Structures élémentaires de contrôle Algorithmique (rappels

1
Structures élémentaires de
contrôle
Joël Quinqueton
Dépt MIAp, UFR IV
UPV - Université Montpellier III
Algorithmique (rappels)
•La cohérence du programme (du contenu)
n'est pas examinée ou évaluée par le
compilateur
•L'analyse du problème à traiter, la preuve de
la cohérence et de la pertinence de sa
solution sont préalable à l’écriture du
programme
Algorithmique: la démarche
•On doit
–fixer l'objectif du programme
–établir la liste des données à manipuler et des
opérations à exécuter, et les ordonner.
•La description de la suite des opérations
élémentaires ordonnées capables de
résoudre le problème posé constitue un
algorithme
Structure générale
•Algorithme:
–Imprimer(«!bonjour!»)
•Programme:
Public class essai {
Public static void main(String [] args) {
System.out.println("bonjour");
}
}
Traitement d’une entrée
•Algorithme(entree):
–Imprimer(«!bonjour!»)
–Imprimer(entree)
•Programme:
Public class essai {
Public static void main(String [] args) {
System.out.println("bonjour" + args[0]);
}
}
Condition sur une entrée
•Algorithme(entree):
–Si (entree = «!salut!»)
•Alors imprimer(«!bonjour!»)
•Sinon imprimer(entree)
•Programme:
Public class essai {
Public static void main(String [] args) {
if (args[0].equals("salut"))
system.out.println("bonjour");
else system.out.println(args[0]);
}
}

2
Boucle itérative
•Calcul de la somme des entiers de 1 à 10:
–Somme = 0, entier=0
–Tant que (entier < 10)
•Somme = Somme + entier, entier = entier + 1
–imprimer(Somme)
•Programme:
Public class essai {
Public static void main(String [] args) {
int somme = 0; int i = 0;
while (i < 10)
somme = somme + i;
i = i + 1;
system.out.println("resultat = " + somme);
}
}
Boucle itérative «!for!»
•Calcul de la somme des entiers de 1 à 10:
–Somme = 0
–Tant que (entier < 10)
•Somme = Somme + entier
–imprimer(Somme)
•Programme:
Public class essai {
Public static void main(String [] args) {
int somme = 0;
for(int i = 0; i < 10; i++)
somme = somme + i;
system.out.println("resultat = " + somme);
}
}
Algorithmique
•Techniques de tris élémentaires
–Qu'est-ce qu'un tri?
–On suppose qu'on se donne une suite de N nombres
entiers et on veut les ranger en ordre croissant au sens
large.
Ainsi, pour N = 10, la suite
18, 3, 10, 25, 9, 3, 11, 13, 23, 8
devra devenir
3, 3, 8, 9, 10, 11, 13, 18, 23, 25
Tri par sélection
•On trie N nombres entiers, rangés dans un
tableau
•Tri par sélection (le plus simple)
–Trouver l'emplacement de l'élément le plus petit
du tableau : l'entier m tel que, pour tout i, am ≤
ai
–On échange les éléments a1 et am
–Puis on recommence ces opérations sur la suite
a2, a3, ..., aN
Tri par sélection
•Cette solution utilise la solution à un sous-
problème
–La recherche de la position du plus petit
élément d’un tableau
indElmtMin = 0 // pos de l’élmt min courant
j = 0
tant que j < N faire {
si (T[j] < T[indElmtMin])
alors indElmtMin = j
j = j + 1
}
Tri par sélection
18, 3, 10, 25, 9, 3, 11, 13, 23, 8
indElmtMin
j
18, 3, 10, 25, 9, 3, 11, 13, 23, 8
indElmtMin
j

3
Tri par sélection
18, 3, 10, 25, 9, 3, 11, 13, 23, 8
indElmtMin
j
18, 3, 10, 25, 9, 3, 11, 13, 23, 8
indElmtMin
j
Tri par sélection
triSelection {
min = 0
i = 0
tant que i < N - 1 faire {
min = i
j = i + 1
tant que j < N faire {
si (T[j] < T[min]) alors min = j
j = j + 1
}
echanger(i, min)
i = i + 1
}
Tri par sélection
18, 3, 10, 25, 9, 3, 11, 13, 23, 8
3, 18, 10, 25, 9, 3, 11, 13, 23, 8
3, 3, 10, 25, 9, 18, 11, 13, 23, 8
Tri par sélection
triSelection {
min = 0
i = 0
tant que i < N - 1 faire {
min = i
j = i + 1
tant que j < N faire {
si (T[j] < T[min]) alors min = j
j = j + 1
}
echanger(i, min)
i = i + 1
}
Tri par sélection
triSelection {
t, min = 0
i = 0
tant que i < N - 1 faire {
min = i
j = i + 1
tant que j < N faire {
si (T[j] < T[min]) alors min = j
j = j + 1
}
t = T[j], T[j] = T[min], T[min] = t
i = i + 1
}
Tri par sélection
•Ses performances ?
–Evaluation du coût de l!’algorithme
–Combien d’opérations doit-on effectuer pour
trier un tableau de N entiers ?

4
Tri par sélection
triSelection {
t, min = 0
i = 0
tant que i < N - 1 faire {
min = i
j = i + 1
tant que j < N faire {
si (T[j] < T[min]) alors min = j
j = j + 1
}
t = T[j], T[j] = T[min], T[min] = t
i = i + 1
}
N échanges:
Tri par sélection
triSelection {
t, min = 0
i = 0
tant que i < N - 1 faire {
min = i
j = i + 1
tant que j < N faire {
si (T[j] < T[min]) alors min = j
j = j + 1
}
t = T[j], T[j] = T[min], T[min] = t
i = i + 1
}
N-i comparaisons:
Tri par sélection
•Coût de l’algorithme
2
)1(
1
2
0
-
=--+ Â
-
=
NN
iNN
N
i
Echanges
Comparaisons
Tri par sélection
•Coût de l’algorithme
Taille du tableau
Temps
d’exécution