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

Algorithmique (rappels)
Joël Quinqueton
Dépt MIAp, UFR IV
UPV - Université Montpellier III
• 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
Structure générale
Structures élémentaires de
contrôle
• 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
• Algorithme:
– Imprimer(«!bonjour!»)
• Programme:
Public class essai {
Public static void main(String [] args) {
System.out.println("bonjour");
}
}
Traitement d’une entrée
• Algorithme(entree):
Condition sur une entrée
• Algorithme(entree):
– Si (entree = «!salut!»)
– Imprimer(«!bonjour!»)
– Imprimer(entree)
• Alors imprimer(«!bonjour!»)
• Sinon imprimer(entree)
• Programme:
• Programme:
Public class essai {
Public class essai {
Public static void main(String [] args) {
Public static void main(String [] args) {
if (args[0].equals("salut"))
System.out.println("bonjour" + args[0]);
system.out.println("bonjour");
}
else system.out.println(args[0]);
}
}
}
1
Boucle itérative
• Calcul de la somme des entiers de 1 à 10:
Boucle itérative «!for!»
• Calcul de la somme des entiers de 1 à 10:
– Somme = 0, entier=0
– Tant que (entier < 10)
– Somme = 0
– Tant que (entier < 10)
• Somme = Somme + entier, entier = entier + 1
• Somme = Somme + entier
– imprimer(Somme)
– imprimer(Somme)
• Programme:
• Programme:
Public class essai {
Public class essai {
Public static void main(String [] args) {
int somme = 0; int i = 0;
while (i < 10)
Public static void main(String [] args) {
int somme = 0;
for(int i = 0; i < 10; i++)
somme = somme + i;
i = i + 1;
system.out.println("resultat =
}
somme = somme + i;
"
system.out.println("resultat =
+ somme);
}
– 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 sousproblè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
}
+ somme);
}
Algorithmique
• Techniques de tris élémentaires
"
}
Tri par sélection
indElmtMin
18, 3, 10, 25, 9, 3, 11, 13, 23, 8
j
indElmtMin
18, 3, 10, 25, 9, 3, 11, 13, 23, 8
j
2
Tri par sélection
indElmtMin
18, 3, 10, 25, 9, 3, 11, 13, 23, 8
j
indElmtMin
18, 3, 10, 25, 9, 3, 11, 13, 23, 8
j
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 {
t, min = 0
i = 0
tant que i < N
min = i
j = i + 1
tant que j <
si (T[j] <
j = j + 1
}
t = T[j], T[j]
i = i + 1
}
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 {
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
• Ses performances ?
- 1 faire {
– Evaluation du coût de l!’algorithme
– Combien d’opérations doit-on effectuer pour
trier un tableau de N entiers ?
N faire {
T[min]) alors min = j
= T[min], T[min] = t
3
Tri par sélection
triSelection {
t, min = 0
i = 0
tant que i < N
min = i
j = i + 1
tant que j <
si (T[j] <
j = j + 1
}
t = T[j], T[j]
N échanges:
i = i + 1
}
Tri par sélection
- 1 faire {
N faire {
T[min]) alors min = j
= T[min], T[min] = t
triSelection {
t, min = 0
i = 0
tant que i < N
min = i
j = i + 1
tant que j <
si (T[j] <
N-i comparaisons:
j = j + 1
}
t = T[j], T[j]
i = i + 1
}
Tri par sélection
- 1 faire {
N faire {
T[min]) alors min = j
= T[min], T[min] = t
Tri par sélection
• Coût de l’algorithme
• Coût de l’algorithme
N -2
N + Â N - i - 1 = N ( N - 1)
i =0
2
Temps
d’exécution
Echanges
Comparaisons
Taille du tableau
4