Corrigé 30.  Enoncé

1. Epuration des listes bilatérales (version itérative)

Module Sous-liste (L, Tete, queue)


    Tete := NIL
    Queue := L
    { cette dernière initialisation ne sert que pour rendre le test Suivant(Queue) valide dans la deuxième boucle dans         le cas particulier oł la liste contient un     seul élément ou pas de doubles du tout }
    { Trouver les deux premiers éléments identiques }
    L := L ; Trouv := FAUX
    TANTQUE Suivant(L) <> NIL ET NON Trouv :
        SI Valeur(L) = Valeur (Suivant(L) )
            Trouv := VRAI;
            Tete := L
            Queue := Suivant(L)
        FSI
        L := Suivant(L)
    FINTANTQUE

    { Déterminer les autres éléments identiques }

    TANTQUE Suivant(Queue) <> NIL ET Trouv :
        SI Valeur(Queue) = Valeur(Suivant(Queue))
            Queue := Suivant(Queue)
        SINON
            Trouv := FAUX
        FSI
    FINTANTQUE

Si la sous-liste n'est pas trouvée, Tete est à NIL.



Module Supprimer(L, Tete, Queue)

    SI Précédent(Tete) # NIL :
        Aff_Adrd(Précédent(Tete), Suivant(Queue))
    SINON
        L := Suivant (Queue)
    FSI
    SI Suivant(Queue) # NIL :
        Aff_Adrg( Suivant(Queue), Précédent(Tete) )
    FSI

    { Libération des éléments de la sous liste }

    TANTQUE Tete <> Queue
        L := Tete
        Libérer(L)
        Tete := Suivant(Tete)
    FINTANTQUE
    Liberer(Queue)
   
Suppression des éléments identiques dans une liste bilatérale

    Continue := VRAI
    TANTQUE Continue
        Sous-Liste(L, Tete, Queue)
        SI Tete = NIL
            Continue := FAUX
        SINON
            { On garde un seul élément parmi les doubles }
            Supprimer(L, Suivant(Tete), Queue)
        FSI
    FINTANTQUE

2. Epuration des listes bilatérales ( version récursive)

Module SUPPR ( L )

Dans cet algorithme, l'élément supprimé n'est pas le premier élément de la liste.


    SI Précédent(L) # NIL :
        Aff_Adrd( Précédent(L), Suivant(L) )
    FSI
    SI Suivant(L) # NIL :
        Aff_Adrg( Suivant(L), Précédent(L) )
    FSI
    Libérer(L)

Module récursif SUP (L)

    SI Suivant(L) = NIL
        Sup := L
    SINON
        SI Valeur(L) = Valeur(Suivant(L))
            Sup := Sup(Suppr(Suivant(L)))
        SINON
            Sup := Sup(Suivant(L))
        FSI
    FSI       


3. Implémentation d'une liste de piles de files d'attente

    {Liste de piles}
    Typeliste = STRUCTURE
        Vl : Typepile
        Adrl : POINTEUR(Typeliste)
    FIN.
    TYPE Typepile = POINTEUR(Type_elementpile)

    {Pile de files d'attente}
    TYPE Type_elementpile = STRUCTURE
        Vp : Typefile
        Adrp : POINTEUR(Type_elementpile)
    FIN

    {File}
    TYPE Typefile = STRUCTURE
        Tete, Queue : POINTEUR(Type_elementfile)
    FIN

    TYPE Type_elementfile = STRUCTURE
        Vf : Typeqq
        Adrf : POINTEUR(Type_elementfile)
    FIN