C HAPITRE II: S TRUCTURES S ÉQUENTIELLES Université Saad Dahlab – Blida1 Faculté des Sciences Département d’Informatique Licence d’Informatique Semestre 3 (2 ème année) Algorithmique et Structures de Données M me AROUSSI Disponible sur

P LAN DU C HAPITRE III I. Introduction II. Listes Linéaires Chaînées (LLC) III. Files d’Attente (FIFO) IV. Piles (LIFO) 2

3  Une structure séquentielle est un ensemble de variables de même nature organisées séquentiellement auxquelles on peut accéder :  soit directement par leur numéro d’ordre  soit en les parcourant une par une dans l’ordre I NTRODUCTION Structures séquentielles Listes linéaires contigües Tableaux Fichiers séquentiels Listes chaînées Structures séquentielles particulières Files Piles

P ARTIE I: L ISTES L INÉAIRES C HAÎNÉES (LLC)

P LAN DE LA P ARTIE I  Définitions  Modèle des LLC (M LLC )  Algorithmes sur les listes  Listes particulières  Représentation contigüe  Conclusion 5

6  Une Liste Linéaire Chaînées (LLC) est un ensemble de maillons reliés entre eux.  Un maillon est une entité renfermant de l’information et ayant un pointeur sur le maillon qui la suit. C’est toujours une structure (enregistrement) avec deux champs :  un champ val : contenant la valeur ou l'information  un champ suiv : donnant l'adresse du prochain maillon. D ÉFINITIONS ……. valsuiv

Nil 7  Une LLC est caractérisée par :  L'adresse de son premier élément (la tête de liste). Elle doit toujours être sauvegardée dans une variable pour pouvoir manipuler la liste.  NIL constitue l'adresse qui ne pointe aucun maillon (indiquant par convention la fin de la liste).  Si la liste est vide (ne contient aucun maillon), la tête doit alors être positionnée à NIL. D ÉFINITIONS Tête de liste ……. valsuiv Tête

Nil 8 D ÉFINITIONS Tête de liste ……. valsuiv Langage Algorithmique Langage C type Maillon = Structure val : typeqq suiv: * Maillon Fin Type ptrM = *Maillon Typedef struct Maillon { typeqq val ; struct Maillon*suiv ; } Maillon; Typedef Maillon* ptrM; Var Tête: ptrMptrM Tête; où typeqq est un type simple (entier, réel, caractère,...) ou composé (tableau, chaîne de caractère, structure, …..)

9  On définit un ensemble d'opérations que l'on va utiliser pour écrire des algorithmes sur les listes. Cet ensemble d'opérations s'appelle le M odèle des L istes L inéaires C haînées ( M LLC ) : M ODÈLE DE LLC (M LLC ) ModulesRôle Allouer( ) C’est une fonction qui alloue (dynamiquement) un nouveau maillon et retourne son adresse. Libérer(P) C’est une procédure qui détruit le maillon pointé par P. Valeur(P) C’est une fonction qui retourne le contenu du champs « val » du maillon pointé par P (retourner (*P.val)) Suivant(P) C’est une fonction qui retourne le contenu du champs « suiv » du maillon pointé par P (retourner (*P.suiv)) Aff_Suiv(P, Q) C’est une procédure qui affecte le pointeur Q dans le champs « suiv » du maillon pointé par P (*P.suiv  Q) Aff_Val(P,v) C’est une procédure qui affecte la valeur v dans le champs « val » du maillon pointé par P (*P.val  v)

10  Voici l’équivalence en langage C, des fonctions et des procédures du modèle : M ODÈLE DE LLC (M LLC ) ModulesImplémentation en langage C Allouer( ) ptrM Allouer ( ) { return ((ptrM) malloc( sizeof(Maillon))); } Libérer(P) void Liberer ( ptrM P) {free (p);} Valeur(P) typeqcq Valeur(ptrM P) { return( P->val) ; //équivalent à *P.val} Suivant(P) ptrM Suivant(ptrM P) { return( P->suiv ); //équivalent à *P.suiv}} Aff_Suiv(P, Q) void aff_suiv(ptrM P, ptrM Q) { P->suiv = Q; //équivalent à *P.suiv=Q} Aff_Val(P,v) void Aff_Val(ptrM P, typeqcq v) { P->val =v; //équivalent à *P.val = v}

11  Parcours :  Accès par valeur : il s'agit de rechercher (séquentiellement à partir de la tête) une valeur v dans la liste.  Accès par position : il s'agit de rechercher (séquentiellement à partir de la tête) le maillon (son adresse) qui se trouve à une position donnée. La position est le numéro d'ordre du maillon dans la liste (entier). A LGORITHMES SUR LES LLC S

12  Mises à jour :  Construction d'une liste à partir de n valeurs données.  Insertion d'une valeur (v) à une position donnée (i) : allouer un nouveau maillon contenant v et l'insérer dans la liste de telle sorte qu'il se retrouve à la i ème position.  Insertion d'une valeur (v) dans une liste ordonnée : allouer un nouveau maillon contenant v et l'insérer dans la liste de telle sorte que la liste reste ordonnée après l'insertion. A LGORITHMES SUR LES LLC S

13  Mises à jour :  Suppression du maillon se trouvant à une position donnée : rechercher par position le maillon et le libérer.  Suppression d'une valeur v dans la liste : rechercher par valeur et supprimer le maillon trouvé en mettant à jour le précédent (s'il existe). Si la liste contient plusieurs occurrences de la même valeur, on pourra les supprimer en faisant un seul parcours de la liste.  Destruction de tous les maillons d'une liste. A LGORITHMES SUR LES LLC S

14  Tri sur les LLC : Les mêmes algorithmes de tri utilisable pour les tableaux, en prenant en compte que l'accès par position coûte beaucoup plus cher que dans un tableau.  Algorithmes sur plusieurs LLC :  Fusion (ou Interclassement) de deux listes ordonnées : à partir de 2 listes ordonnées, construire une liste ordonnée contenant tous leurs éléments (sans allouer de nouveaux maillons).  Eclatement d'une liste en 2 listes distinctes : à partir d'une liste L et d'un critère (un prédicat) donné, on construit deux listes, l'une contenant toutes les valeurs de L vérifiant le critère, l'autre, celles qui ne le vérifient pas. A LGORITHMES SUR LES LLC S

15  Exercice 1 (Série 2): Soit L une LLC sur lequel on veut réaliser les opérations suivantes : a. ImprimerLLC : qui permet d’afficher les éléments d’une liste de gauche à droite b. LongLLC : qui permet de calculer la longueur de la liste. c. RechLLC : qui permet de rechercher le maillon contenant la valeur « v » dans la liste. d. RechPosLLC : qui permet de rechercher le maillon qui se trouve à la position « k ». e. InsLLC : qui permet d’insérer une valeur « v » dans la liste. f. InsPosLLC : qui permet d’insérer une valeur « v » à la position « k ». A LGORITHMES SUR LES LLC S

16  Exercice 1 (Série 2): Soit L une LLC sur lequel on veut réaliser les opérations suivantes : g. CreerLLC : qui permet de construire la liste à partir de n données lues. h. InverserLLC : qui permet d’inverser la liste i. SuppLLC : qui permet de supprimer une valeur « v » dans la liste. j. SuppTousLLC : qui permet de supprimer tous les maillons contenant la valeur « v ». k. SuppPosLLC : qui permet de supprimer le maillon de position « k ». l. DetruireLLC : qui permet de détruire la liste. A LGORITHMES SUR LES LLC S

17  Soient la liste suivante:  La liste imprimée est 2, 10, 5, -1 et 6 A LGORITHMES SUR LES LLC S I MPRESSION L Procédure ImprimerLLC (L: ptrM) Début Tant que (L  nil) faire // la liste n’est pas vide DTQ écrire (valeur (L)) L  suivant (L) FTQ Fin Procédure ImprimerLLC (L: ptrM) Début Tant que (L  nil) faire // la liste n’est pas vide DTQ écrire (valeur (L)) L  suivant (L) FTQ Fin

18  Soient la liste suivante:  La longueur de cette liste = 5 A LGORITHMES SUR LES LLC S L ONGUEUR L Fonction LongLLC (L: ptrM): entier Début Cpt  0; Tant que (L  nil) faire // la liste n’est pas vide DTQ Cpt ++ L  suivant (L) FTQ Retourner (Cpt) Fin Fonction LongLLC (L: ptrM): entier Début Cpt  0; Tant que (L  nil) faire // la liste n’est pas vide DTQ Cpt ++ L  suivant (L) FTQ Retourner (Cpt) Fin

19  Rechercher une valeur « v=5 » dans la liste suivante:  Si v= 1 alors la fonction retourne nil. A LGORITHMES SUR LES LLC S R ECHERCHE L Fonction RechLLC (L: ptrM, v:entier): ptrM Début Tant que (L  nil) faire // la liste n’est pas vide Si valeur (L) = v alors retourner (L) Sinon L  suivant (L) FTQ Retourner (nil) Fin Fonction RechLLC (L: ptrM, v:entier): ptrM Début Tant que (L  nil) faire // la liste n’est pas vide Si valeur (L) = v alors retourner (L) Sinon L  suivant (L) FTQ Retourner (nil) Fin

20  Rechercher le maillon qui se trouve à la position k = 4  Si k= 6, le maillon n’existe même pas (retourner nil) A LGORITHMES SUR LES LLC S R ECHERCHE L Fonction RechPosLLC (L: ptrM, K: entier positif): ptrM Debut Si K > 0 alors i  1 Tant que (i  K) et (L  nil) faire //accéder au K ème maillon DTQ i++; L  suivant (L); FTQ Retourner (L); Sinon Retourner (Nil) Fin Fonction RechPosLLC (L: ptrM, K: entier positif): ptrM Debut Si K > 0 alors i  1 Tant que (i  K) et (L  nil) faire //accéder au K ème maillon DTQ i++; L  suivant (L); FTQ Retourner (L); Sinon Retourner (Nil) Fin

21  Pour ajouter un élément dans la liste, il y a plusieurs situations : 1. Insertion au début de la liste 2. Insertion à la fin de la liste 3. Insertion à une position donnée A LGORITHMES SUR LES LLC S I NSERTION

22  Cas 1: Insertion au début A LGORITHMES SUR LES LLC S I NSERTION L P aff_suiv (P, L) Procédure InsererLLC_Deb(Var L: ptrM, v:entier) Début P = allouer () aff_val(P, v) aff_suiv(P, L) L  P //mettre à jour la tête de la liste Fin Procédure InsererLLC_Deb(Var L: ptrM, v:entier) Début P = allouer () aff_val(P, v) aff_suiv(P, L) L  P //mettre à jour la tête de la liste Fin

23  Cas 2: Insertion à la fin. A LGORITHMES SUR LES LLC S I NSERTION L Q P aff_suiv (Q, P) Procédure InsererLLC_Fin (Var L: ptrM, v:entier) Début P = allouer (); aff_val(P, v); aff_suiv(P, nil) Si (L=nil) alors //la liste est vide L  P // mettre à jour l’entête Sinon Dsinon Q  L Tant que (suivant (Q)  nil) faire // accéder au dernier maillon Q  suivant (Q) aff_suiv (Q, P) Fsinon Fin Procédure InsererLLC_Fin (Var L: ptrM, v:entier) Début P = allouer (); aff_val(P, v); aff_suiv(P, nil) Si (L=nil) alors //la liste est vide L  P // mettre à jour l’entête Sinon Dsinon Q  L Tant que (suivant (Q)  nil) faire // accéder au dernier maillon Q  suivant (Q) aff_suiv (Q, P) Fsinon Fin

24  Cas 3: Insertion à une position donné « k ».  Si k = 1 alors insérer le maillon au début  Sinon, accéder d’abord au maillon de position « k -1 », ensuite refaire le chaînage comme suit; A LGORITHMES SUR LES LLC S I NSERTION L Q P (1) aff_suiv (P, suivant (Q)) k (2) aff_suiv (Q, P)

25 A LGORITHMES SUR LES LLC S I NSERTION L Q P (1) aff_suiv (P, suivant (Q)) Procédure InsererLLC_pos (Var L: ptrM, k: entier positif, v:entier, Var possible: booléen) possible  faux Si (k>0) alors Si (k=1) alors InsererLLC_Deb(L, v) possible  vrai Sinon Q  RechPosLLC(L, k-1) ; Si ((Q ≠ nil) et (suivant (Q) ≠ nil)) // la position k existe P = allouer (); aff_val(P, v) ; aff_suiv (P, suivant (Q)) ; aff_suiv (Q, P) possible  vrai Fin Procédure InsererLLC_pos (Var L: ptrM, k: entier positif, v:entier, Var possible: booléen) possible  faux Si (k>0) alors Si (k=1) alors InsererLLC_Deb(L, v) possible  vrai Sinon Q  RechPosLLC(L, k-1) ; Si ((Q ≠ nil) et (suivant (Q) ≠ nil)) // la position k existe P = allouer (); aff_val(P, v) ; aff_suiv (P, suivant (Q)) ; aff_suiv (Q, P) possible  vrai Fin k (2) aff_suiv (Q, P)

26  Pour créer une liste: 1. Allouer un nouveau maillon 2. Initialiser le maillon avec la valeur lue 3. Insérer dans la liste. On distingue deux cas: a. Insertion à la fin b. Insertion au début et la liste crée est inversée A LGORITHMES SUR LES LLC S C RÉATION val suiv ??? val suiv 2 NIL

27  Cas 1: Insertion à la fin. Soient N= 5 et les valeurs suivantes: 2, 10, 5, -1, 6 A LGORITHMES SUR LES LLC S C RÉATION L Q P aff_suiv (Q, P) Procédure CreerLLC (Var L: ptrM) Début Pour i  1 à N faire DP lire (x) P = allouer () aff_val(P, x) aff_suiv(P, nil) Si (L=nil) alors //la liste est vide L  P // mettre à jour l’entête Sinon aff_suiv(Q, P) Q  P //sauvegarder du dernier maillon FP Fin Procédure CreerLLC (Var L: ptrM) Début Pour i  1 à N faire DP lire (x) P = allouer () aff_val(P, x) aff_suiv(P, nil) Si (L=nil) alors //la liste est vide L  P // mettre à jour l’entête Sinon aff_suiv(Q, P) Q  P //sauvegarder du dernier maillon FP Fin Procédure CreerLLC (Var L: ptrM) Début Pour i  1 à N faire DP lire (v) InsererLLC_Fin(L, v) FP Fin Procédure CreerLLC (Var L: ptrM) Début Pour i  1 à N faire DP lire (v) InsererLLC_Fin(L, v) FP Fin

28  Soient N= 5 et les valeurs suivantes: 2, 10, 5, -1, 6  Cas 2: Insertion au début A LGORITHMES SUR LES LLC S C RÉATION L P aff_suiv (P, L) Procédure CreerLLC_inverse (Var L: ptrM) Début Pour i  1 à N faire DP lire (x) P = allouer () aff_val(P, x) aff_suiv(P, nil) aff_suiv(P, L) L  P //mettre à jour la tête de la liste FP Fin Procédure CreerLLC_inverse (Var L: ptrM) Début Pour i  1 à N faire DP lire (x) P = allouer () aff_val(P, x) aff_suiv(P, nil) aff_suiv(P, L) L  P //mettre à jour la tête de la liste FP Fin Procédure CreerLLC_inverse (Var L: ptrM) Début Pour i  1 à N faire lire (v) InsérerLLC_Deb( L, v) Fin Procédure CreerLLC_inverse (Var L: ptrM) Début Pour i  1 à N faire lire (v) InsérerLLC_Deb( L, v) Fin

29 A LGORITHMES SUR LES LLC S I NVERSION 5102 L L Procédure InverserLLC (Var L: ptrM) Début P  Nil TQ (L≠Nil) faire Q  L L  suivant (L) aff_suiv(Q, P) P  Q FP L  P Fin Procédure InverserLLC (Var L: ptrM) Début P  Nil TQ (L≠Nil) faire Q  L L  suivant (L) aff_suiv(Q, P) P  Q FP L  P Fin

30  Pour supprimer un maillon contenant la valeur v, il faut d’abord rechercher ce maillon. Une fois trouvé (soit P ce maillon), on va refaire le chaînage (son précédent avec son suivant), ensuite, libérer le maillon P. A LGORITHMES SUR LES LLC S S UPPRESSION

31  Exemple 1: Suppression v = 5  Exemple 2 : Suppression v = 2 A LGORITHMES SUR LES LLC S S UPPRESSION L P L L Q P 6 Q

32 A LGORITHMES SUR LES LLC S S UPPRESSION Procédure SuppLLC (Var L:ptrM, v:entier) Début P  L; Q  nil TQ ((P  nil) et (valeur (P)  v) ) Q  P; P  suivant (P) FTQ Si (P  nil) alors Si Q = nil alors L  suivant (P); Sinon aff_suiv(Q,suivant (P)); libérer (P) Fin Procédure SuppLLC (Var L:ptrM, v:entier) Début P  L; Q  nil TQ ((P  nil) et (valeur (P)  v) ) Q  P; P  suivant (P) FTQ Si (P  nil) alors Si Q = nil alors L  suivant (P); Sinon aff_suiv(Q,suivant (P)); libérer (P) Fin /* rechercher le premier maillon contenant v*/ /* Suppression du premier maillon */

33  Suppression de tous les maillons contenant la valeur v A LGORITHMES SUR LES LLC S S UPPRESSION Procédure SuppTousLLC (Var L:ptrM, v:entier) Début P  L; Q  nil TQ (P  nil) Si (valeur (P)  v) Q  P; P  suivant (P) Sinon Si Q = nil alors L  suivant (P); Libérer (P); P  L; Sinon aff_suiv(Q,suivant (P)); libérer (P); P  suivant (Q); Fin Procédure SuppTousLLC (Var L:ptrM, v:entier) Début P  L; Q  nil TQ (P  nil) Si (valeur (P)  v) Q  P; P  suivant (P) Sinon Si Q = nil alors L  suivant (P); Libérer (P); P  L; Sinon aff_suiv(Q,suivant (P)); libérer (P); P  suivant (Q); Fin

34  Suppression à une position donnée « k ».  Deux situations se présentent:  k = 1, supprimer le premier maillon  k  1, accéder d’abord au maillon de position « k-1», sauvegarder l’adresse du maillon « k+1 », ensuite refaire le chaînage comme suit; A LGORITHMES SUR LES LLC S S UPPRESSION L Q k P

35  Suppression à une position donné « k ». A LGORITHMES SUR LES LLC S S UPPRESSION Procédure SuppPosLLC (Var L:ptrM, k:entier positif, Var possible : booléen) Début Possible  faux Si (k>0) alors Si (k = 1) alors // supprimer le premier maillon P  L; L  suivant (L); libérer (P); Possible  vrai Sinon Q  RechPosLLC(L, k-1) Si ((Q ≠ nil) et (suivant (Q) ≠ nil)) // la position k existe P  suivant (Q); aff_suiv(Q,suivant (P)); libérer (P); Possible  vrai Fin Procédure SuppPosLLC (Var L:ptrM, k:entier positif, Var possible : booléen) Début Possible  faux Si (k>0) alors Si (k = 1) alors // supprimer le premier maillon P  L; L  suivant (L); libérer (P); Possible  vrai Sinon Q  RechPosLLC(L, k-1) Si ((Q ≠ nil) et (suivant (Q) ≠ nil)) // la position k existe P  suivant (Q); aff_suiv(Q,suivant (P)); libérer (P); Possible  vrai Fin

36  Soient la liste suivante: A LGORITHMES SUR LES LLC S D ESTRUCTION L Procédure DetruireLLC (Var L:ptrM) Début Tant que (L  nil) faire // la liste n’est pas vide DTQ P  L L  suivant (L) libérer (P) FTQ Fin Procédure DetruireLLC (Var L:ptrM) Début Tant que (L  nil) faire // la liste n’est pas vide DTQ P  L L  suivant (L) libérer (P) FTQ Fin L P

37  Liste circulaire est une LLC où le dernier maillon pointe le premier, formant ainsi un cercle.  La tête de la liste est l'adresse de n'importe quel maillon.  Le même modèle des LLC est utilisé pour écrire des algorithmes sur ce type de listes: M LLCcir = M LLC L ISTES P ARTICULIÈRES L ISTE CIRCULAIRE ……. Tête

38  Impression d’une LLC circulaire L ISTES P ARTICULIÈRES L ISTE CIRCULAIRE ( QUELQUES ALGORITHMES ) 2105 L Procédure ImprimerLLCcir (L:ptrM) Début Si L  nil alors P  L Répéter Écrire (valeur (P)) P  suivant(P) Jusqu’à P=L Fin Procédure ImprimerLLCcir (L:ptrM) Début Si L  nil alors P  L Répéter Écrire (valeur (P)) P  suivant(P) Jusqu’à P=L Fin P

39  Recherche le premier maillon contenant la valeur v L ISTES P ARTICULIÈRES L ISTE CIRCULAIRE ( QUELQUES ALGORITHMES ) 2105 L Fonction RechLLC_cir (L:ptrM, v:entier): ptrM Début Si L  nil alors P  L Répéter Si (valeur (P) = v) alors retourner (P) P  suivant(P) Jusqu’à P=L Retourner (nil) Fin Fonction RechLLC_cir (L:ptrM, v:entier): ptrM Début Si L  nil alors P  L Répéter Si (valeur (P) = v) alors retourner (P) P  suivant(P) Jusqu’à P=L Retourner (nil) Fin P

40  Insertion dans une LLC circulaire L ISTES P ARTICULIÈRES L ISTE CIRCULAIRE ( QUELQUES ALGORITHMES ) L Procédure InsLLCcir (Var L:ptrM, v:entier) Début P = allouer() aff_val(P, v) Si (L=nil) alors //la liste est vide aff_suiv(P, P) L  P // mettre à jour l’entête Sinon aff_suiv(P, suivant (L)) aff_suiv (L, P) Fin Procédure InsLLCcir (Var L:ptrM, v:entier) Début P = allouer() aff_val(P, v) Si (L=nil) alors //la liste est vide aff_suiv(P, P) L  P // mettre à jour l’entête Sinon aff_suiv(P, suivant (L)) aff_suiv (L, P) Fin P Q

41  Construction d’une LLC circulaire  Construire une LLC unidirectionnel  À la fin, chaîner le dernier maillon avec le premier L ISTES P ARTICULIÈRES L ISTE CIRCULAIRE ( QUELQUES ALGORITHMES ) L Procédure CreerLLCcir (Var L:ptrM, N:entier) Début Pour i  1 à N faire lire (x) P = allouer (); aff_val(P, x) Si (L=nil) alorsL  P // mettre à jour l’entête Sinon aff_suiv(Q, P) Q  P //sauvegarder du dernier maillon aff_suiv (P, L); Fin Procédure CreerLLCcir (Var L:ptrM, N:entier) Début Pour i  1 à N faire lire (x) P = allouer (); aff_val(P, x) Si (L=nil) alorsL  P // mettre à jour l’entête Sinon aff_suiv(Q, P) Q  P //sauvegarder du dernier maillon aff_suiv (P, L); Fin Q P

42  Construction d’une LLC circulaire L ISTES P ARTICULIÈRES L ISTE CIRCULAIRE ( QUELQUES ALGORITHMES ) L 2 éme Méthode Procédure CreerLLCcir (Var L:ptrM, N:entier) Début Pour i  1 à N faire lire (x); P = allouer (); aff_val(P, x) Si (L=nil) alors //la liste est vide L  P // mettre à jour l’entête Sinon aff_suiv(Q, P) aff_suiv(P, L) // lier le dernier maillon au premier Q  P //sauvegarder du dernier maillon Fin 2 éme Méthode Procédure CreerLLCcir (Var L:ptrM, N:entier) Début Pour i  1 à N faire lire (x); P = allouer (); aff_val(P, x) Si (L=nil) alors //la liste est vide L  P // mettre à jour l’entête Sinon aff_suiv(Q, P) aff_suiv(P, L) // lier le dernier maillon au premier Q  P //sauvegarder du dernier maillon Fin Q P

43  Suppression du maillon contenant la valeur v  Rechercher le maillon contenant la valeur v  S’il existe un tel maillon, on distingue deux cas: 1. La valeur se trouve dans le maillon « L », a. Si la liste contient qu’un seul maillon, alors la liste devient vide b. Sinon, mettre à jour le pointeur L et refaire le chaînage. 2. La valeur se trouve dans un autre maillon (  L), refaire le chaînage L ISTES P ARTICULIÈRES L ISTE CIRCULAIRE ( QUELQUES ALGORITHMES ) 2105 L

44  Suppression du maillon contenant la valeur v L ISTES P ARTICULIÈRES L ISTE CIRCULAIRE ( QUELQUES ALGORITHMES ) Procédure SuppLLCcir (L:*maillon, v:entier) Début Si (L  nil) alors // la liste n’est pas vide P  L répéter Q  P P  suivant (P) jusqu’à (P = L) ou (valeur (P) =v ) Si valeur (P) =v alors // il existe un maillon contenant la valeur v Si P = L alors // la valeur se trouve dans le maillon L Si P = Q alors // la liste contient un seul maillon L  nil Sinon L  suivant (P); aff_suiv(Q,suivant (P)) Sinon aff_suiv(Q,suivant (P)) libérer (P) Fin Procédure SuppLLCcir (L:*maillon, v:entier) Début Si (L  nil) alors // la liste n’est pas vide PLPL répéter QPQP P  suivant (P) jusqu’à (P = L) ou (valeur (P) =v ) Si valeur (P) =v alors // il existe un maillon contenant la valeur v Si P = L alors // la valeur se trouve dans le maillon L Si P = Q alors // la liste contient un seul maillon L  nil Sinon L  suivant (P); aff_suiv(Q,suivant (P)) Sinon aff_suiv(Q,suivant (P)) libérer (P) Fin //rechercher le maillon contenant la valeur v

45  Destruction d’une LLC circulaire L ISTES P ARTICULIÈRES L ISTE CIRCULAIRE ( QUELQUES ALGORITHMES ) 2105 L Procédure DetruireLLCcir (L:*maillon) Début Si L  nil alors P  suivant (L) TQ (P≠L) faire aff_suiv(L, suivant (P)) libérer (P) P  suivant (L) FTQ Libérer (P); L  nil; Fin Procédure DetruireLLCcir (L:*maillon) Début Si L  nil alors P  suivant (L) TQ (P≠L) faire aff_suiv(L, suivant (P)) libérer (P) P  suivant (L) FTQ Libérer (P); L  nil; Fin

46  Liste bidirectionnelle ou Liste Doublement Chaînées est une liste que l'on peut parcourir dans les deux sens : de gauche à droite (pour aller au maillon suivant) et de droite à gauche (pour aller au maillon précédent).  Elle est définit par sa tête, aussi que par sa queue. L ISTES P ARTICULIÈRES L ISTE B IDIRECTIONNELLE Tête Nil V1 V2 V3 V4 V5 Nil Queue val suiv prec

 Chaque maillon d’une liste bidirectionnelle comporte trois champs:  Un champ contenant la donnée.  Un pointeur vers l'élément suivant de la liste.  Un pointeur vers l'élément précédent de la liste. L ISTES P ARTICULIÈRES L ISTE B IDIRECTIONNELLE type MaillonBD = Structure val : typeqq suiv: * MaillonBD prec:*MaillonBD fin Type ptrMBD = *MaillonBD val suivprec 47 type ListeBD= Structure Tête: ptrMBD Queue: ptrMBD fin Var L: ListeBD

 Le modèle des LLC bidirectionnelles est donc étendu par les opérations suivantes : M LLCbd = M LLC + { Init, Aff_prec, Précédent } L ISTES P ARTICULIÈRES L ISTE B IDIRECTIONNELLE 48 FonctionRôle Init (L) Initialiser la tête et la queue à Nil Précédent(P) Accéder au champ « prec » du maillon d'adresse P. Aff_prec(P, Q) Modifier le champ « prec » du maillon d'adresse P en lui affectant le pointeur Q. val suivprec

49  Impression d’une LLC Bidirectionnelle L ISTES P ARTICULIÈRES L ISTE B IDIRECTIONNELLE ( QUELQUES ALGORITHMES ) Tete 256 Queue Procédure ImprimerLLCbd (Var L: ListeBD) Début T  L.Tete Tant que (T  nil) faire // la liste n’est pas vide écrire (valeur (T)) T  suivant (T) Fin La liste imprimée est 2, 5, -1, 6 Procédure ImprimerLLCbd (Var L: ListeBD) Début T  L.Tete Tant que (T  nil) faire // la liste n’est pas vide écrire (valeur (T)) T  suivant (T) Fin La liste imprimée est 2, 5, -1, 6 Procédure ImprimerLLCbd_inverse(Var L: ListeBD) Début Q  L.Queue Tant que (Q  nil) faire // la liste n’est pas vide écrire (valeur (Q)) Q  precedent (Q) Fin La liste imprimée est 6, -1, 5, 2 Procédure ImprimerLLCbd_inverse(Var L: ListeBD) Début Q  L.Queue Tant que (Q  nil) faire // la liste n’est pas vide écrire (valeur (Q)) Q  precedent (Q) Fin La liste imprimée est 6, -1, 5, 2

50  Recherche d’une valeur dans une LLC Bidirectionnelle L ISTES P ARTICULIÈRES L ISTE B IDIRECTIONNELLE ( QUELQUES ALGORITHMES ) Fonction RechLLCbd(L: ListeBD, v:entier): ptrMBD Début P  L.Tete Tant que (P  nil) faire // la liste n’est pas vide Si valeur (P) = v alors retourner (P) Sinon P  suivant (P) Retourner (nil) Fin Fonction RechLLCbd(L: ListeBD, v:entier): ptrMBD Début P  L.Tete Tant que (P  nil) faire // la liste n’est pas vide Si valeur (P) = v alors retourner (P) Sinon P  suivant (P) Retourner (nil) Fin Tete 256 Queue Fonction RechLLCbd (L: ListeBD, v:entier): ptrMBD Début P  L.Queue Tant que (P  nil) faire // la liste n’est pas vide Si valeur (P) = v alors retourner (P) Sinon P  précédent (P) Retourner (nil) Fin Fonction RechLLCbd (L: ListeBD, v:entier): ptrMBD Début P  L.Queue Tant que (P  nil) faire // la liste n’est pas vide Si valeur (P) = v alors retourner (P) Sinon P  précédent (P) Retourner (nil) Fin

51  Recherche du maillon qui se trouve à une position donnée L ISTES P ARTICULIÈRES L ISTE B IDIRECTIONNELLE ( QUELQUES ALGORITHMES ) K Tete 256 Queue P RechLLCbd_pos(L: ListeBD, K: entier positif): ptrMBD Debut P  L.Tete; i  1 Tant que (i  K) et (P  nil) faire //accéder au K ème maillon DTQ i++; P  suivant (P); FTQ Retourner (P); Fin RechLLCbd_pos(L: ListeBD, K: entier positif): ptrMBD Debut P  L.Tete; i  1 Tant que (i  K) et (P  nil) faire //accéder au K ème maillon DTQ i++; P  suivant (P); FTQ Retourner (P); Fin

52  Insertion au début de la liste L ISTES P ARTICULIÈRES L ISTE B IDIRECTIONNELLE ( QUELQUES ALGORITHMES ) Aff_suiv (P, Tete) Tete Queue 526 P Aff_prec (Tete, P) Procédure InsererLLCbd_Deb (Var L: ListeBD, v:entier) Début P = Allouer (); aff_val(P, v); Si L.Tete = nil alors // si la liste est vide aff_suiv(P, nil); aff_prec(P, nil) L.Tete  P; L.Queue  P Sinon aff_prec (P, nil); aff_suiv (P, L.Tete) ; aff_prec (L.Tete, P) L.Tete  P //mettre à jour la tête Fin Procédure InsererLLCbd_Deb (Var L: ListeBD, v:entier) Début P = Allouer (); aff_val(P, v); Si L.Tete = nil alors // si la liste est vide aff_suiv(P, nil); aff_prec(P, nil) L.Tete  P; L.Queue  P Sinon aff_prec (P, nil); aff_suiv (P, L.Tete) ; aff_prec (L.Tete, P) L.Tete  P //mettre à jour la tête Fin

53  Insertion à la fin de la liste. L ISTES P ARTICULIÈRES L ISTE B IDIRECTIONNELLE ( QUELQUES ALGORITHMES ) Procédure InsererLLCbd_Fin (Var L: ListeBD, v:entier) Début P = Allouer (); aff_val(P, v); Si L.Queue = nil //la liste est vide aff_suiv(P, nil); aff_prec(P, nil) L.Tete  P; L.Queue  P Sinon aff_suiv(P, nil) aff_suiv (L.Queue, P); aff_prec (P, L.Queue) L.Queue  P //mettre à jour la queue Fin Procédure InsererLLCbd_Fin (Var L: ListeBD, v:entier) Début P = Allouer (); aff_val(P, v); Si L.Queue = nil //la liste est vide aff_suiv(P, nil); aff_prec(P, nil) L.Tete  P; L.Queue  P Sinon aff_suiv(P, nil) aff_suiv (L.Queue, P); aff_prec (P, L.Queue) L.Queue  P //mettre à jour la queue Fin Aff_suiv (Queue, P) Tete Queue 2 56 P Aff_prec (P, Queue)

54  Insertion à une position donnée L ISTES P ARTICULIÈRES L ISTE B IDIRECTIONNELLE ( QUELQUES ALGORITHMES ) P K Tete 256 Queue S 6 (1) (2) (4) (3) Procédure InsererLLCbd_pos (Var L: ListeBD, v:entier, K:entier positif) Si K>0 alors Si K = 1 alors InsererLLCbd_Deb(L, v) Sinon S  RechLLCbd_pos(L, K):; Si S ≠ Nil P = Allouer (); aff_val(P, v); aff_suiv (Precedent (S), P) ; aff_prec (P, Precedent (S)); aff_suiv (P, S) ;aff_prec (S, P) ; Procédure InsererLLCbd_pos (Var L: ListeBD, v:entier, K:entier positif) Si K>0 alors Si K = 1 alors InsererLLCbd_Deb(L, v) Sinon S  RechLLCbd_pos(L, K):; Si S ≠ Nil P = Allouer (); aff_val(P, v); aff_suiv (Precedent (S), P) ; aff_prec (P, Precedent (S)); aff_suiv (P, S) ;aff_prec (S, P) ;

55  Construction d’une LLC Bidirectionnelle  Soient N= 4 et les valeurs suivantes: 2, 5, -1, 6 L ISTES P ARTICULIÈRES L ISTE B IDIRECTIONNELLE ( QUELQUES ALGORITHMES ) Aff_suiv (Q, P) Tete Queue 2 56 P Aff_prec (P, Q) Procédure CreerLLCbd (Var L: ListeBD) Début Init (L) Pour i  1 à N faire lire (x); InsererLLCbd_Fin (L, x); Fin Procédure CreerLLCbd (Var L: ListeBD) Début Init (L) Pour i  1 à N faire lire (x); InsererLLCbd_Fin (L, x); Fin

56  Construction d’une LLC Bidirectionnelle  Soient N= 4 et les valeurs suivantes: 2, 5, -1, 6 L ISTES P ARTICULIÈRES L ISTE B IDIRECTIONNELLE ( QUELQUES ALGORITHMES ) Aff_suiv (P, T) Tete Queue 526 P Aff_prec (T, P) Procédure CreerLLCbd_inverse(Var L: ListeBD) Début Init (L) Pour i  1 à N faire lire (x); InsererLLCbd_Deb (L, x); Fin Procédure CreerLLCbd_inverse(Var L: ListeBD) Début Init (L) Pour i  1 à N faire lire (x); InsererLLCbd_Deb (L, x); Fin

57  Suppression du maillon contenant la valeur v L ISTES P ARTICULIÈRES L ISTE B IDIRECTIONNELLE ( QUELQUES ALGORITHMES ) 256 Procédure SuppLLCbd (Var L: ListeBD v:entier) Si (L.Tete  nil) alors // la liste n’est pas vide P  RechLLCbd (L, v) Si P  nil alors // il existe un maillon contenant la valeur v Si P = L.Tete = L.Queue alors // la liste contient un seul maillon Init (L) // T  nil; Q  nil i.e. la liste devient vide SinonSi P = L.Tete alors //suppression au début L.Tete  suivant (P); aff_prec(L.Tete, nil); Sinon Si P = L.Queuealors //suppression à la fin L.Queue  précédent (P); aff_suiv(L.Queue, nil) Sinon aff_suiv(precedent (P), suivant(P)); aff_prec(suivant(P), precedent (P)); libérer (P) Procédure SuppLLCbd (Var L: ListeBD v:entier) Si (L.Tete  nil) alors // la liste n’est pas vide P  RechLLCbd (L, v) Si P  nil alors // il existe un maillon contenant la valeur v Si P = L.Tete = L.Queue alors // la liste contient un seul maillon Init (L) // T  nil; Q  nil i.e. la liste devient vide SinonSi P = L.Tete alors //suppression au début L.Tete  suivant (P); aff_prec(L.Tete, nil); Sinon Si P = L.Queuealors //suppression à la fin L.Queue  précédent (P); aff_suiv(L.Queue, nil) Sinon aff_suiv(precedent (P), suivant(P)); aff_prec(suivant(P), precedent (P)); libérer (P) Queue Tete P

58  Destruction d’une LLC Bidirectionnelle L ISTES P ARTICULIÈRES L ISTE B IDIRECTIONNELLE ( QUELQUES ALGORITHMES ) Tete 256 Queue Procédure DetruireLLCbd (Var L: ListeBD) Début T  L.Tete Tant que (T  nil) faire P  T T  suivant (T) libérer (P) Init (L); Fin Procédure DetruireLLCbd (Var L: ListeBD) Début T  L.Tete Tant que (T  nil) faire P  T T  suivant (T) libérer (P) Init (L); Fin Procédure DetruireLLCbd (Var L: ListeBD) Début Q  L.Queue Tant que (Q  nil) faire P  Q Q  precedent (Q) libérer (P) Init (L); Fin Procédure DetruireLLCbd (Var L: ListeBD) Début Q  L.Queue Tant que (Q  nil) faire P  Q Q  precedent (Q) libérer (P) Init (L); Fin

59  Liste bidirectionnelle circulaire est une LLC à double sens et dont le dernier maillon pointe sur le premier maillon et le premier maillon pointe sur le dernier maillon.  Le même modèle des LLCs bidirectionnel est utilisé pour écrire des algorithmes sur ce type de liste: M LLCbdcir = M LLCbd L ISTES P ARTICULIÈRES L ISTE B IDIRECTIONNELLE C IRCULAIRE Tête V1 V2 V3 V4 V5

60  On peut représenter une LLC par un tableau où chaque élément contient au moins 3 champs : l'information, l’indice du suivant et l’indicateur vide.  Exemple d’une LLC unidirectionnel: R EPRÉSENTATION S TATIQUE DÉFINITION Tête Nil VideValSuiv F123 F236 V F81 V V F45 Tête = 0

61  Initialement, le champ Vide de tous les éléments sont à vrai pour indiquer que les cases sont disponibles.  Une LLC est définie par l'indice de son premier élément dans le tableau T VideValSuiv F123 F236 V F81 V V F45 Définition de la structure : type element = Structure vide : Booléen val : typeqq suiv : Entier fin varListe : tableau [N] de element Tête = 0 R EPRÉSENTATION S TATIQUE DÉFINITION

62  Le modèle de la LLC est défini comme suit: ModulesRôle Allouer() C’est une fonction qui retourne l’indice de la case libre dans le tableau L du taille max sinon la valeur -1 s'il n’y a pas de place. Libérer(P) C’est une procédure qui positionne le champs « vide » de la case L[P] à vrai Valeur(P) C’est une fonction qui retourner le contenu du champs « val » de la case L[P]. Suivant(P) C’est une fonction qui retourne le contenu du champs « suiv » de la case L[P] aff_suiv(P, Q) C’est une procédure qui affecte l’entier Q dans le champs « suiv » de la case L[P] Aff_Val(P,v) C’est une procédure qui affecte la valeur v dans le champs « val » de la case L[P] R EPRÉSENTATION S TATIQUE M ODÈLE

63 ModulesCodeComplexité Allouer() Pour i  0 à N aire Si L[i].Vide alors L[i]  faux Retourner(i) Retourner (-1) O(N) Libérer(P) L[P].Vide  vrai O(1) Valeur(P) Retourner (L [P].val)O(1) Suivant(P) Retourner (L [P].suiv)O(1) aff_suiv(P, Q) L[P].suiv  Q O(1) Aff_Val(P, v) L[P].val  v O(1) R EPRÉSENTATION S TATIQUE M ODÈLE

Faut-il utiliser une représentation dynamique ou statique pour implémenter une LLC? C ONCLUSION 64

65 Tableau non ordonné LLC unidirectionnelle non ordonné Accès à un élément Séquentielle (O(n)) tq n est la longueur de la liste Séquentielle (O(n)) tq n est la longueur de la liste Ajout Recherche séquentielle d’une case vide O(n) Chaînage: Au début O(1) A la fin O(n) Suppression Direct (O(1)) Chaînage: Au début O(1) À la fin O(n) Définition de la relation suivant: Implicite définie par la contiguïté des composantes du tableau Explicite On peut la modifier, i.e. les maillons des LLC peuvent être réarrangés sans avoir à déplacer les informations qu’ils portent). De plus, un même maillon peut faire partie de plusieurs listes. C ONCLUSION

66 Tableau non ordonné LLC unidirectionnelle non ordonné Sur- encombrement Non: La relation suivant étant implicite, il n’y a pas besoin d’espace supplémentaire pour son codage. Oui: l’encombrement de chaque maillon est augmenté de la taille du pointeur suivant Encombrement total selon le besoin Non: avec l’allocation statique, l’encombrement d’un tableau est constant (fixé d’avance). Oui: avec l’allocation dynamique des maillons, le nombre de maillons d’une LLC correspond au nombre d’éléments effectivement présents C ONCLUSION

P ARTIE II: F ILES D ’A TTENTE

P LAN DE LA P ARTIE II  Définition  Utilisation  Modèle  Implémentation  Représentation statique  Représentation dynamique  File d’attente avec priorité 68

69  Une file (en anglais queue ) est une structure de données basée sur le principe « premier arrivé, premier sorti » (en anglais FIFO: First In First Out ),  Le fonctionnement ressemble à une file d'attente : les premières personnes à arriver sont les premières personnes à sortir de la file. D ÉFINITION

70  Une file d'attente peut être définie comme une collection d'éléments dans laquelle tout nouvel élément est inséré ( ajouté ) à la fin ( queue ) et tout élément ne peut être supprimé ( retiré ) que du début ( Tête ). D ÉFINITION Retrait (Défilement ) Ajout (enfilement) tête queue

71  Les files d’attente sont utilisées, en programmation comme des buffers (mémoire tampon = espace de mémorisation temporaire), pour gérer des objets qui sont en attente d’un traitement ultérieur, tel que la gestion des documents à imprimer, des programmes à exécuter, des messages reçus,...etc.  Elles sont utilisées également dans le parcours des arbres. U TILISATION

72  Les opérations habituelles sur les files sont :  Initialisation de la file  Vérification du contenu de la file (vide ou pleine)  Enfilement : ajout d’un élément à la queue de la file  Défilement : retrait d’un élément de la tête de la file M ODÈLE OpérationRôle Initfile(F) initialiser une file vide Filevide(F) tester si la file est vide Filepleine(F) tester si la file est pleine Enfiler(F,Val) ajouter Val à la queue de file Défiler(F,Val) retirer dans Val l'élément en tête de file

73  Les files d’attente peuvent être présentées en deux manières:  statique en utilisant les tableaux,  dynamique en utilisant les listes linéaires chaînées.  L’implémentation statique peut être réalisée par  décalage en utilisant un tableau avec une tête fixe, toujours à 0, et une queue variable.  tableau circulaire où la tête et la queue sont toutes les deux variables. I MPLÉMENTATION

74  A chaque défilement, on fait un décalage.  La tête n'est plus une caractéristique puisqu'elle est toujours égale à 0. I MPLÉMENTATION STATIQUE PAR DÉCALAGE V0V1V2V3V4V5 Tête = 0 Queue = 5 Défiler Décalage V1V2V3V4V5 Queue = 4

75 I MPLÉMENTATION STATIQUE PAR DÉCALAGE Définition de la structure : TYPE File_Attente = STRUCTURE Elements : TABLEAU[Max] de Typeqq Queue : ENTIER FIN VAR F : File_Attente V1V2V3V4V5V6 Queue File_Attente Eléments

76 I MPLÉMENTATION STATIQUE PAR DÉCALAGE ModèleImplémentation Initfile(F) F.Queue ←-1 Filevide(F) Retourner (F.Queue = -1) Filepleine(F) Retourner (F.Queue = Max-1) Enfiler(F,X) SI (NON Filepleine(F)) F.Queue ← F.Queue + 1 F.Elements[F.Queue] ←X Defiler(F,X) SI (NON Filevide(F)) X ← F.Elements[0] POUR I ← 0 à F.Queue - 1 F.Elements[I] ← F.Elements[I+1] F.Queue ← F.Queue – 1

77  Les incrémentations se font modulo Max afin de réutiliser des cases libérées: Tete  (Tete+1) mod Max & Queue  (queue+1) mod Max  Par convention,  L'élément d'indice tête sera sacrifié (case vide).  Le premier élément se trouve alors à l'indice (tête+1 mod Max) I MPLÉMENTATION STATIQUE PAR T ABLEAU CIRCULAIRE V0V1V2V3V4V5 Tête = 8Queue = 5

78 I MPLÉMENTATION STATIQUE PAR T ABLEAU CIRCULAIRE V1V2V3V4V5 Tête = 0Queue = 5 V2V3V4V5 Tête = 1Queue = 5 Tête = Queue = 5  Défiler (F, V)  Pour i  1 à 4 faire Défiler (F, V) File Vide ssi Tête = Queue

79 I MPLÉMENTATION STATIQUE PAR T ABLEAU CIRCULAIRE V3V4V5V6V7V8 Tête = 2Queue = 8 V9V3V4V5V6V7V8 Tête = 2Queue = 0  Enfiler (F, V9) V9V10V3V4V5V6V7V8 Tête = 2Queue = 1  Enfiler (F, V10) File Pleine ssi : tete = (queue+1) mod Max File Pleine ssi : tete = (queue+1) mod Max Queue  (queue+1) mod Max

80 I MPLÉMENTATION STATIQUE PAR T ABLEAU CIRCULAIRE Définition de la structure : TYPE File_Attente = STRUCTURE Elements : TABLEAU[Max] de Typeqq Tête, Queue : ENTIER FIN VAR F : File_Attente File_Attente Eléments V2V3V4V5 Tête = 1Queue = 5

81 I MPLÉMENTATION STATIQUE PAR T ABLEAU CIRCULAIRE ModèleImplémentation Initfile(F) F.Tête ←0; F.Queue ←0 Filevide(F) Retourner (F.Tête = F.Queue) Filepleine(F) Retourner (F.Tête = ( (F.Queue +1) Mod Max )) Enfiler(F,X) SI (NON Filepleine( F)) F.Queue ← (F.Queue + 1) Mod Max F.elements[F.Queue] ← X Defiler(F,X) SI (NON Filevide(F)) F.Tete ← (F.Tete + 1)Mod Max X ← F.elements[F.Tete]

82  La représentation dynamique utilise une liste linéaire chaînée (LLC). L’enfilement se fait à la queue de la liste et de défilement se fait de la tête. La file d’attente, dans ce cas, peut devenir vide, mais ne sera jamais pleine.  Les opérations de base sont :  Initialisation de la file  Enfilement : insertion d’un élément à la queue de la LLC  Défilement : suppression d’un élément de la tête de la LLC  Vérification si la LLC n’est pas vide I MPLÉMENTATION D YNAMIQUE V0V1V2V3V4 TêteQueue Enfilement Défilement

83 I MPLÉMENTATION D YNAMIQUE V0V1V2V3V4 TêteQueue Définition de la structure : TYPE Maillon = STRUCTURE val : typeqq suiv: * Maillon FIN TYPE ptrM = *Maillon TYPE File_Attente = STRUCTURE Tête, Queue : ptrM FIN VAR F: File_Attente File_Attente

84 I MPLÉMENTATION D YNAMIQUE ModèleImplémentation Initfile(F) F.Tete ← NIL; F.Queue← NIL Filevide(F) Retourner (F.Tete = NIL ) Enfiler(F,X) P = Allouer (), Aff_Val(P, X), aff_suiv(P, NIL) SI (NON Filevide(F)) aff_suiv(F.Queue, P) SINON F.Tete ← P F.Queue ← P Defiler(F,X) SI (NON Filevide(F)) P ← F.Tete X ← Valeur(F.Tete) F.Tete ← Suivant(F.Tete) Liberer(P)

85  Une file d’attente avec priorité est une collection d’éléments dans laquelle l’insertion ne se fait pas toujours à la queue.  Tout nouvel élément est inséré dans la file, selon sa priorité.  Le retrait se fait toujours du début.  Dans une file avec priorité, un élément prioritaire prendra la tête de la file même s’il arrive le dernier.  Un élément est toujours accompagné d’une information indiquant sa priorité dans la file. F ILE D ’ ATTENTE AVEC PRIORITÉ

P ARTIE III: P ILES

P LAN DE LA P ARTIE III  Définition  Modèle  Implémentation  Représentation statique  Représentation dynamique  Utilisation 87

88  Une pile (en anglais stack ) est une structure de données fondée sur le principe « dernier arrivé, premier sorti » (ou LIFO : Last In, First Out )  Les derniers éléments ajoutés à la pile seront les premiers à être récupérés. D ÉFINITION  Le fonctionnement ressemble à une piles des livres: On ajoute des livres sur la pile, et on les récupère dans l'ordre inverse, en commençant par le dernier ajouté.

89  Une pile peut être définie comme une collection d'éléments dans laquelle tout nouvel élément est inséré à la fin ( empilement ) et tout élément ne peut être supprimé que de la fin ( dépilement ).  Les insertions et les suppressions d’éléments se font à une seule et même extrémité de la liste appelée le sommet de la pile. D ÉFINITION Sommet DépilementEmpilement

90  Les opérations habituelles sur les piles sont :  Initialisation de la pile  Vérification du contenu de la pile (vide ou pleine)  Lecture de la valeur de sommet  Empilement : ajout d’un élément au sommet de la pile  Dépilement : retrait d’un élément du sommet de la pile M ODÈLE OpérationRôle InitPile(P) créer une pile vide Pilevide(P) tester si la pile est vide Pilepleine(P) tester si la pile est pleine Sommet(P) Retourner la valeur de sommet Empiler(P,Val) ajouter Val en sommet de pile Depiler(P,Val) retirer dans Val l'élément en sommet de pile

91  Les piles peuvent être présentées en deux manières:  statique en utilisant les tableaux,  dynamique en utilisant les listes linéaires chaînées. I MPLÉMENTATION

92  L’implémentation statique des piles utilise les tableaux. Dans ce cas, la capacité de la pile est limitée par la taille du tableau (max). L’ajout à la pile se fait dans le sens croissant des indices, tandis que le retrait se fait dans le sens inverse. I MPLÉMENTATION STATIQUE Sommet =5 V5 V4 V3 V2 V1 V0 Dépilement Empilement 0 max-1

93 I MPLÉMENTATION STATIQUE PAR DÉCALAGE Définition de la structure : TYPE Pile = STRUCTURE Elements : TABLEAU[Max] de Typeqq Sommet : ENTIER FIN VAR P : Pile Pile Eléments Sommet =5 V5 V4 V3 V2 V1 V0 0 max-1

94 I MPLÉMENTATION STATIQUE modèleImplémentation Initpile(P) P.Sommet ← -1 Pilevide(P) Retourner ( P.Sommet = -1) Pilepleine(P) Retourrner (P.Sommet = Max-1) Sommet(P) Retourner (P.Elements[P.Sommet]) Empiler(P, X) Si (NON Pilepleine(P)) P.Sommet ← P.Sommet + 1 P.Elements[P.Sommet] ← X Sinon « Overflow » Depiler(P, X) Si (NON Pilevide(P)) X ← P.Elements [P.Sommet] P.Sommet ← P.Sommet – 1 Sinon « Underflow »

95  L’implémentation dynamique utilise les listes linéaires chinées. Dans ce cas, la pile peut être vide, mais ne peut être jamais pleine, sauf bien sur en cas d’insuffisance de l’espace mémoire. L’empilement et le dépilement dans les piles dynamique se font à la tête de la liste.  Les opérations de base sont :  Vérification si la LLC n’est pas vide  Lecture de la valeur de la tête  Enfilement : insertion d’un élément à la tête de la LLC  Défilement : suppression d’un élément de la tête de la LLC I MPLÉMENTATION D YNAMIQUE V4V3V2V1V0 Sommet (Tête) Empilement Dépilement

96 I MPLÉMENTATION D YNAMIQUE V4V3V2V0V1 S Définition de la structure : TYPE Maillon = STRUCTURE val : typeqq suiv: * Maillon FIN TYPE Pile = *Maillon VAR S: Pile Pile

97 I MPLÉMENTATION D YNAMIQUE ModèleImplémentation Initpile(S) Sommet ← Nil Pilevide(S) Retourner (S = Nil) Sommet(S) Retourner (valeur(S)) Empiler(S, X) Q = allouer () Aff_Val(Q, X) aff_suiv(Q, S) S← Q Depiler(S, X) Si NON Pilevide(S) X ← Valeur(S) Q ← S S ←Suivant(S) Liberer(Q) Fsi

98  Les piles sont utilisées en  Compilation pour faire l’analyse syntaxique: vérification des parenthèses, des accolades, analyse des expressions arithmétiques, ………  Exécution d’un programme pour sauvegarder le contexte en cours lors d’appel d’un module, évaluation des expressions arithmétiques, ………….  Exécution des processus par le processeur pour sauvegarder le contexte des processus interrompus U TILISATION

S OURCES DE CE COURS N. EL-ALLIA, Cours d’Algorithmique et Structures de données dynamiques, Ecole nationale Supérieure d’Informatique (ESI), Djamel Eddine ZEGOUR, Cours de Structures de Données, Ecole nationale Supérieure d’Informatique (ESI), Disponible sur B. Boutoumi,, Cours d’Algorithmique et Structures de données, Université Saad Dahlab de Blida, 2014, Disponible sur donnees/nouveau-programme. donnees/nouveau-programme A. Djeffal, Cours d’Algorithmique et Structures de données 1, Université Mohamed Khider de Biskra, 2012, Disponible sur univ- biskra.dz/fac/fsesnv/cours/algo 99

100  Exercice 6:  Le processeur possède un buffer permettant de gérer ses programmes à exécuter. Ce buffer est une file d'attente avec priorité où les éléments (programmes) sont caractérisés par une priorité d’exécution: un programme de priorité supérieure est servi même s’il n’est pas arrivé le premier.  Sachant qu’un programme est défini par sa priorité et son mot d’état programme (Program Status Word ou PSW) qui regroupe l’adresse de la prochaine instruction (CO) et les bits du registre de flag. Définir les structures de données nécessaires ainsi que le modèle de file, pour chaque type de présentation (statique par décalage, statique par tableau circulaire et dynamique). F ILE D ’ ATTENTE AVEC PRIORITÉ

101 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR DÉCALAGE Définition de la structure : TYPE prog = STRUCTURE prio : ENTIER PSW : typeqcq FIN TYPE File_Attente = STRUCTURE Elements : TABLEAU[Max] de prog Queue : ENTIER FIN (3, PSW) (2, PSW) (1, PSW) (0, PSW) Queue

102 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR DÉCALAGE ModèleImplémentation Initfile(F) F.Queue ←-1 Filevide(F) Retourner (F.Queue = -1) Filepleine(F) Retourner (F.Queue = Max-1) Defiler(F,X) SI (NON Filevide(F)) X ← F.Elements[0] POUR I ← 0 à F.Queue - 1 F.Elements[I] ← F.Elements[I+1] F.Queue ← F.Queue – 1

103 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR DÉCALAGE (3, PSW) (2, PSW) (1, PSW) (0, PSW) Queue  Enfiler (F, (2, PSW)) (3, PSW) (2, PSW) (1, PSW) (0, PSW) Queue

104 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR DÉCALAGE  Enfilement:  1 ère méthode: rechercher la bonne position (soit i), décaler les éléments (i à Queue) vers la droite, insérer le nouvel élément et enfin incrémenter la queue.  2 ème méthode: faire un décalage à droite en commençant par la queue jusqu’à trouver la bonne position du nouvel élément, insérer le nouvel élément et enfin incrémenter la queue.  3 ème méthode: incrémenter la queue, insérer le nouvel élément à la queue ensuite essayer de trier le tableau en faisant des permutations (principe de tri par insertion),

105 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR DÉCALAGE 1 ère méthode: Enfiler(F,X) SI (NON Filepleine(F)) I ← 0 //rechercher la bonne position où enfiler X TQ (I  F.Queue) & (F.Elements[I].priorité ≥ X.priorité ) faire I←I+1 //décaler les programmes moins prioritaires J  F.Queue TQ (J ≥I) faire F.Elements[J+1] ← F.Elements[J] J  J-1 //insérer le programme X F.Elements[I] ← X //mettre à jour la queue F.Queue ← F.Queue + 1

106 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR DÉCALAGE 2 ère méthode: Enfiler(F,X) SI (NON Filepleine(F)) I ← F.Queue //décaler les programmes moins prioritaires jusqu’à trouver la bonne position où enfiler X TQ (I ≥ 0) & (F.Elements[I].priorité < X.priorité ) faire F.Elements[I+1] ← F.Elements[I] I←I-1 //insérer le programme X F.Elements[I] ← X //mettre à jour la queue F.Queue ← F.Queue + 1

107 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR DÉCALAGE 3 ème méthode: Enfiler(F,X) SI (NON Filepleine(F)) //mettre à jour la queue F.Queue ← F.Queue + 1 //insérer le programme X F.Elements[F.Queue] ← X //trier le tableau d’éléments I ← F.Queue -1 TQ (I ≥ 0) & (F.Elements[I].priorité > F.Elements[I+1].priorité ) faire Tmp  F.Elements[I] F.Elements[I+1] ← F.Elements[I] F.Elements[I] ← Tmp I←I-1

108 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR T ABLEAU C IRCULAIRE Définition de la structure : TYPE prog = STRUCTURE prio : ENTIER PSW : typeqcq FIN TYPE File_Attente = STRUCTURE Elements : TABLEAU[Max] de prog Queue, Tete : ENTIER FIN (3, PSW) (2, PSW) (1, PSW) (0, PSW) Tete Queue

109 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR T ABLEAU C IRCULAIRE ModèleImplémentation Initfile(F) F.Tête ←Max; F.Queue ←Max Filevide(F) Retourner (F.Tête = F.Queue) Filepleine(F) Retourner (F.Tête = ( (F.Queue +1) Mod Max )) Defiler(F,X) SI ‘(NON Filevide(F)) F.Tete ← (F.Tete + 1)Mod Max X← F.elements[F.Tete]

110 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR T ABLEAU C IRCULAIRE (3, PSW) (2, PSW) (1, PSW) (0, PSW) Queue  Enfiler (F, (2, PSW)) (3, PSW) (2, PSW) (1, PSW) (0, PSW) Queue Tete

111 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR T ABLEAU C IRCULAIRE (1, PSW) (0, PSW) (3, PSW) (2, PSW) (1, PSW) Queue  Enfiler (F, (2, PSW)) Tete (1, PSW) (0, PSW) (3, PSW) (2, PSW) Queue Tete

112 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR T ABLEAU C IRCULAIRE  Enfilement:  1 ère méthode: rechercher la bonne position (soit i), décaler les éléments (i à Queue) vers la droite, insérer le nouvel élément et enfin incrémenter la queue  décalage circulaire.  2 ème méthode: faire un décalage à droite en commençant par la queue jusqu’à trouver la bonne position du nouvel élément, insérer le nouvel élément et enfin incrémenter la queue.  décalage circulaire.

113 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR T ABLEAU C IRCULAIRE  Enfilement:  3 ème méthode: insérer le nouvel élément à la queue ensuite essayer de trier le tableau en faisant des permutations (principe de tri par insertion) (1, PSW) (0, PSW) (2, PSW) (3, PSW) (2, PSW) (1, PSW) Queue Tete (1, PSW) (0, PSW) (3, PSW) (2, PSW) Queue Tete

114 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR T ABLEAU C IRCULAIRE 3 ème Méthode: Enfiler(F,X) SI (NON Filepleine(F)) //mettre à jour la queue F.Queue ← (F.Queue + 1) mod Max //insérer le programme X F.Elements[F.Queue] ← X //trier le tableau d’éléments I ← F.Queue Si I=0 alors J  Max-1; Sinon J  I-1 TQ (I ≠F. Tete) & (F.Elements[I].priorité > F.Elements[J].priorité ) faire Tmp  F.Elements[I] F.Elements[I] ← F.Elements[J] F.Elements[J] ← Tmp Si I=0 alors I  Max-1; Sinon I  I-1 Si J=0 alors J  Max-1; Sinon J  J-1

115 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR T ABLEAU C IRCULAIRE  Enfilement:  3 ème méthode: insérer le nouvel élément à la queue ensuite essayer de trier le tableau en faisant des permutations (principe de tri par insertion)  Décrémentation des indices!!  4 ème méthode: insérer le nouvel élément à la tête ensuite essayer de trier le tableau en faisant des permutations (principe de tri par insertion)

116 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR T ABLEAU C IRCULAIRE (2, PSW) (3, PSW) (2, PSW) (1, PSW) (0, PSW) Queue  Enfiler (F, (2, PSW)) (3, PSW) (2, PSW) (1, PSW) (0, PSW) Queue Tete

117 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR T ABLEAU C IRCULAIRE (2, PSW) (3, PSW) (2, PSW) (1, PSW) (0, PSW) Queue  Enfiler (F, (2, PSW)) (3, PSW) (2, PSW) (1, PSW) (0, PSW) Queue Tete

118 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR T ABLEAU C IRCULAIRE (3, PSW) (2, PSW) (1, PSW) (0, PSW) (2, PSW) Queue  Enfiler (F, (2, PSW)) (2, PSW) (1, PSW) (0, PSW) (3, PSW) Queue Tete

119 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR T ABLEAU C IRCULAIRE (1, PSW) (0, PSW) (2, PSW) (3, PSW) (2, PSW) (1, PSW) Queue  Enfiler (F, (2, PSW)) Tete (1, PSW) (0, PSW) (3, PSW) (2, PSW) (1, PSW) Queue Tete

120 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION STATIQUE PAR T ABLEAU C IRCULAIRE 4 ème Méthode: Enfiler (F, X) SI (NON Filepleine(F)) //insérer le programme X F.Elements[F.Tete] ← X //trier le tableau d’éléments I ← F..Tete J  (I+1)mod Max; TQ (I ≠F. TQueue) & (F.Elements[I].priorité > F.Elements[J].priorité ) faire Tmp  F.Elements[I] F.Elements[I] ← F.Elements[J] F.Elements[J] ← Tmp I  (I+1)mod Max; J  (J+1)mod Max; //mettre à jour la Tête Si F.Tete=0 alors F.Tete  Max-1; Sinon F.Tete  I-1

121 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION D YNAMIQUE (3,PSW) Tête Queue (2,PSW) (1,PSW) (0,PSW) Définition de la structure : TYPE prog = STRUCTURE prio : ENTIER PSW : typeqcq FIN TYPE Maillon = STRUCTURE val : prog suiv: * Maillon FIN TYPE File_Attente = STRUCTURE TêTe, Queue : *Maillon FIN

122 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION D YNAMIQUE ModèleImplémentation Initfile(F) F.Tete ← NIL F.Queue← NIL Filevide(F) Retourner (F.Tete = NIL ) Defiler(F,X) SI (NON Filevide(F)) P ← F.Tete X ← Valeur(F.Tete) F.Tete ← Suivant(F.Tete) Liberer(P)

123 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION D YNAMIQUE  Enfiler (F, (2, PSW)) (3,PSW) Tête Queue (2,PSW) (1,PSW) (0,PSW) (2,PSW) (3,PSW) Tête Queue (2,PSW) (1,PSW) (0,PSW)

124 F ILE D ’ ATTENTE AVEC PRIORITÉ I MPLÉMENTATION D YNAMIQUE Enfiler(F,X) Allouer (P), Aff_Val(P, X), aff_suiv(P, NIL) Si (Filevide(F)) F.Tete ← P; F.Queue ← P Sinon Si (X.prio >Valeur(F.Tete).prio) alors //insertion au début aff_suiv(P, F.Tete); F.Tete←P Sinon S←L TQ (suivant (S)  Nil) et (valeur (suivant (S)) ≥ X.prio) faire S← suivant (S) Si (suivant (S) = Nil) alors //insertion à la fin aff_suiv (S, P); F.Queue ← P Sinon //insertion au milieu aff_suiv(P, suivant (S)), aff_suiv(S, P)

125  Calcul arithmétique : Une application courante des piles se fait dans le calcul arithmétique: l'ordre dans la pile permet d'éviter l'usage des parenthèses.  Exercice 9 (Evaluation d’expression arithmétique postfixée) :  Une expression arithmétique est une combinaison des opérandes (les nombres), des opérateurs [+, -, * ; /, %] et des parenthèses [(, )]. Elle est habituellement écrite de manière infixée, c'est à dire que l'opérateur est placé entre ses deux opérandes. On trouve aussi une notation postfixée où l'opérateur est placé après ses opérandes. L'intérêt de cette notation est qu'il n'y a plus besoin de connaître les priorités des opérateurs, et donc plus besoin de parenthèses. U TILISATION

126 E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE )  Il est demandé de réaliser une calculette qui prend en entrée une LLC représentant une expression arithmétique en notation infixée, et qui affiche le résultat de l'évaluation de cette expression, en utilisant une pile statique. 1.Ecrire les expressions suivantes en postfixée: 5*(((9+8)*(4*6))+7), ~3+2-5*6/2+3, (1+3*4+2)*5 NotationFormatExemples Infixée a + b, a + b * c, (a+b) * c, -a + b Postfixée a b +, a bc* +, ab+ c *, a- b +

Ecrire les expressions suivantes en postfixée: 2. Une expression arithmétique peut être implémentée sous forme d’une LLC où les maillons sont déclarés comme suit: Expressions en infixéeExpressions en postfixée 5 *(((9+8)*(4*6))+7) 5 98*46**7+* ~3+2-5*6/2+3 3~2+56*2/-3+ (1+3*4+2)*5 134*+2+5* E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE )

128 2.Donner la LLC qui présente cette expression 5 * (((9+8)*(4*6))+7) en format infixé et postfixé. Type Terme = structure Op : Chaines de caractères; Prio : {0,1, 2, 3, 4}; Fin Type maillon = structure Val : Terme; Suiv : * maillon ; Fin PrioSignification 0Opérande 1Opérateur binaire (+, -) 2Opérateur binaire ( *, /, %) 3Opérateur unaire ( - unaire) 4Parenthèse ouvrante ou fermante E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE )

129 [‘5’, 0][‘*’, 2][‘(’, 4] [‘9’, 0][‘+’, 2][‘8’, 0][‘)’, 4][‘(’, 4][‘4’, 0][‘*’, 2][‘6’, 0][‘)’, 4] [‘+’, 2][‘)’, 4][‘*’, 2] Linfixe  La LLC qui présente cette expression 5*(((9+8)*(4*6))+7). E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE ) [‘7’, 0]

130 [‘5’, 0][‘9’, 0][‘8’, 0][‘*’, 2][‘4’, 0][‘6’, 0][‘*’, 2] [‘7’, 0][‘*’, 2][‘+’, 1] Lpostfixe  La LLC qui présente cette expression 598*46**7+* E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE )

Ecrire l’algorithme qui permet de transformer une expression infixée en une expression postfixée.  Exemples illustratif: E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE ) Expressions en infixéeExpressions en postfixée 5 *(((9+8)*(4*6))+7) **7+* ~3+2-5*6/2+3 3~2+56*2/-3+ (1+3*4+2)*5 134*+2+5*

132 1.Inserer ([5, 0]) 2.Empiler ([*, 2]) 3.Empiler ([(, 4]) 4.Empiler ([(, 4]) 5.Empiler ([(, 4]) 6.Inserer ([9, 0]) 7.Empiler ([+, 1]) 8.Inserer ([8, 0]) 9.Depiler ([+, 1]); inserer ([+, 1]); Depiler ([(, 4]) 10.Empiler ([*, 2]) 11.Empiler ([(, 4]) [*, 2] [(, 4] [(, 4] 7 [*, 2] [(, 4] [+, 1]  Exemple 1: 5 * (((9+8)*(4*6))+7)  [*, 2] [(, 4] [*, 2] [(, 4] E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE )

Inserer ([4, 0]) 13.Empiler ([*, 2]) 14.Inserer ([6, 0]) 15.Depiler ([*, 2]); inserer ([*, 2]); Depiler ([(, 4]) 16.Depiler ([*, 2]); inserer ([*, 2]); Depiler ([(, 4]) 17.Empiler ([+, 1]); 18.Inserer ([7, 0]) 19.Depiler ([+, 1]); inserer ([+, 1]); Depiler ([(, 4]) 20.Depiler ([*, 2]); inserer ([*, 2]); 13 [*, 2] [(, 4] [*, 2] [(, 4] [*, 2] [(, 4] [*, 2] [(, 4] [*, 2] [(, 4] [*, 2]  Exemple 1: 5 * (((9+8)*(4*6))+7)  **7+* [*, 2] [(, 4] [+, 1] E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE )

134 1.Empiler ([~, 3]) 2.Inserer ([3, 0]) 3. Depiler ([~, 3]); inserer ([~, 3]); Empiler ([+, 1]) 4.Inserer ([2, 0]) 5. Depiler ([+, 1]); insérer ([+, 1]), Empiler ([-, 1]) 6.Inserer ([5, 0]) 7.Empiler ([*, 2] 8.Inserer ([6, 0]) 9. Depiler ([*, 2]); inserer ([*, 2]); Empiler ([/, 2]) 10.Inserer ([2, 0]) 11. Depiler ([/, 2]); inserer ([/, 2]); Depiler ([-, 1]); inserer ([-, 1]); Empiler ([+, 1]) 12.Inserer ([3, 0]) 13. Depiler ([+, 1]); inserer ([+, 1]); [~, 3] 1 [-, 1] 5 [+, 1] 3 [-, 1] 7 [*, 2]  Exemple 2: ~3+2-5*6/2+3  3~2+56*2/-3+ [-, 1] 9 [/, 2][+, 1] 11 E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE )

135 1.Empiler ([(, 4]) 2.Inserer ([1, 0]) 3.Empiler ([+, 1]) 4.Inserer ([3, 0]) 5.Empiler ([*, 2]) 6.Inserer ([4, 0]) 7. Depiler ([*, 2]); inserer ([*, 2]); Depiler ([+, 1]); insérer ([+, 1]), Empiler ([+, 1]) 8.Inserer ([2, 0]) 9. Depiler ([+, 1]); inserer ([+, 1]); Depiler ([(, 4]) 10.Empiler ([*, 2]) 11.Inserer ([5, 0]) 12. Depiler ([*, 2]); inserer ([*, 2]); [(, 4] 1 3 [+, 1] [(, 4] 5 [+, 1] [*, 2] [(, 4] 7 [+, 1]  Exemple 3: (1+3*4+2)*5  134*+2+5* [*, 2] 10 E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE )

136  Transformation infixée  postfixée (Pseudo Algorithme): Lire l’expression infixée terme par terme: Si c'est un opérande alors on insère dans la liste L postfixée Si c’est une parenthèse ouvrante alors on doit l’empiler tout le temps. Si c’est une parenthèse fermante alors on doit dépiler jusqu'à trouver la parenthèse ouvrante associée. Les éléments dépilés sont insérés dans la liste L postfixée Si c'est un opérateur, Si la pile est vide ou si l'opérateur est plus prioritaire que l'opérateur en sommet de pile, alors on l'empile. Sinon, on dépile jusqu'à pouvoir l'empiler. Les éléments dépilés sont insérés dans la liste L postfixée E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE )

137  Transformation infixée  postfixée (Déclaration): E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE ) Type Terme = structure Op : Chaines de caractères; Prio : {0,1, 2, 3, 4}; Fin Type Maillon = structure Val : Terme; Suiv : *Maillon ; Fin Type Pile= structure Elements : tableau[Max] de Terme Sommet : entier Fin PrioSignification 0Opérande 1Opérateur binaire (+, -) 2Opérateur binaire ( *, /, %) 3Opérateur unaire ( - unaire) 4Parenthèse ouvrante ou fermante

138  Transformation infixée  postfixée (Algorithme): E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE ) InfixeAPostfixe( Linfixe: *Maillon) : *Maillon Var P: Pile; Lpostfixe, Q:*Maillon; X, Y: Terme Debut Lpostfixe  Nil; Q  Linfixe; InitPile(P) Tant que (Q≠Nil) faire X  valeur (Q); Si X.prio = 0 alors InsererLLCFin (Lpostfixe, X) FSI Si X.op ='(‘ alors Empiler(P, X) FSI Si X.op = ‘)’ alors // depiler (et ecrire...) jusqu'a l'ouvrante Tant que P.Elements[P.Sommet]≠ ‘(‘ faire depiler(P, Y); InsererLLCFin (Lpostfixe, Y) FTQ depiler(P,Y) // et depiler l'ouvrante ! FSI InfixeAPostfixe( Linfixe: *Maillon) : *Maillon Var P: Pile; Lpostfixe, Q:*Maillon; X, Y: Terme Debut Lpostfixe  Nil; Q  Linfixe; InitPile(P) Tant que (Q≠Nil) faire X  valeur (Q); Si X.prio = 0 alors InsererLLCFin (Lpostfixe, X) FSI Si X.op ='(‘ alors Empiler(P, X) FSI Si X.op = ‘)’ alors // depiler (et ecrire...) jusqu'a l'ouvrante Tant que P.Elements[P.Sommet]≠ ‘(‘ faire depiler(P, Y); InsererLLCFin (Lpostfixe, Y) FTQ depiler(P,Y) // et depiler l'ouvrante ! FSI

139  Transformation infixée  postfixée (Algorithme): E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE ) Si X.prio = 1, 2 ou 3 alors //c’est un operateur Tant que (non Pilevide(P)) et (P.Elements[P.Sommet]≠ ‘(‘ ) et (P.Elements[P.Sommet].prio ≤X.prio) faire depiler(P,Y) InsererLLCFin (Lpostfixe, Y) FTQ Empiler(T[i].valeur,P) FSI Q  suivant (Q); FTQ // maintenant vider la pile Tant que non Pilevide(P) faire depiler(P,Y) InsererLLCFin (Lpostfixe, Y) FTQ Retourner (Lpostfixe) Fin Si X.prio = 1, 2 ou 3 alors //c’est un operateur Tant que (non Pilevide(P)) et (P.Elements[P.Sommet]≠ ‘(‘ ) et (P.Elements[P.Sommet].prio ≤X.prio) faire depiler(P,Y) InsererLLCFin (Lpostfixe, Y) FTQ Empiler(T[i].valeur,P) FSI Q  suivant (Q); FTQ // maintenant vider la pile Tant que non Pilevide(P) faire depiler(P,Y) InsererLLCFin (Lpostfixe, Y) FTQ Retourner (Lpostfixe) Fin

Donner l’algorithme d’évaluation d’une expression postfixée.  Exemples illustratif: E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE ) Expressions en infixée Expressions en postfixée Evaluation 5 *(((9+8)*(4*6))+7)5 98*46**7+* 2075 ~3+2-5*6/2+33~2+56*2/ (1+3*4+2)*5134*+2+5* 75

141 1.empiler(5) 2.empiler(9) 3.empiler(8) 4.depiler (8); depiler (9); empiler(9 + 8) 5.empiler(4) 6.empiler(6) 7.depiler (6); depiler (4); empiler(4*6) 8.depiler (24); depiler (17); empiler( 17 * 24 ) 9.empiler(7) 10.depiler (7); depiler (408); empiler(408+7) 11.depiler (415); depiler (5); empiler( 5*415) 12.depiler(2075) « 10 » 2075 « 11 » « 9 » « 8 » « 5 » « 6 » « 7 » 5 « 1 » 5 9 « 2 » « 3 » 5 17 « 4 »  Exemple 1: **7+* = 2075 E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE )

142 1.empiler(3) 2.depiler(3) ; empiler(0-3) 3.empiler(2) 4.depiler (2); depiler (-3); empiler( ) 5.empiler(5) 6.empiler(6) 7.depiler (6); depiler (5); empiler(5*6) 8.empiler(2) 9.depiler (2); depiler (30); empiler(30/2) 10.depiler (15); depiler (-1); empiler(-1-15) 11.empiler (3) 12.depiler (3); depiler (-16); empiler(-16+3) 13.depiler (-13) 30 « 7 » 30 2 « 8 » 3 « 1 » -3 « 2 » -3 2 « 3 » 5 6 « 4-6 » 15 « 9 » « 10 » -13 « 12 » E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE )  Exemple 2: 3~2+56*2/-3+ = -13

143 1.empiler(1) 2.empiler(3) 3.empiler(4) 4.depiler (4); depiler (3); empiler( 3 * 4) 5.depiler (12); depiler (1); empiler(1+12) 6.empiler(2) 7.depiler (2); depiler (13); empiler(13+2) 8.empiler(5) 9.depiler (5); depiler (15); empiler(15*5) 10.depiler (75) 5 13 « 5 » 13 2 « 6 » 1 « 1 » 1 3 « 2 » 1 12 « 4 » 15 « 7-8 » 75 « 9 » « 3 » E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE )  Exemple 3: 134*+2+5* = 75

144  Evaluation d'une expression postfixée (Pseudo Algorithme) Lire l’expression postfixée terme par terme: Si c’est un opérande alors on l’empile Si c’est un opérateur alors Si c’est un opérateur unaire (moins unaire) alors on dépile une fois, on multiple par (-1) ensuite on empile le résultat Si c’est opérateur binaire alors on dépile deux fois, on fait le calcul correspondant, ensuite on empile le résultat. A la fin : Le résultat final se trouve au sommet de pile E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE )

145  Evaluation d'une expression postfixée (Déclaration) E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE ) Type Terme = structure Op : Chaines de caractères; Prio : {0,1, 2, 3, 4}; Fin Type Maillon = structure Val : Terme; Suiv : *Maillon ; Fin Type Pile1= structure Elements : tableau[Max] de chaines de caractères Sommet : entier Fin PrioSignification 0Opérande 1Opérateur binaire (+, -) 2Opérateur binaire ( *, /, %) 3Opérateur unaire ( - unaire) 4Parenthèse ouvrante ou fermante

146  Evaluation d'une expression postfixée (Fonction Calcul) E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE ) Procédure Calcul (op : caractère, op1, op2, res : chaines de caractères) Var X, Y, Z : entier Debut // convertir les opérandes en entier X  ConvertirChaineEntier(op1) ; Y  ConvertirChaineEntier(op2) ; //réaliser l’opération correspondante Selon op Cas ‘+’: Z  X+Y Cas ‘-’: Z  X-Y Cas ‘*’: Z  X*Y Cas ‘/’: Z  X/Y Cas ‘%’: Z  X%Y Finselon //convertir le résultat en chaîne de caractère Res  ConvertirEntierChaine(Z) Fin Procédure Calcul (op : caractère, op1, op2, res : chaines de caractères) Var X, Y, Z : entier Debut // convertir les opérandes en entier X  ConvertirChaineEntier(op1) ; Y  ConvertirChaineEntier(op2) ; //réaliser l’opération correspondante Selon op Cas ‘+’: Z  X+Y Cas ‘-’: Z  X-Y Cas ‘*’: Z  X*Y Cas ‘/’: Z  X/Y Cas ‘%’: Z  X%Y Finselon //convertir le résultat en chaîne de caractère Res  ConvertirEntierChaine(Z) Fin

 Evaluation d'une expression postfixée (Algorithme) E XERCICE 9 (E VALUATION D ’ EXPRESSION ARITHMÉTIQUE POSTFIXÉE ) EVAL_Postfixe( L: *Maillon) : entier Initpile(P); Q  L postfixe Tant que (Q≠Nil) faire X  valeur (Q) Si (X.prio=0) alors Empiler( P, X.op ) //opérande Sinon /* donc c'est un opérateur */ Si (X.prio=3) // moins unaire Depiler(P,Y); Calcul(‘*’,‘-1’, Y, Y); Empiler(P, Y) Sinon Si (X.prio=1) ou (X.prio=2) alors /* donc opérateur binaire */ Depiler(P,b); Depiler(P,a); Calcul(X.op, a, b, a); Empiler( P, a) Q  suivant (Q) FTQ Depiler( P, res ) // le résultat se trouve au sommet Retourner (ConvertirChaineEntier (res)) EVAL_Postfixe( L: *Maillon) : entier Initpile(P); Q  L postfixe Tant que (Q≠Nil) faire X  valeur (Q) Si (X.prio=0) alors Empiler( P, X.op ) //opérande Sinon /* donc c'est un opérateur */ Si (X.prio=3) // moins unaire Depiler(P,Y); Calcul(‘*’,‘-1’, Y, Y); Empiler(P, Y) Sinon Si (X.prio=1) ou (X.prio=2) alors /* donc opérateur binaire */ Depiler(P,b); Depiler(P,a); Calcul(X.op, a, b, a); Empiler( P, a) Q  suivant (Q) FTQ Depiler( P, res ) // le résultat se trouve au sommet Retourner (ConvertirChaineEntier (res))  Evaluation d'une expression postfixée (Algorithme) 147