TD1 Les listes chaînées - FR

TD no 1 (corrigé)
ESIEE IGI-3005
2016-2017
Les listes chaînées (corrigé)
Tous les exercices sont à faire.
Pas de compte-rendu obligatoire.
Le compte-rendu du TP suivant en tiendra lieu.
1
Implémentation de liste chaînée en tableau
1.1
Principe
Une liste chaînée peut être représentée par deux tableaux, l’un (contenu) contenant des
valeurs et l’autre (suivant) contenant des indices. Le chaînage sera effectué de la façon suivante :
l’élément suivant contenu[k] aura suivant[k] comme indice dans le tableau contenu.
La liste sera l’indice dans le tableau contenu du premier élément. L’élément situé en fin de
liste sera associé à une valeur spéciale dans le tableau suivant (-1 par exemple).
Ainsi, la liste :
'q'
't'
lst
'w'
'r'
peut être représentée par :
'e'
lst
0
1
2
3
4
2
contenu
'q'
'w'
'e'
'r'
't'
suivant
3
-1
0
4
1
La valeur de la tête de liste (lst) est l’élément no 2 du tableau contenu ('e'). Le suivant est
l’élément no 0 ('q') et ainsi de suite jusqu’au dernier élément 'w' associé à -1 indiquant la fin de
la liste.
Pour afficher la liste, on pourra utiliser l’algorithme suivant :
Algorithme - Affichage itératif d’une liste
parcours de liste représentée par tableau
itération sur les éléments de tableau à partir de la tête
PROCÉDURE affichageListeIteratif
DONNÉES
: lst ∈ ENT // la tête de la liste
DONNÉES
: contenu ∈ TAB de CAR , suivant ∈ TAB de ENT
p
lst
TANT QUE p 6= -1 FAIRE
afficher (contenu[p])
p
suivant[p]
FIN TANT QUE
FIN PROCÉDURE
–1/15–
TD no 1 (corrigé)
ESIEE IGI-3005
2016-2017
Exercice 1. Écrire l’algorithme récursif de parcours de cette liste
Algorithme à écrire 1 - Affichage récursif d’une liste
parcours de liste représentée par tableau
affichage de la tête, affichage récursif de la suite
PROCÉDURE affichageListeRécursif
DONNÉES
: lst ∈ ENT
DONNÉES
: contenu ∈ TAB de CAR , suivant ∈ TAB de ENT
...
FIN PROCÉDURE
Corrigé
***************************************************************************
Algorithme - Affichage récursif d’une liste
parcours de liste représentée par tableau
affichage de la tête, affichage récursif de la suite
PROCÉDURE affichageListeRecursif
DONNÉES
: lst ∈ ENT
DONNÉES
: contenu ∈ TAB de CAR , suivant ∈ TAB de ENT
SI lst 6= -1 ALORS
afficher (contenu[lst])
affichageListeRecursif(suivant[lst])
FIN SI
FIN PROCÉDURE
***************************************************************************
1.2
Ajout d’un élément en tête de liste
Soit la liste suivante :
lst
2
Mémoire de gestion de liste
contenu suivant
0
'q'
3
1
'w'
-1
2
'e'
0
3
'r'
4
4
't'
1
Si on ajoute un élément (par exemple 'a') en tête de liste, il faudra :
– le placer dans le tableau contenu (en dernière position)
– le chaîner à l’ancienne tête de liste
– modifier la valeur de lst pour qu’elle indique ce nouvel élément.
–2/15–
TD no 1 (corrigé)
ESIEE IGI-3005
2016-2017
Exercice 2. Faire un schéma de la configuration après insertion de 'a' en tête de liste
Corrigé
***************************************************************************
lst
5
Mémoire de gestion de liste
contenu suivant
0
'q'
3
1
'w'
-1
2
'e'
0
3
'r'
4
4
't'
1
5
'a'
2
***************************************************************************
Pour écrire l’algorithme, il est nécessaire d’avoir un marqueur indiquant la position du tableau
à laquelle une insertion peut se faire (première position non occupée) :
Mémoire de gestion de liste
libre 5
lst
2
0
1
2
3
4
contenu
'q'
'w'
'e'
'r'
't'
suivant
3
-1
0
4
1
Exercice 3. Écrire l’algorithme de la procédure permettant d’insérer un nouvel élément
en tête de liste
C’est une procédure qui est demandée. La donnée indiquant la tête de liste doit donc être
modifiable. D’autre part, on ne se préoccupera pas de la taille réelle du tableau (considéré comme
infini)
Algorithme à écrire 2 - Insertion en tête de liste
PROCÉDURE insereEnTete
DONNÉES
: c ∈ CAR
DONN. MOD. : lst ∈ ENT
DONN. MOD. : contenu ∈ TAB de CAR , suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
...
FIN PROCÉDURE
Corrigé
***************************************************************************
–3/15–
ESIEE IGI-3005
TD no 1 (corrigé)
2016-2017
Algorithme - Insertion en tête de liste
PROCÉDURE insereEnTete
DONNÉES
: c ∈ CAR
DONN. MOD. : lst ∈ ENT
DONN. MOD. : contenu ∈ TAB de CAR , suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
contenu[libre]
c
suivant[libre]
lst
lst
libre
libre
libre + 1
FIN PROCÉDURE
***************************************************************************
1.3
Vider la liste
Cette opération est simple : il suffit d’indiquer que le premier emplacement libre est l’élément no 0 et mettre lst à une valeur impossible (-1). Il n’est pas nécessaire de remettre à 0 les
contenus des tableaux.
Exercice 4. Écrire l’algorithme de la procédure permettant de vider la liste et faire un
schéma de la configuration après remise à zéro de la liste
Algorithme à écrire 3
PROCÉDURE raz
DONN. MOD. : lst ∈ ENT
DONN. MOD. : libre ∈ ENT
...
FIN PROCÉDURE
Corrigé
***************************************************************************
Algorithme
PROCÉDURE raz
DONN. MOD. : lst ∈ ENT
DONN. MOD. : libre ∈ ENT
lst
-1
0
libre
FIN PROCÉDURE
–4/15–
TD no 1 (corrigé)
ESIEE IGI-3005
2016-2017
Mémoire de gestion de liste
libre 0
lst
-1
0
1
2
3
4
5
contenu
'q'
'w'
'e'
'r'
't'
'a'
suivant
3
-1
0
4
1
2
***************************************************************************
1.4
Autres opérations
Maintenir un tri sur la liste, supprimer des éléments de la liste sont des opérations possibles.
Mais si les ajouts se font systématiquement en fin de tableau, les suppressions créeront des trous
irrécupérables. La suite du TD propose une solution utilisant une liste des places libres pour
accéder aux emplacements non occupés.
2
Gestion par liste des emplacements libres
Une liste chaînée particulière permettra d’accéder aux emplacements libres.
– ajouter un élément à une liste consistera à enlever un élément de la liste des places libres
et pour l’inclure dans la liste modifiée ;
– supprimer un élément d’une liste consistera à l’enlever de la liste active et l’ajouter à la
liste des places libres.
2.1
Représentation mémoire
Exercice 5. À partir de la configuration initiale représentée ci-dessous, dessiner les configurations après chacune les opérations indiquées
Mémoire de gestion de liste
libre 0
lst
-1
0
1
2
3
4
5
contenu
?
?
?
?
?
?
suivant
1
2
3
4
5
-1
La liste lst est vide (-1). Les éléments de tableaux disponibles sont eux mêmes dans une liste
chaînée libre commençant en 0.
–5/15–
TD no 1 (corrigé)
ESIEE IGI-3005
–
–
–
–
–
–
2016-2017
ajouter '2' en tête de liste ;
ajouter 'x' en tête de liste ;
ajouter 'T' en tête de liste ;
supprimer 'x' de la liste ;
ajouter 'S' en tête de liste ;
ajouter '0' après 'T'.
Corrigé
***************************************************************************
Mémoire de gestion de liste
libre 1
Ajouter '2' en tête de liste
lst
0
0
1
2
3
4
5
contenu
'2'
?
?
?
?
?
suivant
-1
2
3
4
5
-1
Mémoire de gestion de liste
libre 2
Ajouter 'x' en tête de liste
lst
1
0
1
2
3
4
5
contenu
'2'’
'x'
?
?
?
?
suivant
-1
0
3
4
5
-1
Mémoire de gestion de liste
libre 3
Ajouter 'T' en tête de liste
lst
2
0
1
2
3
4
5
–6/15–
contenu
'2'
'x'
'T'
?
?
?
suivant
-1
0
1
4
5
-1
TD no 1 (corrigé)
ESIEE IGI-3005
2016-2017
Mémoire de gestion de liste
libre 1
Supprimer 'x' de la liste
0
1
2
3
4
5
2
lst
contenu
'2'
'x'
'T'
?
?
?
suivant
-1
3
0
4
5
-1
Mémoire de gestion de liste
libre 3
Ajouter 'S' en tête de liste
lst
0
1
2
3
4
5
1
contenu
'2'
'S'
'T'
?
?
?
suivant
-1
2
0
4
5
-1
Mémoire de gestion de liste
libre 4
Ajouter '0' après 'T'
lst
1
0
1
2
3
4
5
contenu
'2'
'S'
'T'
'0'
?
?
suivant
-1
2
3
0
5
-1
***************************************************************************
2.2
Initialisation de la mémoire de gestion de liste
On notera T la taille des tableaux contenu et suivant.
Exercice 6. Écrire l’algorithme d’initialisation permettant d’obtenir la configuration suivante :
–7/15–
TD no 1 (corrigé)
ESIEE IGI-3005
2016-2017
Mémoire de gestion de liste
libre 0
0
1
2
3
4
5
contenu
?
?
?
?
?
?
suivant
1
2
3
4
5
-1
Algorithme à écrire 4 - Initialisation de la mémoire de gestion de liste
initialise le tableau suivant en chaînant chaque élément à son suivant, le dernier étant chaîné
à -1. Initialise la chaîne libre à 0
itération classique
PROCÉDURE init
DONN. MOD. : suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
DONNÉES
: T ∈ ENT
....
FIN PROCÉDURE
Corrigé
***************************************************************************
Algorithme - Initialisation de la mémoire de gestion de liste
initialise le tableau suivant en chaînant chaque élément à son suivant, le dernier étant chaîné
à -1. Initialise la chaîne libre à 0
itération classique
PROCÉDURE init
DONN. MOD. : suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
DONNÉES
: T ∈ ENT
i
0
TANT QUE i < T FAIRE
suivant[i]
i + 1
i
i + 1
FIN TANT QUE
-1
suivant[T - 1]
libre
0
FIN PROCÉDURE
***************************************************************************
2.3
Allocation d’une place libre
Demander une place pour écrire un nouvel élément nécessite de consulter la liste des places
libres et retourner une place libre (le plus simple étant d’en retourner la tête de liste). Il conviendra
de supprimer cette place de la liste des places libres.
–8/15–
ESIEE IGI-3005
TD no 1 (corrigé)
2016-2017
Exercice 7. Écrire l’algorithme d’allocation de place
Algorithme à écrire 5 - Réservation d’une place dans le tableau
retourne le no du premier élément libre du tableau et met à jour la tête de liste des éléments
libres
FONCTION allouePlace
DONN. MOD. : suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
RÉSULTAT
: ENT
....
FIN FONCTION
Corrigé
***************************************************************************
Algorithme - Réservation d’une place dans le tableau
retourne le no du premier élément libre du tableau et met à jour la tête de liste des éléments
libres
FONCTION allouePlace
DONN. MOD. : suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
RÉSULTAT
: ENT
SI libre = -1 ALORS
RETOUR
-1 // allocation impossible
SINON
n
libre
libre
suivant[n]
RETOUR
n
FIN SI
FIN FONCTION
***************************************************************************
2.4
Libération d’une place occupée
De même, si on ne désire plus se servir d’une place, il conviendra de l’ajouter à la liste des
places libres place pour la rendre disponible en cas de nouvelle allocation.
Exercice 8. Écrire l’algorithme de libération d’une place occupée
Algorithme à écrire 6 - Libération d’une place occupée
ajoute le no indiqué à la liste des éléments libres
PROCÉDURE liberePlace
DONNÉES
: n ∈ ENT
DONN. MOD. : suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
....
FIN PROCÉDURE
–9/15–
TD no 1 (corrigé)
ESIEE IGI-3005
2016-2017
Corrigé
***************************************************************************
Algorithme - Libération d’une place occupée
ajoute le no indiqué à la liste des éléments libres
PROCÉDURE liberePlace
DONNÉES
: n ∈ ENT
DONN. MOD. : suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
suivant[n]
libre
n
FIN PROCÉDURE
libre
***************************************************************************
2.5
Insertion en tête de liste
Exercice 9. Écrire l’algorithme de la fonction qui ajoute un caractère en tête de liste
Algorithme à écrire 7 - Insertion en tête de liste
insère le caractère c dans une liste. Retourne la valeur de la nouvelle tête de liste
alloue une place, la remplit, la chaîne sur l’ancienne tête de liste, retourne le numéro de place
alloué
FONCTION insereEnTete
DONNÉES
: tete ∈ ENT , c ∈ CAR
DONN. MOD. : contenu ∈ TAB de CAR , suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
RÉSULTAT
: ENT
...
FIN FONCTION
Corrigé
***************************************************************************
Algorithme - Insertion en tête de liste
insère le caractère c dans une liste. Retourne la valeur de la nouvelle tête de liste
alloue une place, la remplit, la chaîne sur l’ancienne tête de liste, retourne le numéro de place
alloué
FONCTION insereEnTete
DONNÉES
: tete ∈ ENT , c ∈ CAR
DONN. MOD. : contenu ∈ TAB de CAR , suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
RÉSULTAT
: ENT
allouePlace(suivant, libre)
m
suivant[m]
tete
contenu[m]
c
RETOUR
m
FIN FONCTION
–10/15–
ESIEE IGI-3005
TD no 1 (corrigé)
2016-2017
***************************************************************************
2.6
Suppression de la tête de liste
Exercice 10. Écrire l’algorithme de la fonction qui supprime la tête d’une liste
On suppposera la liste non vide.
Algorithme à écrire 8 - Suppression de la tête de liste
Supprime le premier élément d’une liste et retourne la valeur de la nouvelle tête de liste
libère la place de l’élément de tête et retourne la place de l’élément suivant
FONCTION supprimeTete
DONNÉES
: tete ∈ ENT
DONN. MOD. : suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
RÉSULTAT
: ENT
...
FIN FONCTION
Corrigé
***************************************************************************
Algorithme - Suppression de la tête de liste
Supprime le premier élément d’une liste et retourne la valeur de la nouvelle tête de liste
libère la place de l’élément de tête et retourne la place de l’élément suivant
FONCTION supprimeTete
DONNÉES
: tete ∈ ENT
DONN. MOD. : suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
RÉSULTAT
: ENT
suivant[tete]
m
liberePlace(tete, suivant, libre)
RETOUR
m
FIN FONCTION
***************************************************************************
2.7
Initialisation d’une liste
Une liste devra être initialisée. C’est simplement la mise à -1 de la valeur de l’entier correspondant à la liste.
Attention : l’initialisation d’une liste (première utilisation) ne doit pas être confondue avec
la remise à zéro d’une liste existante (libération)
–11/15–
ESIEE IGI-3005
TD no 1 (corrigé)
2016-2017
Exercice 11. Écrire l’algorithme de la fonction qui initialise une liste
On suppposera la liste non encore utilisée.
Algorithme à écrire 9 - Initialisation de la liste
Retourne -1
FONCTION initListe
RÉSULTAT
: ENT
...
FIN FONCTION
Corrigé
***************************************************************************
Algorithme - Initialisation de la liste
Retourne -1
FONCTION initListe
RÉSULTAT
: ENT
RETOUR
-1
FIN FONCTION
***************************************************************************
2.8
Remise à zéro de la liste (libération)
En fin d’utilisation, il faut prévoir de vider la liste pour rendre la mémoire utilisée. C’est le
rôle de la libération de la liste.
Attention : la libération d’une liste (après utilisation) ne doit pas être confondue avec
l’initialisation d’une nouvelle liste.
Exercice 12. Écrire l’algorithme de la procédure qui libère une une liste existante
Algorithme à écrire 10 - Libération d’une liste
Désalloue chaque place de la liste
libération récursive
PROCÉDURE libereListe
DONNÉES
: tete ∈ ENT
DONN. MOD. : suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
...
FIN PROCÉDURE
Corrigé
***************************************************************************
–12/15–
ESIEE IGI-3005
TD no 1 (corrigé)
2016-2017
Algorithme - Libération d’une liste
Désalloue chaque place de la liste
libération récursive
PROCÉDURE libereListe
DONNÉES
: tete ∈ ENT
DONN. MOD. : suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
SI tete 6= -1 ALORS
libereListe(suivant[tete], suivant, libre)
liberePlace(tete, suivant, libre)
FIN SI
FIN PROCÉDURE
***************************************************************************
2.9
Insertion dans une liste triée
Exercice 13. Écrire l’algorithme de la fonction qui ajoute un caractère dans une liste triée
Algorithme à écrire 11 - Insertion dans une liste triée
insère un caractère c dans une liste triée. Retourne la valeur de la nouvelle tête de liste
Algo récursif. Si la liste est vide ou si l’élément à insérer est inférieur à l’élément en tête de
liste, on insère en tête, sinon on appelle récursivement l’insertion triée sur le suivant de la tête
de liste.
FONCTION insereTrie
DONNÉES
: tete ∈ ENT , c ∈ CAR
DONN. MOD. : contenu ∈ TAB de CAR , suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
RÉSULTAT
: ENT
...
FIN PROCÉDURE
Corrigé
***************************************************************************
–13/15–
ESIEE IGI-3005
TD no 1 (corrigé)
2016-2017
Algorithme - Insertion dans une liste triée
insère un caractère c dans une liste triée. Retourne la valeur de la nouvelle tête de liste
Algo récursif. Si la liste est vide ou si l’élément à insérer est inférieur à l’élément en tête de
liste, on insère en tête, sinon on appelle récursivement l’insertion triée sur le suivant de la tête
de liste.
FONCTION insereTrie
DONNÉES
: tete ∈ ENT , c ∈ CAR
DONN. MOD. : contenu ∈ TAB de CAR , suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
RÉSULTAT
: ENT
SI tete = -1 ou c ≤ contenu[tete] ALORS
RETOUR
insereEnTete(tete, c, contenu, suivant, libre)
SINON
suivant[tete]
insereTrie(suivant[tete], c, contenu, suivant, libre)
tete
RETOUR
FIN SI
FIN PROCÉDURE
***************************************************************************
2.10
Suppression dans une liste triée
Exercice 14. Écrire l’algorithme de la fonction qui supprime un caractère dans une liste
triée
Algorithme à écrire 12 - Suppression dans une liste triée
supprime un caractère c dans une liste triée. Retourne la valeur de la nouvelle tête de liste
Algo récursif. Si la liste est vide ou si l’élément à supprimer est inférieur à l’élément en tête de
liste, on ne fait rien, sinon si l’élément à supprimer est égal à la tete de liste, on supprime en
tête, sinon on appelle récursivement la suppression sur le suivant de la tête de liste.
FONCTION supprimeTrie
DONNÉES
: tete ∈ ENT , c ∈ CAR
DONNÉES
: contenu ∈ TAB de CAR
DONN. MOD. : suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
RÉSULTAT
: ENT
...
FIN PROCÉDURE
Corrigé
***************************************************************************
–14/15–
ESIEE IGI-3005
TD no 1 (corrigé)
2016-2017
Algorithme - Suppression dans une liste triée
supprime un caractère c dans une liste triée. Retourne la valeur de la nouvelle tête de liste
Algo récursif. Si la liste est vide ou si l’élément à supprimer est inférieur à l’élément en tête de
liste, on ne fait rien, sinon si l’élément à supprimer est égalà la tete de liste, on supprime en
tête, sinon on appelle récursivement la suppression sur le suivant de la tête de liste.
FONCTION supprimeTrie
DONNÉES
: tete ∈ ENT , c ∈ CAR
DONNÉES
: contenu ∈ TAB de CAR
DONN. MOD. : suivant ∈ TAB de ENT
DONN. MOD. : libre ∈ ENT
RÉSULTAT
: ENT
SI tete = -1 or c < contenu[tete] ALORS
RETOUR
tete
SINON
SI c = contenu[tete] ALORS
RETOUR
supprimeTete(tete, suivant, libre)
SINON
suivant[tete]
supprimeTrie(suivant[tete], c, contenu, suivant, libre)
RETOUR
tete
FIN SI
FIN SI
FIN PROCÉDURE
***************************************************************************
–15/15–
Schéma de la liste chaînée
Mémoire de gestion de liste
libre
contenu
lst
suivant
0
1
2
3
4
5
6
Schéma de la liste chaînée
Mémoire de gestion de liste
libre
contenu
lst
suivant
0
1
2
3
4
5
6
Schéma de la liste chaînée
Mémoire de gestion de liste
libre
contenu
lst
0
1
2
3
4
5
6
suivant
Schéma de la liste chaînée
Mémoire de gestion de liste
libre
contenu
lst
suivant
0
1
2
3
4
5
6
Schéma de la liste chaînée
Mémoire de gestion de liste
libre
contenu
lst
suivant
0
1
2
3
4
5
6
Schéma de la liste chaînée
Mémoire de gestion de liste
libre
contenu
lst
0
1
2
3
4
5
6
suivant
Schéma de la liste chaînée
Mémoire de gestion de liste
libre
contenu
lst
suivant
0
1
2
3
4
5
6
Schéma de la liste chaînée
Mémoire de gestion de liste
libre
contenu
lst
suivant
0
1
2
3
4
5
6
Schéma de la liste chaînée
Mémoire de gestion de liste
libre
contenu
lst
0
1
2
3
4
5
6
suivant
Schéma de la liste chaînée
Mémoire de gestion de liste
libre
contenu
lst
suivant
0
1
2
3
4
5
6
Schéma de la liste chaînée
Mémoire de gestion de liste
libre
contenu
lst
suivant
0
1
2
3
4
5
6
Schéma de la liste chaînée
Mémoire de gestion de liste
libre
contenu
lst
0
1
2
3
4
5
6
suivant