Table des matières 1 Tri par insertion 1 Tri fusion.1 Principe........................... Algorithme de fusion....................3 Algorithme du tri par fusion............... 4 3 Tri rapide (quick sort) 5 3.1 Algorithme du pivot................... 5 3. Algorithme de tri rapide................. 6 4 Application : recherche de la médiane dans une liste 7 But : étudier trois algorithmes qui permettent de trier les différents éléments d un tableau. On note A[0...n 1] un tableau contenant n éléments qui peuvent être des entiers, des réels ou, plus généralement, toute collection de valeurs sur lesquelles on peut définir une relation d ordre total. En pratique nous allons étudier des tableaux d entiers positifs. On peut accéder à chaque élément du tableau au moyen de son indice : entier i [[0...n - 1]]. A[i] désigne le (i + 1) ème élément du tableau. A[0] est le premier élément du tableau et A[n 1] le dernier. La convention adoptée pour les indices est celle que Python utilise pour les listes ou les tableaux numpy. 1 Tri par insertion Cet algorithme s inspire du tri que fait un joueur de cartes lors de la distribution du jeu. Les cartes qu il a en main sont déjà triées, la plus petite étant à gauche et la plus grande à droite. Lorsqu on lui distribue une nouvelle carte, il va l insérer à sa place en la comparant aux plus grandes valeurs de son jeu. Supposons que la prochaine "carte" à insérer à la bonne place soit A[i]. On suppose que le sous-tableau A[0...i 1] est déjà trié. L idée est de créer un trou à l emplacement où se trouve A[i] en la sauvegardant temporairement dans une variable temp. On compare A[i 1] et A[i]. Si A[i 1] A[i] c est terminé et on remet temp à sa place. Si A[i 1] > A[i] on décale le contenu A[i 1] dans la case libre A[i], ce qui déplace le trou vers la gauche du tableau. On recommence en comparant A[i ] avec A[i]. Le processus s arrête lorsque on a trouvé k tel que A[i k] A[i] ou si on atteint A[0]. On recommence tout le processus avec la nouvelle carte à insérer, c est à dire A[i + 1]. 1
Précondition : n > 1 # Au moins éléments dans le tableau Tri fusion fonction TRI_INSERTION(A, n) : 1. pour i allant de 1 à n 1 faire :. temp = A[i] 3. j = i # j est l indice du trou dans le tableau 4. tant que { j > 0 et A[j 1] > temp } faire : 5. A[j] = A[j 1] 6. j = j 1 7. A[j] = temp Intérêt : Le tri se fait sur place c est à dire à l intérieur même du tableau. Pas besoin de réserver un espace mémoire supplémentaire. Réalisation 1. Écrire cet algorithme en langage Python et le tester avec la liste proposée sur le site mp1.. En vous aidant du tableau ci-dessous, calculer la complexité temporelle de cette fonction dans le meilleur des cas, puis dans le pire des cas (à définir). fonction TRI_INSERTION(A, n) Coût Nbre de fois 1 pour i allant de 1 à n-1 : c 1 temp = A[i] c 3 j = i c 3 4 tant que ( j > 0 et A[j - 1] > temp ) : c 4 5 A[j] =A[j - 1] c 5 6 j = j - 1 c 6 7 A[j] = temp c 7.1 Principe Le tri fusion est un exemple du paradigme diviser pour résoudre. Cela consiste à prendre un problème et à le diviser en deux sous - problèmes plus simples à résoudre. On utilise ensuite les deux solutions pour résoudre le problème initial Prenons l exemple d un jeu de 3 cartes à trier. L idée est de partager ce jeu en deux jeux de 16 cartes (diviser) et de trier séparément ces deux jeux (résoudre). On ré-assemble ensuite chacun des deux jeux, grâce à un algorithme de fusion.. Algorithme de fusion L algorithme le plus important de ce tri est celui qui permet la fusion de deux jeux de cartes triés séparément pour n en former qu un dans lequel toutes les cartes sont triées. Dans notre cas, les deux jeux de cartes sont en fait un sous-tableau A[p...q, q + 1,...r] de A, où p q < r. Le premier jeux de carte est représenté par A[p...q] et le second jeu par A[q + 1,..., r]. Chacun est déjà trié séparément, la plus petite valeur étant celle d indice le plus bas et la plus grande valeur celle d indice le plus élevé. On aura donc : A[p] A[p + 1]... A[q] et A[q + 1]... A[r] L algorithme de fusion est écrit dans une fonction FUSION qui prend en argument le tableau A et les trois entiers p, q et r : On commence par "vider" A[p...r] dans deux sous-tableau : G pour tous les éléments allant de A[p] à A[q] et D pour tous les éléments allant de A[q+1] à A[r]. On remplit ensuite à nouveau A[p...r] en comparant chaque élément de G et de D afin de le placer à la bonne place dans A.
fonction FUSION(A, p, q, r) : Variables locales : tableaux d entiers G[0...q p + 1], D[0...r q] 1 pour i allant de 0 à q p faire : G[i] = A[p + i] 3 pour j allant de 0 à r q 1 faire : 4 D[j] = A[q + j + 1] 5 G[q p + 1] = 6 D[r q] = 7 i = 0 8 j = 0 9 pour k allant de p à r faire : 10 si G[i] D[j] faire : 11 A[k] = G[i] 1 i = i + 1 13 sinon : 14 A[k] = D[j] 15 j = j + 1 Aux lignes 5 et 6, on a recours à une astuce qui consiste à placer une valeur appelée à la fin des tableaux G et D : en pratique, c est une valeur strictement supérieure à toutes les valeurs du tableau A qui fait office de "butée" ou encore de sentinelle. Cela évite d avoir à introduire un test au sein de la boucle "pour" destiné à savoir quand on atteint la fin d un de ces deux tableaux. Les lignes 7, 8 et 9 introduisent 3 entiers i, j et k qui sont les indices des tableaux G, D et A. Pour chaque valeur de k entre p et q, on compare G[i] et D[j] et on place la plus petite des deux valeurs dans A[k]. On augmente ensuite i ou j suivant la valeur qui a été transférée. Le processus est réitéré pour toutes les valeurs de k variant de p à r, grâce à la boucle pour, ligne 9. 1. Écrire la fonction FUSION en Python. À l aide du tableau ci-dessous, montrer que sa complexité temporelle T(n), avec n = r p + 1 (nombre d éléments du sous tableau A[p...r] est O(n). fonction FUSION(A, p, q, r) : Coût Nbre de fois 1 pour i allant de 0 à q p : c 1 G[i] = A[p + i] c 3 pour j allant de 0 à r q : c 3 4 D[j] = A[q + j + 1] c 4 5 G[q p + 1] = infini c 5 6 D[r q] = infini c 6 7 i = 0 c 7 8 j = 0 c 8 9 pour k allant de p à r : c 9 10 si G[i] D[j] : c 10 11 A[k] = G[i] c 11 1 i = i + 1 c 1 13 sinon : 0 14 A[k] = D[j] c 14 15 j = j + 1 c 15 3
.3 Algorithme du tri par fusion Soit à trier le sous-tableau A[p...r] (p r) extrait de A[0...n 1]. La fonction TRI_FUSION, prend en paramètres le tableau A et les deux entiers p et r. Elle utilise le paradigme "diviser pour résoudre", c est à dire qu elle va séparer A[p...q] en deux tableaux de tailles à peu près identique qu elle va trier séparément, avec une approche purement récursive. fonction TRI_FUSION(A, p, r) : 1. si p < r faire : ( ) p + r. q = E 3. TRI_FUSION(A, p, q) 4. TRI_FUSION(A, q + 1, r) 5. FUSION(A, p, q, r) La ligne 1 teste si p < r. Dans le cas contraire, on a soit une absurdité (r < p), soit il n y a rien à trier (p == r) puisque le soustableau ne renferme alors qu un seul élément. ( ) p + q À la ligne, on définit l entier q = E (partie entière) ce qui permet de diviser A[p...r] en deux sous tableaux de tailles égales ou environ égales : A[p..q] et A[q + 1...r] : diviser. La fonction s appelle ensuite de façon récursive lignes 3 et 4 pour trier les deux sous-tableaux obtenus : résoudre. Le tri du tableau entier se fait en appelant la fonction TRI_FUSION(A, 0, n 1). 1. Écrire cette fonction en Python et la tester sur la liste fournie sur le site mp1.. Dessiner l arbre des appels récursifs de la fonction TRI_FUSION pour A = [7, 3, 1, 8, 4]. 3. En vous aidant du tableau ci-dessous et en supposant que n = r p + 1 est toujours divisible par (hypothèse simplificatrice mais efficace), montrer que sa complexité temporelle T (n) vérifie l équation (approchée) : T (n) = T ( n ) + O(n) 4. En posant n = p et en étudiant la suite u p = T (p ) p, résoudre cette équation de récurrence et montrer que T (n) = O(n lg(n) ) où lg est le logarithme en base. fonction TRI_FUSION(A, p, r) : Coût Nbre de fois 1 si p < r : c 1 q = E( (p + r)/ ) c 3 TRI_FUSION(A, p, q) 4 TRI_FUSION(A, q + 1, r) 5 FUSION(A, p, q, r) À la ligne 5, on ré-assemble enfin les deux sous-tableaux triés grâce à la fonction FUSION étudiée à la section précédente. 4
3 Tri rapide (quick sort) Le tri rapide est très souvent utilisé, bien que ce ne soit pas le meilleur en terme de complexité temporelle. Comme le tri par fusion, il fonctionne lui aussi sur le principe diviser pour résoudre et sur l approche purement récursive. En voici le principe : On commence par choisir une valeur particulière du tableau qu on appelle le pivot. On ré-ordonne ensuite le tableau en plaçant toutes les valeurs < pivot à gauche de celui-ci et toutes les valeurs > pivot à droite de celui-ci. L algorithme PIVOT se charge de faire cela. À la fin de l algorithme précédent, le pivot est à la bonne place dans le tableau. Soit ind_p son indice. Le tableau A est ensuite divisé en deux sous-tableaux A[0...ind_p 1] et A[ind_p + 1...n 1] à qui on va appliquer séparément l algorithme PIVOT : on recommence le premier point avec chacun des deux sous-tableaux, selon une approche récursive. 3.1 Algorithme du pivot Prenons un tableau A[0...n 1] contenant n > 1 éléments entiers positifs que l on souhaite trier. Pour des raisons qui vont apparaître plus tard, on va commencer par s intéresser au sous-tableau A[p...q] délimité par les indices p et q, vérifiant : 0 p < q n 1 On choisit comme pivot de ce sous tableau A[p...q] son dernier élément A[q]. La fonction PIVOT ci-dessous permet de réordonner les éléments A[p], A[p + 1],..., A[q] en plaçant toutes les valeurs inférieures au pivot à gauche de celui-ci et toutes les valeurs supérieures au pivot à droite. Elle retourne l indice ind_p du pivot, après que A[p...q] ait été ré-ordonné. fonction PIVOT(A, p, q) : 1 si p < q : pivot = A[q] 3 temp = A[p] 4 min = p 5 max = q 6 tant que min < max : 7 si temp > pivot : 8 A[max] = temp 9 max = max - 1 10 temp = A[max] 11 sinon : 1 A[min] = temp 13 min = min + 1 14 temp = A[min] 15 A[min] = pivot 16 retourner min 17 sinon : 18 retourner 1 À la ligne 1, on place une condition p < q pour lancer l algorithme. En effet, si p > q, c est absurde et si p == q, A ne contient qu un seul élément et il n est pas nécessaire de le réordonner. Dans ce cas l indice retourné vaut 1 : cette valeur ne pouvant pas être celle d un indice, cela permet de placer une sentinelle dans le programme. Ligne, le pivot choisi est toujours A[q], valeur de plus haut indice et on crée un trou dans A en sauvegardant cette valeur dans la 5
variable pivot. À la ligne 3, on crée un deuxième trou dans A en sauvegardant temporairement A[p] dans une autre variable, nommée temp. Les indices des deux trous sont appelés min et max. Ces indices vont varier au cours de la progression de l algorithme. Au début, min vaut p et max est égal à q (initialisation). À partir de la ligne 6, on s engage dans une boucle qui ne va s arrêter que lorsque min sera égal à max, avec deux options : si... sinon... Si temp > pivot, on place la valeur contenue dans temp dans A[max] et on diminue max d une unité : le trou indicé par max se déplace donc vers la gauche. On crée alors un nouveau trou en max-1 en sauvegardant la valeur dans temp. Au contraire, si temp pivot, on place la valeur contenue dans temp dans A[min] puis on augmente min d une unité : le trou se déplace donc vers la droite. On crée alors un nouveau trou en min + 1 en sauvegardant la valeur dans temp. À la ligne 15, tous les éléments du tableau sont correctement positionnés et il reste un seul trou d indice min == max. Il ne reste plus qu à remettre l élément pivot à cette position. La fonction retourne alors l indice du pivot (ou 1). 1. Écrire la fonction PIVOT en Python.. En vous aidant du tableau ci-contre, montrer que sa complexité temporelle T (n) où n = q p + 1 est le nombre d éléments du sous-tableau A[p...q] vérifie T (n) = O(n). fonction PIVOT(A, p, q) Coût Nbre de fois 1 si p < q : c 1 pivot = A[q] c 3 temp = A[p] c 3 4 min = p c 4 5 max = q c 5 6 tant que min < max : c 6 7 si temp > pivot : c 7 8 A[max] = temp c 8 9 max = max - 1 c 9 10 temp = A[max] c 10 11 sinon : 0 1 A[min] = temp c 1 13 min = min + 1 c 13 14 temp = A[min] c 14 15 A[min] = pivot c 15 16 retourner min c 16 17 sinon : 0 18 retourner 1 c 18 3. Algorithme de tri rapide Voici maintenant l algorithme du tri rapide. Il est écrit sous la forme d une fonction TRI_RAPIDE(A, p, q) qui prend comme paramètres un tableau A[0...n 1] et les deux entiers p et q qui délimitent le sous-tableau A[p...q] qui va être trié. À la ligne 1, la fonction PIVOT est appelée. Elle ré-ordonne A[p...q] et place le pivot à la bonne position : tous les éléments de A[p...q] inférieurs au pivot sont à sa gauche et tous ceux qui 6
sont supérieurs au pivot sont à sa droite. On récupère l indice du pivot dans la variable ind_p. Il ne reste plus qu à trier les deux sous-tableaux A[p...ind_p 1] et A[ind_p + 1...q], ce qui est fait aux lignes 3 et 4 en appelant la fonction TRI_RAPIDE de façon récursive. fonction TRI_RAPIDE(A, p, q) : 1 ind_p = PIVOT(A, p, q) si ind_p!= 1 : 3 TRI_RAPIDE(A, p, ind_p 1) 4 TRI_RAPIDE(A, ind_p + 1, q) ˆL = [ˆx 0,..., ˆx n 1 ] formée des mêmes éléments écrits dans l ordre croissant. Lorsque n = p + 1 est impair, la valeur médiane est la valeur ˆx p pour laquelle il existe p éléments strictement plus petits et p éléments strictement plus grands. Lorsque n = p est pair, on appelle valeurs médianes les deux éléments ˆx p 1 et ˆx p. considérons une liste A non triée composée de n éléments tous distincts deux à deux. Écrire une fonction MEDIANE(A) qui retourne la valeur ou les valeurs médianes de A et dont la complexité soit en O(n lg n). Si vous voulez trier le tableau entier A[0.. n 1] tout entier, il suffit d appeler la fonction TRI_RAPIDE(A, 0, n 1). 1. Écrire cette fonction en Python et vérifier son fonctionnement sur la liste exemple du site mp1.. Dessiner l arbre des appels récursifs lorsque A = [7, 3, 1, 8, 4]. On peut montrer que la complexité temporelle T (n) de cette fonction est O(n ) dans le pire des cas et O(n lg(n) ) dans le meilleur des cas. 4 Application : recherche de la médiane dans une liste Soit L = [x 0,..., x n 1 ] une liste de n valeurs distinctes appartenant à un ensemble totalement ordonnée. On lui associe la liste triée 7