COURS 4 TRIS DE TABLEAUX Fabien HOSPITAL CPGE

COURS 4 : TRIS DE TABLEAUX Fabien HOSPITAL – CPGE PCSI//PSI/PC/MP– Lycée Bellevue Toulouse -- fabien. hospi@gmail. com

1. 2. INTRODUCTION LES METHODES « SIMPLES » 2. 1. Tri par sélection 2. 2. Tri à bulles (Bubble sort) 2. 3. Tri par insertion 3. LE TRI RAPIDE « QUICK SORT » 4. LE TRI FUSION 5. LE TRI TAS … ARBRE DE HUFFMAN 6. SYNTHESE Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 2

1. 2. 3. 4. 5. 6, 1. INTRODUCTION Un algorithme de tri permet d'organiser une collection d'objets selon un ordre déterminé. faciliter les recherches ultérieures d’un élément dans une liste (recherche dichotomique) de valeurs numériques = tableau à une dimension. Pour trier des chaînes de caractères (mots), il suffit d’associer une valeur numérique à chaque caractère (code ASCII par exemple). Programme : tri par insertion, du tri rapide et du tri fusion. La plupart des algorithmes de tri sont fondés sur des comparaisons successives la complexité de l’algorithme a le même ordre de grandeur que le nombre de comparaisons entre les données faites par l’algorithme. http: //www. laboiteverte. fr/algorithmes-tri-visualises-danses-folkloriques/ Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 3

1. 2. 3. 4. 5. 6, 2. LES MÉTHODES « SIMPLES » 2. 1. Tri par sélection On recherche le plus grand élément que l'on va replacer à sa position finale, c'est-à -dire en dernière position. Puis on recherche le second plus grand élément que l'on va placer en avantdernière position, etc. , jusqu'à ce que le tableau soit entièrement trié. PYTHO N Données : tableau T entre les indices 1 et n. def echange(l, i, j): # echange 2 valeurs d'une liste l[i], l[j] = l[j], l[i] def tri_selection(l): Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 4

1. 2. 3. 4. 5. 6, 2. LES MÉTHODES « SIMPLES » 2. 1. Tri par sélection PYTHO N On recherche le plus grand élément que l'on va replacer à sa position finale, c'est-à -dire en dernière position. Puis on recherche le second plus grand élément que l'on va placer en avantdernière position, etc. , jusqu'à ce que le tableau soit entièrement trié. def echange(l, i, j): # echange 2 valeurs d'une liste l[i], l[j] = l[j], l[i] def tri_selection(l): for i in range(len(l)-1): mini=i for j in range(i+1, len(l)): if l[j]<l[mini]: mini=j echange(l, i, mini) Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 5

1. 2. 3. 4. 5. 6, 2. LES MÉTHODES « SIMPLES » 2. 1. Tri par sélection Complexité • Meilleur des cas : O(n 2 ) quand le tableau est déjà trié. • Pire cas : O(n 2 ) quand le tableau est trié en ordre inverse. • En moyenne : O(n 2 ) Ce n’est donc pas un tri très efficace, mais en revanche c’est un tri très simple. Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 6

1. 2. 3. 4. 5. 6, 2. LES MÉTHODES « SIMPLES » 2. 2. Tri bulles • L'algorithme parcourt la liste, et compare les couples d'éléments successifs • On fait ainsi remonter le terme le plus petit (les bulles plus légéres remontent le plus vite à la surface. . . ). PYTHO N • Lorsque deux éléments successifs ne sont pas dans l’ordre croissant, ils sont échangés. def echange(l, i, j): # echange 2 valeurs d'une liste l[i], l[j] = l[j], l[i] def tri_abulles(l): Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 7

1. 2. 3. 4. 5. 6, 2. LES MÉTHODES « SIMPLES » 2. 2. Tri bulles • L'algorithme parcourt la liste, et compare les couples d'éléments successifs en commençant par la fin de la liste • On fait ainsi remonter le terme le plus petit (les bulles plus légéres remontent le plus vite à la surface. . . ). PYTHO N • Lorsque deux éléments successifs ne sont pas dans l’ordre croissant, ils sont échangés. def echange(l, i, j): # echange 2 valeurs d'une liste l[i], l[j] = l[j], l[i] def tri_abulles(l): Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 8

1. 2. 3. 4. 5. 6, 2. LES MÉTHODES « SIMPLES » 2. 2. Tri bulles • L'algorithme parcourt la liste, et compare les couples d'éléments successifs. • Lorsque deux éléments successifs ne sont pas dans l'ordre croissant, ils sont échangés. PYTHO N def echange(l, i, j): # echange 2 valeurs d'une liste l[i], l[j] = l[j], l[i] def tri_abulles(l): for i in range(len(l)): for j in reversed(range(i, len(l))) : #range(len(l)-1, i-1, -1) if l[j]<l[j-1]: echange(l, j-1, j) Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 9

1. 2. 3. 4. 5. 6, 2. LES MÉTHODES « SIMPLES » 2. 2. Tri bulles Cet algorithme est souvent enseigné en tant qu'exemple algorithmique. complexité en O(n 2 ) dans le pire des cas (où n est la longueur de la liste), parmi les mauvais algorithmes de tri. Il n'est donc quasiment pas utilisé en pratique Complexité Meilleur cas : O(n) quand le tableau est trié. Il ne fait que n comparaisons pour n valeurs à trier (en réalité, pour des raisons d'intervalles, il n'en fait que n-1). Pire des cas : O(n 2 ) quand le tableau est trié en ordre inverse (n− 1)·(n− 1) = O(n²) Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 10

1. 2. 3. 4. 5. 6, 2. LES MÉTHODES « SIMPLES » 2. 3. Tri par insertion Soit un paquet de « n » cartes. On prend la première dans une main. On saisie la seconde carte et on l’insère avant ou après la première selon le cas. A l’étape « i » , la ième carte est insérée à sa place dans le paquet déjà trié. Pour cela, on peut : • méthode 1 : partir du début du tas déjà trié et s’arrêter lorsque l’on rencontre une carte plus grande que la ième , • méthode 2 : partir de la fin du tas déjà trié, et s’arrêter si l’on rencontre une carte plus petite que la ième. Le paquet contient alors « i » cartes triées. On procède ainsi de suite jusqu’à la dernière carte. Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 11

1. 2. 3. 4. 5. 6, 2. LES MÉTHODES « SIMPLES » 2. 3. Tri par insertion Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 12

1. 2. 3. 4. 5. 6, 2. LES MÉTHODES « SIMPLES » 2. 3. Tri par insertion Algorithme : Tri par insertion (fonction Tri_insertion) Données : T : un tableau de valeurs num [1. . n] ; Résultat : le tableau T trié par ordre croissant PYTHO N def Tri_insertion( ) : Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 13

1. 2. 3. 4. 5. 6, 2. LES MÉTHODES « SIMPLES » 2. 3. Tri par insertion PYTHO N Algorithme : Tri par insertion (fonction Tri_insertion) Données : T : un tableau de valeurs num [1. . n] ; Résultat : le tableau T trié par ordre croissant def Tri_insertion( L ) : for i in range(1, len(L)): x=L[i] j=0 while j<=i-1 and L[j]<x: j=j+1 for k in range(i-1, j-1, -1): #on echange les positions L[k+1]=L[k] L[j]=x return L Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 14

1. 2. 3. 4. 5. 6, 2. LES MÉTHODES « SIMPLES » 2. 3. Tri par insertion Complexité : Meilleur des cas : le tableau est déjà trié. Il y a donc n – 1 comparaisons à effectuer. La complexité est donc de classe linéaire : C(n)=O(n). Dans le pire des cas, le tableau est trié à l’envers. Il y a alors une comparaison à effectuer à la première étape, puis deux, … puis n-1. On en déduit donc un nombre total de comparaisons. La complexité est donc de classe quadratique : C(n)=O(n 2). Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 15

1. 2. 3. 4. 5. 6, 2. LES MÉTHODES « SIMPLES » 2. 3. Tri par insertion Algorithme : Tri par insertion méthode 2 (Tri_inser 2) Données : T : un tableau de valeurs num [1. . n] ; Résultat : le tableau T trié par ordre croissant def Tri_inser 2( L ) : PYTHO N for i in range(1, len(L)): x=L[i] j=i while j>0 and L[j-1]>x: L[j]=L[j-1] j=j-1 L[j]=x Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com return L 16

1. 2. 3. 4. 5. 6, 2. LES MÉTHODES « SIMPLES » 2. 3. Tri par insertion On peut aussi montrer que la complexité en moyenne est de classe quadratique lorsque les permutations sont équiprobables. L’efficacité du tri par insertion est excellente lorsque le tableau est déjà trié ou « presque trié » (C(n)=O(n)). Il surpasse alors toutes les autres méthodes de tri qui sont au mieux en O(n ln(n)). Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 17

1. 2. 3. 4. 5. 6, 3. TRI RAPIDE « QUICK SORT » Tri de valeurs numériques Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 18

1. 2. 3. 4. 5. 6, 3. TRI RAPIDE « QUICK SORT » Dans le pire des cas, un des deux segments est vide à chaque appel de la fonction de tri. Cela arrive lorsque le tableau est déjà trié. Le nombre de données à traiter pour le ième appel, est n – i + 1. On peut aussi écrire une relation de récurrence du type C(n) = C(n-1) + n - 1 La complexité est donc de classe quadratique C(n) = O(n 2). Dans le meilleur des cas, les deux segments sont de taille égale. Pour un nombre de données à traiter n, chacun des segments suivant a donc au plus (n-1)/2 éléments (on retire le pivot). On répète ainsi la segmentation des tableaux jusqu’à arriver au plus à un seul élément. On peut écrire une relation de récurrence du type C(n) = 2 C((n - 1) / 2) + n - 1. La complexité est donc de classe quasi linéaire C(n)=O(n ln(n)). Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 19

1. 2. 3. 4. 5. 6, 3. TRI RAPIDE « QUICK SORT » Dans le pire des cas, un des deux segments est vide à chaque appel de la fonction de tri. Cela arrive lorsque le tableau est déjà trié. Le nombre de données à traiter pour le ième appel, est n – i + 1. On peut aussi écrire une relation de récurrence du type C(n) = C(n-1) + n - 1 La complexité est donc de classe quadratique C(n) = O(n 2). Dans le meilleur des cas, les deux segments sont de taille égale. Pour un nombre de données à traiter n, chacun des segments suivant a donc au plus (n-1)/2 éléments (on retire le pivot). On répète ainsi la segmentation des tableaux jusqu’à arriver au plus à un seul élément. On peut écrire une relation de récurrence du type C(n) = 2 C((n - 1) / 2) + n - 1. La complexité est donc de classe quasi linéaire C(n)=O(n ln(n)). Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 20

1. 2. 3. 4. 5. 6, 3. TRI RAPIDE « QUICK SORT » Dans le pire des cas, un des deux segments est vide à chaque appel de la fonction de tri. Cela arrive lorsque le tableau est déjà trié. Le nombre de données à traiter pour le ième appel, est n – i + 1. On peut aussi écrire une relation de récurrence du type C(n) = C(n-1) + n - 1 La complexité est donc de classe quadratique C(n) = O(n 2). Dans le meilleur des cas, les deux segments sont de taille égale. Pour un nombre de données à traiter n, chacun des segments suivant a donc au plus (n-1)/2 éléments (on retire le pivot). On répète ainsi la segmentation des tableaux jusqu’à arriver au plus à un seul élément. On peut écrire une relation de récurrence du type C(n) = 2 C((n - 1) / 2) + n - 1. La complexité est donc de classe quasi linéaire C(n)=O(n ln(n)). Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 21

1. 2. 3. 4. 5. 6, 3. TRI RAPIDE « QUICK SORT » Notion de complexité Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 22

1. 2. 3. 4. 5. 6, 3. TRI RAPIDE « QUICK SORT » Dans le pire des cas, un des deux segments est vide à chaque appel de la fonction de tri. Cela arrive lorsque le tableau est déjà trié. Le nombre de données à traiter pour le ième appel, est n – i + 1. On peut aussi écrire une relation de récurrence du type C(n) = C(n-1) + n - 1 La complexité est donc de classe quadratique C(n) = O(n 2). Dans le meilleur des cas, les deux segments sont de taille égale. Pour un nombre de données à traiter n, chacun des segments suivant a donc au plus (n-1)/2 éléments (on retire le pivot). On répète ainsi la segmentation des tableaux jusqu’à arriver au plus à un seul élément. On peut écrire une relation de récurrence du type C(n) = 2 C((n - 1) / 2) + n - 1. La complexité est donc de classe quasi linéaire C(n)=O(n ln(n)). Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 23

1. 2. 3. 4. 5. 6, 3. TRI RAPIDE « QUICK SORT » Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 24

1. 2. 3. 4. 5. 6, 3. TRI RAPIDE « QUICK SORT » PYTHO N Algorithme : Segmentation (fonction Segmente) Données : T : un tableau de valeurs num [1. . n] ; i, j : les indices de début et de fin de la segmentation à effectuer Résultat : le tableau T « segmenté » avec le pivot à sa place définitive, l’indice de la place du pivot def Segmente( T , i , j ) : Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 25

1. 2. 3. 4. 5. 6, 3. TRI RAPIDE « QUICK SORT » PYTHO N Algorithme : Segmentation (fonction Segmente) Données : T : un tableau de valeurs num [1. . n] ; I , j : les indices de début et de fin de la segmentation à effectuer Résultat : le tableau T « segmenté » avec le pivot à sa place définitive, l’indice de la place du pivot def Segmente( T , i , j ) : g=i+1 d=j p=T[i] while g<=d : while d>=0 and T[d]>p: d=d-1 while g<=j and T[g]<=p: g=g+1 if g<d: echange(T, g, d) d=d-1 g=g+1 k=d echange(T, i, d) 26 Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com return k

1. 2. 3. 4. 5. 6, 3. TRI RAPIDE « QUICK SORT » Complexité : Le nombre de comparaisons : égal dans meilleur des cas à n – 1. La complexité de cet algorithme est donc au mieux de classe linéaire : C(n)=O(n). Dans le pire des cas, tous les éléments sont identiques. La complexité est alors quadratique : C(n)=O(n 2). Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 27

1. 2. 3. 4. 5. 6, 3. TRI RAPIDE « QUICK SORT » Algorithme : Tri rapide (fonction Tri_rapide) Données : T : un tableau de valeurs num [1. . n] ; i, j : les indices de début et de fin de la segmentation à effectuer Résultat : le tableau T trié entre les indices i et j compris PYTHO N def Tri_rapide( ) : Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 28

1. 2. 3. 4. 5. 6, 3. TRI RAPIDE « QUICK SORT » PYTHO N Algorithme : Tri rapide (fonction Tri_rapide) Données : T : un tableau de valeurs num [1. . n] ; i, j : les indices de début et de fin de la segmentation à effectuer Résultat : le tableau T trié entre les indices i et j compris def Tri_rapide(T, i, j): if i<j: k=segmente(T, i, j) Tri_rapide(T, i, k-1) Tri_rapide(T, k+1, j) return T Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 29

1. 2. 3. 4. 5. 6, 3. TRI RAPIDE « QUICK SORT » Cette méthode de tri est très efficace lorsque les données sont distinctes et non ordonnées. La complexité est alors globalement en O(n ln(n)). Lorsque le nombre de données devient petit (<15) lors des appels récursifs de la fonction de tri, on peut avantageusement le remplacer par un tri par insertion dont la complexité est linéaire lorsque les données sont triées ou presque. Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 30

1. 2. 3. 4. 5. 6, 3. TRI RAPIDE « QUICK SORT » Algorithme : Tri rapide (fonction Tri_rapide) Données : T : un tableau de valeurs num [1. . n] ; i, j : les indices de début et de fin de la segmentation à effectuer Résultat : le tableau T trié entre les indices i et j compris Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 31

1. 2. 3. 4. 5. 6, 3. TRI RAPIDE « QUICK SORT » Algorithme : Tri rapide optimisé (fonction Tri_rapide 2) Données : T : un tableau de valeurs num [1. . n] ; i, j : les indices de début et de fin de la segmentation à effectuer Résultat : le tableau T trié entre les indices i et j compris Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 32

1. 2. 3. 4. 5. 6, 4. TRI FUSION • On coupe en deux parties à peu près égales données à trier. • On trie les données de chaque partie par la méthode de tri fusion. • On fusionne les deux parties en interclassant les données. L’algorithme est donc récursif. Il fait partie des algorithmes « diviser pour régner » . Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 33

1. 2. 3. 4. 5. 6, 4. TRI FUSION Tri de valeurs numériques Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 34

1. 2. 3. 4. 5. 6, 4. TRI FUSION Algorithme : fusion de 2 listes trièes (fonction Fusion) Données : T : un tableau de valeurs numériques [g. . d] les sous-tableaux T[g. . m] et T[m+1. . d] sont ordonnés Résultat : le tableau T de valeurs numériques [g. . d] ordonnées Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 35

1. 2. 3. 4. 5. 6, 4. TRI FUSION Complexité : Cet algorithme a une complexité en temps de classe linéaire : C(n)=O(n). Par contre, il oblige à utiliser un espace supplémentaire égal à la taille du tableau original T. algorithme récursif de tri fusion : PYTHO N Algorithme : Tri fusion (fonction Tri_fusion) Données : T : un tableau de valeurs numériques non triées [g. . d] g, d : les indices de début et de fin de tableau Résultat : le tableau T avec les mêmes valeurs mais triées def Tri_fusion( ) : Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 36

1. 2. 3. 4. 5. 6, 4. TRI FUSION PYTHO N Algorithme : Tri fusion (fonction Tri_fusion) Données : T : un tableau de valeurs numériques non triées [g. . d] g, d : les indices de début et de fin de tableau Résultat : le tableau T avec les mêmes valeurs mais triées def Tri_fusion( T, g , d ) : if g<d: m=(g+d)//2 Tri_fusion(T, g, m) Tri_fusion(T, m+1, d) Fusion(T, g, d, m) return T Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 37

1. 2. 3. 4. 5. 6, 4. TRI FUSION Si l’on s’intéresse au nombre de données à traiter à chaque appel de fonction, la relation de récurrence est du type : C(n) = 2 C(n / 2) + n. La méthode de tri fusion a donc une efficacité temporelle comparable au tri rapide en O(n ln(n)). Par contre, elle n'opère pas en place : une zone temporaire de données supplémentaire de taille égale à celle de l'entrée est nécessaire. Des versions plus complexes peuvent être effectuées sur place mais sont moins rapides. Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 38

1. 2. 3. 4. 5. 6, 5. ARBRE ET TRI TAS Un arbre binaire de recherche Les noeuds appartiennent à un ensemble ordonné Pour tout noeud interne a, les données du sous-arbre gauche de a <= donnée contenue dans le noeud a, qui est elle-même <= aux données contenues dans le sous-arbre droit de a. Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 39

1. 2. 3. 4. 5. 6, 5. ARBRE ET TRI TAS Un arbre binaire de recherche Les noeuds appartiennent à un ensemble ordonné Pour tout noeud interne a, les données du sous-arbre gauche de a <= donnée contenue dans le noeud a, qui est elle-même <= aux données contenues dans le sous-arbre droit de a. La complexité : • dans le pire des cas égale à la profondeur de l’arbre binaire • en moyenne égale à la profondeur moyenne des feuilles de l’arbre binaire. Le tri par arbre binaire de recherche est donc au pire en O(n 2) et en moyenne en O(n ln(n)). Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 40

1. 2. 3. 4. 5. 6, 5. TRI TAS (HUFFMAN) def table_frequences(texte): table = {} for caractere in texte: if caractere in table: table[caractere] = table[caractere] + 1 else: table[caractere] = 1 return table from heapq import * def arbre_huffman (occurrences): # Construction d'un tas avec les lettres sous forme de feuilles tas = [(occ, lettre) for (lettre, occ) in occurrences. items()] heapify(tas) # Création de l'arbre while len(tas) >= 2: occ 1, noeud 1 = heappop(tas) # noeud de plus petit poids occ 1 occ 2, noeud 2 = heappop(tas) # noeud de deuxième plus petit poids occ 2 heappush(tas, (occ 1 + occ 2, {0: noeud 1, 1: noeud 2})) # ajoute au tas le noeud de poids occ 1+occ 2 et avec les fils noeud 1 et noeud 2 return heappop(tas)[1] Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 41

1. 2. 3. 4. 5. 6, 5. TRI TAS (HUFFMAN) def table_frequences(texte): table = {} for caractere in texte: if caractere in table: table[caractere] = table[caractere] + 1 else: table[caractere] = 1 return table from heapq import * def arbre_huffman (occurrences): # Construction d'un tas avec les lettres sous forme de feuilles tas = [(occ, lettre) for (lettre, occ) in occurrences. items()] heapify(tas) # Création de l'arbre while len(tas) >= 2: occ 1, noeud 1 = heappop(tas) # noeud de plus petit poids occ 1 occ 2, noeud 2 = heappop(tas) # noeud de deuxième plus petit poids occ 2 heappush(tas, (occ 1 + occ 2, {0: noeud 1, 1: noeud 2})) # ajoute au tas le noeud de poids occ 1+occ 2 et avec les fils noeud 1 et noeud 2 return heappop(tas)[1] Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 42

1. 2. 3. 4. 5. 6, 5. TRI TAS (HUFFMAN) def code_huffman_parcours(arbre, prefixe, code): for noeud in arbre: if len(arbre[noeud]) == 1: code[prefixe+str(noeud)] = arbre[noeud] else: code_huffman_parcours(arbre[noeud], prefixe+str(noeud), code) def code_huffman(arbre): code = {} code_huffman_parcours(arbre, '', code) return code def encodage(texte, code): code_inv = dict((code[str(bits)], bits) for bits in code) # construit le dictionnaire inverse texte_binaire = ' ' for c in texte: texte_binaire = texte_binaire + code_inv[c] return texte_binaire def decodage(code, texte_binaire): texte = '' tampon = '' for b in texte_binaire: tampon = tampon+b if tampon in code: texte = texte+code[tampon] tampon = '' return texte Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 43

1. 2. 3. 4. 5. 6. SYNTHÈSE Tri de 10000 valeurs numériques générées aléatoirement La simulation a été effectuée pour un tableau de 10000 valeurs numériques générées aléatoirement. Tri Bulle Tri par Insertion Tri par Sélection Tri Fusion Tri Rapide Tri Natif Python (méthode sort) : Temps en secondes 37. 03597636012455 16. 26099099187195 15. 775444085769777 0. 157514432699827 0. 09675168212743301 0. 0075889533436566126 Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 44

1. 2. 3. 4. 5. 6. SYNTHÈSE Tri de 10000 valeurs numériques générées aléatoirement La simulation a été effectuée pour un tableau de 10000 valeurs numériques générées aléatoirement. Tri Bulle Tri par Insertion Tri par Sélection Tri Fusion Tri Rapide Tri Natif Python (méthode sort) : Temps en secondes 37. 03597636012455 16. 26099099187195 15. 775444085769777 0. 157514432699827 0. 09675168212743301 0. 0075889533436566126 Module time Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 45

1. 2. 3. 4. 5. 6. SYNTHÈSE Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 46

1. 2. 3. 4. 5. 6. SYNTHÈSE DISTINGUER PAR LEURS COMPLEXITÉS DEUX ALGORITHMES RÉSOLVANT UN MÊME PROBLÈME : • La première étape consiste à vérifier que les algorithmes résolvent exactement le même problème. • On compare la complexité en temps dans le pire des cas (préférable à l’utilisation du module Time car indépendant de la machine). • Il faut vérifier que le pire des cas peut arriver en situation réelle • Penser à comparer la complexité en espace qui peut permettre de départager des algorithmes équivalents Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 47

1. 2. 3. 4. 5. 6. SYNTHÈSE DISTINGUER PAR LEURS COMPLEXITÉS DEUX ALGORITHMES RÉSOLVANT UN MÊME PROBLÈME : • La première étape consiste à vérifier que les algorithmes résolvent exactement le même problème. • On compare la complexité en temps dans le pire des cas (préférable à l’utilisation du module Time car indépendant de la machine). • Il faut vérifier que le pire des cas peut arriver en situation réelle • Penser à comparer la complexité en espace qui peut permettre de départager des algorithmes équivalents Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 48

1. 2. 3. 4. 5. 6. SYNTHÈSE DISTINGUER PAR LEURS COMPLEXITÉS DEUX ALGORITHMES RÉSOLVANT UN MÊME PROBLÈME : • La première étape consiste à vérifier que les algorithmes résolvent exactement le même problème. • On compare la complexité en temps dans le pire des cas (préférable à l’utilisation du module Time car indépendant de la machine). • Il faut vérifier que le pire des cas peut arriver en situation réelle • Penser à comparer la complexité en espace qui peut permettre de départager des algorithmes équivalents Fabien HOSPITAL – CPGE PCSI//PSIPC/MP – Lycée Bellevue Toulouse -- fabien. hospi@gmail. com 49