Faculté des Sciences de Gabes 05/03/2019

Département d’informatique
ASD II

CHAPITRE III– LES

STRUCTURES CHAINÉES

Par :
Khaled Hassine
[email protected]

01/03/2019 Khaled Hassine 1 01/03/2019 2

PLAN PLAN

Introduction Introduction

Création d’une liste Création d’une liste

Insertion dans une liste Insertion dans une liste

Suppression dans une liste Suppression dans une liste

Autres opérations Autres opérations

01/03/2019 Khaled Hassine 3 01/03/2019 Khaled Hassine 4

LFSI 1 1
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Besoins aux structures chaînées Définition

Une structure autoréférentielle (parfois appelée structure
 Limites des tableaux : 
récursive) est une structure dont au moins un des champs contient
 Le "suivant" doit toujours être stocké physiquement un pointeur vers une structure de même type.
dans la cellule suivante (consécutives).  Ce sont des éléments (appelés parfois nœuds ou maillon) contenant
des données, mais, contrairement à un tableau, celles-ci peuvent être
 La taille et la dimension d'un tableau doivent êtres éparpillées en mémoire et reliées entre elles par des liens (des
connues à la compilation. pointeurs).
 Exemples de structure autoréférentielle :
 Gestion par tableau : ajout, suppression, …  Liste chaînée : la structure contient des données et un pointeur vers la
 Décalage des contenues structure suivante.
 Numéroter les champs : Utilisation d’index  Liste chaînée double : la structure contient des données, un pointeur vers
la structure suivante, et un pointeur vers la structure précédente.
 Solution : utiliser les structures  Arbre binaire : la structure contient des données, un pointeur vers une
première structure droite, et un pointeur vers une structure gauche.
autoréférentielles  …

01/03/2019 Khaled Hassine 5 01/03/2019 Khaled Hassine 6

Les listes chaînées Avantage des listes

 Ce sont des structures de données à accès  Cette représentation n’impose pas une longueur
indirect qui permettent de construire une suite maximum sur les listes ; elle permet de traiter
d’éléments de même type. facilement la plupart des opérations sur les listes :
 Les avantages des listes sont : le parcours séquentiel, l'insertion et la suppression
 Dynamiques : utile surtout si la taille de la liste varie d'un élément à une place quelconque, la
beaucoup où on réserve moins de ressource. concaténation de deux listes, se font par une
 Facilité d’ajout et de suppression : dans un simple manipulation des pointeurs.
tableau, il faut d’abord déplacer les éléments du
tableau pour faire un « trou », ou décaler les éléments aaaaa bb ddd mm
pour n’est pas en avoir de « trou ».

01/03/2019 Khaled Hassine 7 01/03/2019 Khaled Hassine 8

LFSI 1 2
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Figure illustrative PLAN

Introduction

Création d’une liste

Après insertion d’un nouveau maillon
Insertion dans une liste

Suppression dans une liste

Autres opérations
01/03/2019 Khaled Hassine 9 01/03/2019 Khaled Hassine 10

Création d’une liste Création d’une liste

 Déclaration et initialisation d’une liste  Déclaration et initialisation d’une liste
 Saisie des éléments d’une liste  Saisie des éléments d’une liste
 Affichage d’une liste  Affichage d’une liste

01/03/2019 Khaled Hassine 11 01/03/2019 Khaled Hassine 12

LFSI 1 3
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Déclaration d'une liste Déclaration d'une liste en C

 Une liste chaînée est une structure comportant un ou plusieurs champs typedef int ELEMENT ; /* Ce type peut changer */
contenant des données et un pointeur vers une structure de même type.
Ainsi, une structure correspondant à une liste chaînée d'ELEMENT peut être struct maillon
déclarée comme suit : { ELEMENT valeur;
Type ELEMENT …. ; /* à définir Ce type peut changer */
maillon = Enregistrement struct maillon *suivant;
ELEMENT valeur;
maillon *suivant;
};
Fin Enregistrement typedef struct maillon pmaillon; /*Structure Maillon*/
On déclare ensuite un pointeur vers le premier élément de la liste (une

typedef struct maillon * VersMaillon ; /*Pointeur vers maillon*/
donnée statique) :
Maillon *tete;  Création d’un élément de la liste :
 Au fur et à mesure des besoins, on crée un nouvel élément de la liste : VersMaillon nouveau ;
Maillon *nouveau ;
nouveau ← allouer (1, Maillon)
nouveau = (VersMaillon) malloc(sizeof(pmaillon));

01/03/2019 Khaled Hassine 13 01/03/2019 Khaled Hassine 14

Initialisation d'une liste Initialisation d'une liste en C

 Il est nécessaire de conserver une «trace» du VersMaillon tete = NULL ;

premier enregistrement afin de pouvoir  Etant donné que le dernier enregistrement ne

accéder aux autres, c'est pourquoi un pointeur pointe vers rien, il est nécessaire de donner à son
vers le premier élément de la liste est pointeur la valeur NULL
indispensable.
 Ce pointeur est appelé pointeur de tête (tete).
Maillon *tete
tete ← NULL ;

01/03/2019 Khaled Hassine 15 01/03/2019 Khaled Hassine 16

LFSI 1 4
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Ajout d'un premier élément Ajout d'un premier élément en C

 Une fois la structure et les pointeurs définis, il est possible  Allouer la mémoire nécessaire au nouveau maillon grâce à la fonction
malloc, selon la syntaxe suivante :
d'ajouter un premier maillon à la liste chaînée, puis de Nouveau = (VersMaillon) malloc(sizeof(struct maillon));
l'affecter au pointeur Tete. Pour cela il est nécessaire :  Remplir les champs des données de la structures (par saisie, par
 d'allouer la mémoire nécessaire au nouveau maillon : affectation, …)
Nouveau ← allouer (1, maillon);  Assigner au champ « pointeur » du nouveau maillon, la valeur du
 remplir les champs des données de la structures (par saisie, par pointeur vers le maillon de tête :
affectation, …) Nouveau->Suivant = Tete;

 d'assigner au champ « pointeur » du nouveau maillon, la valeur du  Définir le nouveau maillon comme maillon de tête :
pointeur vers le maillon de tête : Tete = Nouveau;

Nouveau->Suivant ← Tete;  Il est conseillé de tester la valeur renvoyée en retour par la fonction
malloc() afin de savoir si l'allocation dynamique de la mémoire s'est
 définir le nouveau maillon comme maillon de tête :
déroulée correctement.
Tete ← Nouveau;

01/03/2019 Khaled Hassine 17 01/03/2019 Khaled Hassine 18

Evolution d’une liste

Création d’une liste

 Déclaration et initialisation d’une liste
 Saisie des éléments d’une liste
 Affichage d’une liste

01/03/2019 Khaled Hassine 19 01/03/2019 Khaled Hassine 20

LFSI 1 5
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Construction d'une liste avec Construction d'une liste avec

insertion en tête insertion en tête en C
Action construire (Résultat Maillon debut) void construire (Données/Résultat VersMaillon debut)
Début
Maillon *p; { VersMaillon p;
ELEMENT valeur; ELEMENT valeur;
Début
*debut = NULL;
*debut ← NULL;
Ecrire ("Donnez vos entiers, terminez en indiquant ValFin"); printf("Donnez vos entiers, terminez en indiquant EOF\n");
Lire (Valeur) while (scanf("%d", &valeur) != EOF)
Tanque (valeur ≠ ValFin)
Faire
{ p = (VersMaillon) malloc(sizeof(struct maillon));
p ← allouer (1, maillon); p -> valeur = valeur;
p -> valeur ← valeur;
p -> suivant = *debut;
p -> suivant ← *debut;
debut ← p; *debut = p;
Ecrire ("Donnez vos entiers, terminez en indiquant ValFin"); }
Lire (Valeur)
FinFaire
}
Fin

01/03/2019 Khaled Hassine 21 01/03/2019 Khaled Hassine 22

Saisie d’une liste : fonction qui Saisie d’une liste en C : fonction qui
retourne la tête retourne la tête
Fonction construire() : VersMaillon VersMaillon construire()
Variables
{ VersMaillon debut, p;
VersMaillon debut, p;
ELEMENT valeur; ELEMENT valeur;
Début debut = NULL;
debut ← NULL; printf("Donnez vos entiers, terminez en indiquant EOF\n");
Lire (valeur)
Tanque (valeur) ≠ ValStop) while (scanf("%d", &valeur) != EOF)
Faire { p = (VersMaillon) malloc(sizeof(struct maillon));
p ← Allouer (1, maillon);
p -> valeur = valeur;
p -> valeur ← valeur;
p -> suivant ← debut; p -> suivant = *debut;
debut ← p; *debut = p;
lire (valeur)
Fin Faire
}
Construire ← debut; return debut;
Fin }

01/03/2019 Khaled Hassine 23 01/03/2019 Khaled Hassine 24

LFSI 1 6
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Création d’une liste avec une

insertion en queue en C
VersMaillon Creation ()
{ pmaillon *precedent,*nouveau, *tete ;
tete =(pmaillon *)malloc(sizeof(pmaillon));
puts("entrez votre premier entier"); Création d’une liste
scanf("%d",&tete->valeur); int encore(void) /* demande si
precedent=tete; on en veut encore*/
while (encore()) {printf("encore (O/N) ? ");  Déclaration et initialisation d’une liste
{ nouveau=(pmaillon *)malloc(sizeof(pmaillon)); return(toupper(getch())=='O');
precedent->suivant=nouveau; }  Saisie des éléments d’une liste
precedent=nouveau;
puts("\nentrez votre entier");  Affichage d’une liste
scanf("%d",&nouveau->valeur);
}
precedent->suivant=NULL;
return tete;
}

01/03/2019 Khaled Hassine 25 01/03/2019 Khaled Hassine 26

Affichage d’une liste en C avec une Affichage d’une liste en C avec une
boucle while boucle for
void affiche (pmaillon *debut) void affiche (VersMaillon debut)
{ printf("\n______Contenu de la liste ________\n "); { pmaillon *p;
while (debut!=NULL) printf("\n______Contenu de la liste ________\n
{ printf("%d ", debut->valeur); ");
debut=debut->suivant; for (p=debut; p!=NULL; p=p->suivant)
} printf("\t%d",p->valeur);
printf("\n__________Fin contenue _________\n"); printf("\n__________Fin contenu
__________\n");
}
}

01/03/2019 Khaled Hassine 27 01/03/2019 Khaled Hassine 28

LFSI 1 7
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

PLAN

Introduction
Insertion dans une liste
Création d’une liste
 Insertion en tête
 Insertion en queue
Insertion dans une liste
 Insertion par position

Suppression dans une liste  Insertion par valeur

Autres opérations
01/03/2019 Khaled Hassine 29 01/03/2019 Khaled Hassine 30

Insertion en tête
Action Insertion_Tete (Données ELEMENT V,
Données/Résultat Maillon tete)
Insertion dans une liste Variable
 Insertion en tête VersMaillon Nouveau;
Début
 Insertion en queue tete
Nouveau ← allouer(1,maillon);
 Insertion par position
Nouveau->valeur ← V; a b
 Insertion par valeur Nouveau->suivant ← tete;
tete ← Nouveau; Nouveau V
Fin

01/03/2019 Khaled Hassine 31 01/03/2019 Khaled Hassine 32

LFSI 1 8
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Insertion en tête en C
void Insertion_Tete (ELEMENT V, VersMaillon *tete)
{ VersMaillon Nouveau;
Insertion dans une liste
Nouveau = (pmaillon * ) malloc (sizeof(pmaillon));
Nouveau->valeur = V;  Insertion en tête
Nouveau->suivant = *tete;  Insertion en queue
*tete = Nouveau; Tete
 Insertion par position
} a b
 Insertion par valeur
Nouveau V

01/03/2019 Khaled Hassine 33 01/03/2019 Khaled Hassine 34

Insertion en queue de liste Insertion en queue de liste en C

Action Insertion_Fin (Données ELEMENT V, Données/Résultat VersMaillon tete) void Insertion_Fin (ELEMENT V, VersMaillon *tete)
Varaibles
VersMaillon nouveau, q; { VersMaillon nouveau, q;
Début nouveau = (VersMaillon) malloc(sizeof(pmaillon));
nouveau ← Allouer (1, Maillon);
nouveau->valeur ← V; nouveau->valeur = V;
nouveau->suivant ← NULL; nouveau->suivant = NULL;
Si (tete=NULL)
Alors tete ← nouveau;
if (*tete==NULL)*tete = nouveau;
Sinon q ← tete; else
Tanque (q->suivant ≠ NULL)
Faire
{ q=*tete;
q ← q->suivant; while (q->suivant !=NULL) q = q->suivant;
FinFaire q->suivant = nouveau;
q->suivant ← nouveau;
FinSi }
} }

01/03/2019 Khaled Hassine 35 01/03/2019 Khaled Hassine 36

LFSI 1 9
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Insertion par position

Action Insertion_Pos(Données Entier X, Tanque ((p->suivant ≠ NULL) et
K, Données/Résultat Maillon L) (i<K-1))
/* Ajout d’1 élément à la Kème Faire
Insertion dans une liste position*/ p ← p->suivant;
Variables i ← i+1;
 Insertion en tête VersMaillon p, A_inserer; FinFaire
Entier i;
 Insertion en queue A_inserer ← Allouer (1, Maillon)
Début A_inserer->valeur ← X;
 Insertion par position Si ((L=NULL) ou (K=1)) A_inserer->suivant ← p->suivant;
Alors Insertion_Tete(L,X); p->suivant ← A_inserer;
 Insertion par valeur
Sinon FinSi
P ← L; Fin
i ← 1;

01/03/2019 Khaled Hassine 37 01/03/2019 Khaled Hassine 38

Insertion par position en C

void Insertion_Pos(VersMaillon *L,int X,int K)
/* Ajout d'un élément à la K ème position */
{ VersMaillon p, A_inserer; int i;
if ((*L==NULL)||(K==1)) Insertion_Tete(L,X);
Insertion dans une liste
else
{ p=*L; i=1;  Insertion en tête
while ((p->suivant!=NULL)&&(i<K-1))
{ p=p->suivant; i++; }
 Insertion en queue
A_inserer = (VersMaillon)malloc(sizeof(pmaillon));
 Insertion par position
A_inserer->valeur = X;
A_inserer->suivant = p->suivant;  Insertion par valeur
p->suivant = A_inserer;
}
}

01/03/2019 Khaled Hassine 39 01/03/2019 Khaled Hassine 40

LFSI 1 10
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Insertion par valeur sur une liste Insertion par valeur sur une liste
triée triée en C
Action Insertion_Valeur (Données ELEMENT V, Données/Résultat Maillon tete,) void Insertion_Valeur (VersMaillon *tete, ELEMENT V)
Variables
VersMaillon Precedent, Courant, A_inserer; { VersMaillon Precedent, Courant, A_inserer;
Début if (((*tete) == NULL)||((*tete)->valeur > V)) Insertion_Tete(tete,V) ;
Si ((tete= NULL) ou (tete->valeur > V)) Alors Insertion_Tete(tete,V) ;
else {for (Courant = (*tete); (Courant != NULL) && (Courant->valeur < V);
Sinon Courant ← tete
Tanque (Courant ≠ NULL) et (Courant->valeur < V) Courant=Courant->suivant) Precedent = Courant ;
Faire if (Courant ==NULL) Insertion_Fin(tete, V);
Precedent ← Courant ;
Courant ← Courant->suivant
else { A_inserer =(VersMaillon) malloc(sizeof(pmaillon));
FinFaire A_inserer->valeur = V;
Si (Courant =NULL) Alors Insertion_Fin(tete, V); A_inserer->suivant=Precedent->suivant /* ou Courant*/
Sinon A_inserer ← Allouer (1, Maillon);
A_inserer->valeur ← V; Precedent->suivant =A_inserer;
A_inserer->suivant ← Precedent->suivant /* ou Courant*/ }
Precedent->suivant ← A_inserer; }
FinSi
FinSi }
Fin

01/03/2019 Khaled Hassine 41 01/03/2019 Khaled Hassine 42

PLAN

Introduction
Suppression dans une liste
Création d’une liste
 Suppression par choix du user
 Suppression en tête
Insertion dans une liste
 Suppression par position

Suppression dans une liste  Suppression par valeur

 Vider une liste
Autres opérations
01/03/2019 Khaled Hassine 43 01/03/2019 Khaled Hassine 44

LFSI 1 11
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Suppression dans une liste par choix

de l’utilisateur
Action suppression_Choix (Données/Résultat VersMaillon Tete)
Variables
VersMaillon P, C, A_Sup;
Cacarctère OK;
Suppression dans une liste Début
C ← Tete; P ← Tete;
Tanque (C ≠ NULL)
Faire
 Suppression par choix du user Ecrire("valeur : courant->valeur, " supprimer celui-ci (O/N) ? "); Lire (OK)
Si (OK='O’)
Alors
 Suppression en tête A-Sup← C;
Si (C =Tete)

 Suppression par position

Alors Tete ← Tete->suivant ; P ← Tete->suivant ;
Sinon P->suivant ← C->suivant; C ← P->suivant;
FinSi

 Suppression par valeur Sinon

Liberer (A_Sup);

P←C;
 Vider une liste FinSi
C ← C->suivant;

FinFaire
Fin

01/03/2019 Khaled Hassine 45 03/03/2019 Khaled Hassine 46

Suppression dans une liste par choix

de l’utilisateur en C
void suppression_Choix (VersMaillon *tete)
{ VersMaillon C,P; A_Sup; char OK;
C=P=*tete;
while (c!=NULL)
{ printf("\nvaleur : %d - supprimer celui-ci (O/N) ? ", C->valeur);
Suppression dans une liste
OK =toupper(getch());
if (OK=='O')
{ A_Sup=C;  Suppression par choix du user
if (C ==*tete) *tete = P=*tete->suivant;
else {P->suivant = C->suivant; C = P->suivant; }  Suppression en tête
free(C);
}  Suppression par position
else
{ P = C; C = C->suivant;  Suppression par valeur
}

}
}
 Vider une liste

03/03/2019 Khaled Hassine 47 01/03/2019 Khaled Hassine 48

LFSI 1 12
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Suppression de l’élément en tête de

liste Suppression en tête
Action Suppression_Tete (Données/Résultat Maillon tete)
Variables
VersMaillon A_Supprimer ;
Cacarctère OK;
Tête Début
p←tête; Si (tete ≠ NULL)
tête←tête->suivant; …
libérer(p);
a b Alors A_Supprimer ← tete;
tete ← tete->suivant;
p Liberer (A_Supprimer);
Sinon
Il faut préserver l’adresse de la tête Ecrire("Suppression impossible-liste vide!!");
pour pouvoir ensuite libérer l’espace FinSi
Fin

01/03/2019 Khaled Hassine 49 01/03/2019 Khaled Hassine 50

Suppression en tête en C
void Suppression_Tete (VersMaillon *tete)
{ VersMaillon A_Supprimer ;
Suppression dans une liste
if (*tete != NULL)
{ A_Supprimer = *tete;  Suppression par choix du user
*tete = (*tete)->suivant;  Suppression en tête
free(A_Supprimer);
 Suppression par position
} else printf("Suppression impossible-liste vide!!\n");
 Suppression par valeur
}
 Vider une liste

01/03/2019 Khaled Hassine 51 01/03/2019 Khaled Hassine 52

LFSI 1 13
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Suppression par position Suppression par position en C

Action Suppression_Pos(Données Entier K, Données/Résultat Maillon Tete) void Suppression_Pos (VersMaillon *Tete,int K)
/* Si K est superieur à la longueur de la liste, on supprime le dernier*/ /* Si K est superieur à la longueur de la liste, on supprime le dernier*/
Variables { VersMaillon prec, A_Supprimer;
VersMaillon Precedent, A_Supprimer; Entier i int i;
Début if((*Tete==NULL)||(K==1)) Suppression_Tete(Tete);
Si ((Tete=NULL) ou (K=1)) Alors Suppression_Tete(Tete); else
Sinon { prec=*Tete;
Precedent ← Tete; i ← 1; /*Indice du précedent*/ i=1; /*Indice du précedent*/
Tanque ((Precedent->suivant->suivant ≠ NULL) et (i<K-1)) while ((prec->suivant->suivant!=NULL)&& (i<K-1))
Faire { prec = prec->suivant;
Precedent ← Precedent->suivant; i++;
i ← i+1 } /*On sort de la boucle avec i=k-1 ou sur NULL*/
FinFaire /*On sort de la boucle avec i=k-1 ou sur NULL*/ A_Supprimer = prec->suivant;
A_Supprimer ← Precedent->suivant; prec->suivant = prec->suivant->suivant;
Precedent->suivant ← Precedent->suivant->suivant; free(A_Supprimer);
Liberer (A_Supprimer); }
FinSi }
Fin

01/03/2019 Khaled Hassine 53 01/03/2019 Khaled Hassine 54

Suppression par valeur sur une liste

triée
Action Suppression_Valeur (Données ELEMENT E, Données/Résultat VersMaillon tete)
Variables
VersMaillon Precedent, Courant, A_Sup;
Début
Suppression dans une liste Si ((tete ≠NULL) et (tete->valeur =E))
Alors
repeter suppression_tete (tete); jusqu’à (tete = NULL) ou (tete->valeur >E))
Sinon Courant←tete;
 Suppression par choix du user Tanque ((courant ≠NULL) et (courant->valeur < E))
Faire
Precedent← courant;
 Suppression en tête Courant←courant->suivant;
FinFaire
Tanque ((courant ≠ NULL) et (courant->valeur = E))
 Suppression par position Faire
A_Sup ← Courant;

 Suppression par valeur

Precedent->suivant ← Courant->suivant; Courant ← Courant->suivant
Liberer (A_Sup);
FinFaire
 Vider une liste Fin
FinSi

01/03/2019 Khaled Hassine 55 03/03/2019 Khaled Hassine 56

LFSI 1 14
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Suppression par valeur sur une liste Suppression par valeur sur une liste
triée en C quelconque
void Suppression_Valeur (ELEMENT E, VersMaillon *tete) Action Suppression_Valeur (Données ELEMENT E, Données/Résultat VersMaillon tete)
Variables
{ VersMaillon Precedent, Courant, A_Sup;
VersMaillon P, C, A_Sup;
if (((*tete)!= NULL)&&((*tete)->valeur ==E)) Suppression_Tete (tete); Debut
else { courant=*tete; Tanque (tete ≠ NULL) et ((tete->valeur =E)) Faire suppression_tete (tete); FinFaire
while ((courant !=NULL)&& (courant->valeur < E)) Si (tete ≠ NULL)
Alors
{ Precedent= Courant; C ← Tete->suivant; P ← Tete;
Courant=Courant->suivant; Tanque (C ≠ NULL) Faire
} Si (C->valeur = E))
Alors P->suivant ← C->suivant; A_Sup ← C;
while ((Courant != NULL) && (Courant->valeur == E)) free(A_Sup);
{ A_Sup=Courant; Precedent->suivant = Courant->suivant; C ← P->suivant;
Courant = Courant->suivant; free(A_Sup); Sinon
} P ← C;
C ← C->suivant;
} FinSi
} FinSi
Fin

03/03/2019 Khaled Hassine 57 03/03/2019 Khaled Hassine 58

Suppression par valeur sur une liste

quelconque en C
void Suppression_Valeur (ELEMENT E, VersMaillon *tete,)
{ VersMaillon precedent, courant;
while (((*tete) != NULL) && ((*tete)->valeur ==E)) suppression_tete (tete);
if (((*tete) != NULL)
{ courant=(*tete)->suivant;
Suppression dans une liste
precedent=(*tete);
while ((courant !=NULL)
if (courant->valeur == E))  Suppression par choix du user
{ precedent->suivant = courant->suivant;
free(courant);  Suppression en tête
courant = precedent->suivant;
}  Suppression par position
else
{ precedent= courant;  Suppression par valeur
courant=courant->suivant;

}
}
 Vider une liste
}

03/03/2019 Khaled Hassine 59 01/03/2019 Khaled Hassine 60

LFSI 1 15
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Vider une liste Vider une liste en C

Action vider (Données/Résultats VersMaillon tete)
void vider (VersMaillon *tete)
Variables
VersMaillon A_Sup; { VersMaillon *tmp;
Début
Tanque (tete ≠ NULL)
while (*tete !=NULL)
Faire { tmp=*tete;
A_Sup ← tete;
tete ← tete->suivant;
*tete = (*tete)->suivant;
Liberer (A_Sup); free(tmp); /*Libération des maillons un par un
/*Libération des maillons un par un */ */
FinFaire
Fin }
}
01/03/2019 Khaled Hassine 61 01/03/2019 Khaled Hassine 62

PLAN

Introduction
Opérations particulières
Création d’une liste
 Recherche dans une liste
 Concaténation de deux listes
Insertion dans une liste
 Fusion de deux listes

Suppression dans une liste  Inversion d’une liste

 Tri d’une liste
Autres opérations
01/03/2019 Khaled Hassine 63 01/03/2019 Khaled Hassine 64

LFSI 1 16
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Tester si un élément appartient à

une liste (quelconque)
Fonction Present (Données VerMaillon T, ELEMENT E) : VersMaillon
Variables
Opérations particulières VersMaillon C;
Début
 Recherche dans une liste C←T;
 Concaténation de deux listes Tanque (C ≠ NULL) et (C->valeur ≠ E)
Faire
 Fusion de deux listes C← C->suivant;
 Inversion d’une liste FinFaire Si E appartient à la liste
Present ← C on retourne le pointeur
 Tri d’une liste qui pointe sur E sinon
Fin
on retourne NULL

01/03/2019 Khaled Hassine 65 01/03/2019 Khaled Hassine 66

Tester si un élément appartient à

une liste En C Recherche dans une liste triée
Fonction RechercheTrie (Données VersMaillon Tete, ELEMENT E) : VersMaillon
VersMaillon present (VersMaillon Liste, ELEMENT E) Variables
{/* Si E appartient à la liste on retourne le pointeur VersMaillon C ;
Début
qui pointe sur E sinon on retourne NULL */ C ← Tete ;
VersMaillon p; Tanque (C ≠ NULL) et (C->valeur < E)
Faire
p=Liste; C← C->suivant;
FinFaire Si E est dans la liste on
while ((p !=NULL) && (p->valeur!=E)) Si (C ≠ NULL) et (C->valeur = E) retourne le pointeur qui
Alors RechercheTrie ← C
p=p->suivant; Sinon RechercheTrie ← NULL
pointe sur E sinon on
retourne NULL
return p; FinSi
Fin
}

03/03/2019 Khaled Hassine 67 03/03/2019 Khaled Hassine 68

LFSI 1 17
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Recherche dans une liste triée en C

VersMaillon RechercheTrie (VersMaillon Liste, ELEMENT
E)
{/* Si E est dans la liste on retourne le pointeur qui Opérations particulières
pointe sur E sinon on retourne NULL */
VersMaillon p;  Recherche dans une liste
p=Liste;  Concaténation de deux listes
while ((p !=NULL)&& (p->valeur < E))
 Fusion de deux listes
p=p->suivant;
if ((p !=NULL) && (p->valeur == E)) return p;  Inversion d’une liste
else return NULL;  Tri d’une liste
}

03/03/2019 Khaled Hassine 69 01/03/2019 Khaled Hassine 70

Solution 1 : Concaténation de deux

Concaténation de deux listes listes
Fonction Concat(Données VersMaillon L1, L2) : VersMaillon
 Mettre bout à bout deux listes quelconque Variables VersMaillon L3, P;
Début
L3 ← NULL; P ← L1;
Tanque P ≠ NULL
liste1 Faire
Insertion_Queue(L3, P->valeur);
P ← P->suivant
FinFaire
P ← L2;
Tanque P ≠ NULL
Faire
Insertion_Queue(L3, P->valeur);
P ← P->suivant
liste2 FinFaire
Concat ← L3;
Fin

01/03/2019 Khaled Hassine 71 03/03/2019 Khaled Hassine 72

LFSI 1 18
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Solution 1 : Concaténation de deux Solution 2 : Concaténation de deux

listes en C listes
Fonction Concatenation (Données VersMaillon L1, L2) : VersMaillon
VersMaillon Concat(VersMaillon L1,VersMaillon L2) Variables VersMaillon P;
Début
{ VersMaillon L3=NULL, p; Si (L1=NULL)
for (p=L1 ; p ; p=p->suivant) alors Concatenation ← L2;
Sinon
Insertion_Fin(&L3,p->valeur); P ← L1;
Tanque (P->suivant ≠ NULL)
for (p=L2 ; p ; p=p->suivant) Faire
P←P->suivant;
Insertion_Fin(&L3,p->valeur); FinFaire
P->Suivant ← L2;
return L3; Concatenation ← L1;
FinSi
} Fin

03/03/2019 Khaled Hassine 73 03/03/2019 Khaled Hassine 74

Solution 2 : Concaténation de deux

listes en C
VersMaillon Concatenation (VersMaillon L1, VersMaillon L2)
{ VersMaillon P;
if (L1==NULL) return L2; Opérations particulières
else
{ for (P=L1;P->suivant; P=P->suivant) ;  Recherche dans une liste
/* P=L1;
while (P->suivant !=NULL) P=P->suivant;  Concaténation de deux listes
*/  Fusion de deux listes
P->suivant=L2;
return L1;  Inversion d’une liste
}
 Tri d’une liste
}

05/03/2019 Khaled Hassine 75 01/03/2019 Khaled Hassine 76

LFSI 1 19
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

FUSION des LISTES triées FUSION des LISTES triées

 Fusion sans élimination des  Fusion sans élimination des
redondances redondances
 Fusion avec élimination des  Fusion avec élimination des
redondances redondances

01/03/2019 Khaled Hassine 77 03/03/2019 Khaled Hassine 78

Fusion Sans élimination des Fusion Sans élimination des

redondances redondances en C
VersMaillon (VersMaillon L1, VersMaillon L2) Tanque (p ≠ NULL) VersMaillon Fusion_Simple (VersMaillon While (p)
Variables VersMaillon L3, p, q; Faire L1,VersMaillon L2) { Insertion_Fin(&L3,p->valeur);
Début Insertion_Fin(L3, p->valeur); { VersMaillon L3, p, q; p=p->suivant;
L3 ← NULL; p ← L1; q ← L2; p ← p->suivant; L3=NULL; }
Tanque (p ≠ NULL) et (q ≠ NULL) FinFaire p=L1;q=L2; while (q)
Faire Tanque (q ≠ NULL) while (p&&q) { Insertion_Fin(&L3,q->valeur);
Si (p->valeur<= q->valeur) if (p->valeur<= q->valeur)
Faire q=q->suivant;
Alors { Insertion_Fin (&L3, p->valeur);
Insertion_Fin(L3, q->valeur); }
Insertion_Fin(L3, p->valeur); p=p->suivant;
p ← p->suivant;
q ← q->suivant; return L3;
FinFaire } }
Sinon
Fusion_Simple ← L3; else
Insertion_Fin(L3, q->valeur);
q ← q->suivant; Fin { Insertion_Fin(&L3, q->valeur);
FinSi q=q->suivant;
FinFaire }

03/03/2019 Khaled Hassine 79 03/03/2019 Khaled Hassine 80

LFSI 1 20
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Fusion de deux listes triées avec

élimination des redondances
Fonction Fusion_Sans_Redondance (Données VersMaillon L1, L2): VersMaillon
Variables VersMaillon Tete; ELEMENT Dernier;
Début
FUSION des LISTES triées Si (L1=NULL)
Alors Tete ← L2;
 Fusion sans élimination des Sinon Si (L2=NULL) Alors Tete ← L1;
Sinon
redondances Tete ← Allouer (1, VersMaillon) ;
Si L1->valeur < L2->valeur)
 Fusion avec élimination des Alors Tete->valeur ← L1->valeur Création du
Sinon Tete->valeur ← L2->valeur premier élément
redondances FinSi
Tete->suivant ← NULL ; Garder toujours le
Dernier ← Tete->valeur; dernier élément écrit

03/03/2019 Khaled Hassine 81 03/03/2019 Khaled Hassine 82

Fusion de deux listes triées avec Fusion de deux listes triées avec
élimination des redondances … élimination des redondances …
Tanque ((L1 ≠ NULL) et (L2 ≠ NULL)) Tanque (L1 ≠ NULL )
Faire Faire
Si (L1->valeur <L2->valeur ) Si (Dernier ≠ L1->valeur )
Alors Si (Dernier ≠ L1->valeur ) Alors Dernier ← L1->valeur;
Alors Dernier ← L1->valeur; Insertion_Fin(Tete, Dernier);
Insertion_Fin(Tete, Dernier); FinSi
FinSi On écrit le plus petit de L1 ← L1->suivant; Copie des éléments
L1 ← L1->suivant; deux listes s’il n’est pas FinFaire restants en éliminant la
Sinon le dernier écrit Tanque (L2 ≠ NULL ) redondance
Si (Dernier ≠ L2->valeur ) Faire
Alors Dernier ← L2->valeur; Si (Dernier ≠ L2->valeur )
Insertion_Fin( tete, Dernier); Alors Dernier ← L2->valeur;
FinSi Insertion_Fin(Tete, Dernier);
L2 ← Li2->suivant; FinSi
FinSi L2 ← L2->suivant;
FinFaire FinFaire
Fusion_Sans_Redondance ← Tete;
Fin

03/03/2019 Khaled Hassine 83 03/03/2019 Khaled Hassine 84

LFSI 1 21
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Fusion de deux listes triées avec Fusion de deux listes triées avec
élimination des redondances en C élimination des redondances en C …
VersMaillon Fusion_Sans_Redondance (VersMaillon Liste1, {
while ((Liste1 != NULL)&&(Liste2 != NULL))
if (Liste1->valeur <Liste2->valeur )
VersMaillon Liste2) { if (Dernier != Liste1->valeur )
{ VersMaillon tete; ELEMENT Dernier; { Dernier = Liste1->valeur;
Insertion_Fin(&tete, Dernier);
if(Liste1==NULL) tete= Liste2; }
Liste1 = Liste1->suivant;
else if (Liste2 ==NULL) tete= Liste1; }
else { tete=(VersMaillon) malloc(sizeof(pmaillon)); else
{ if (Dernier != Liste2->valeur )
if (Liste1->valeur < Liste2->valeur) { Dernier = Liste2->valeur;
tete->valeur = Liste1->valeur; Insertion_Fin(&tete, Dernier);
}
else tete->valeur = Liste2->valeur; Liste2 = Liste2->suivant;
}
tete->suivant = NULL ; }
Dernier = tete->valeur;

03/03/2019 Khaled Hassine 85 03/03/2019 Khaled Hassine 86

Fusion de deux listes triées avec

élimination des redondances en C …
for ( ; Liste1 != NULL ; Liste1 = Liste1->suivant)
{ if (Dernier != Liste1->valeur )
{ Dernier = Liste1->valeur;
Insertion_Fin(&tete, Dernier); Opérations particulières
}
}  Recherche dans une liste
for ( ; Liste2 != NULL ; Liste2 = Liste2->suivant)
{ if (tete->valeur != Liste2->valeur )  Concaténation de deux listes
{ Dernier = Liste2->valeur;
Insertion_Fin(&tete, Dernier);  Fusion de deux listes
}
}  Inversion d’une liste
}
return tete;  Tri d’une liste
}

03/03/2019 Khaled Hassine 87 01/03/2019 Khaled Hassine 88

LFSI 1 22
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Inversion d’une LISTE Inversion d’une LISTE

Le dernier élément dévient en tête et Le dernier élément dévient en tête et
celui en tête dévient en queue : celui en tête dévient en queue :
 sur la même liste  sur la même liste
 en créant une nouvelle liste  en créant une nouvelle liste

01/03/2019 Khaled Hassine 89 03/03/2019 Khaled Hassine 90

Inversion d’une liste sur elle-même

Inversion d’une liste sur elle même en C
Action Inverser (Données/Résultat VersMaillon L) void Inverser(VersMaillon *L)
Variables VersMaillon C; Entier, K;
Début
{ VersMaillon Courant;
K←3 int K=3; /*Après insertion du premier, Il faut supprimer le 3 ème*/
Si (L ≠ NULL) et (L->suivant ≠ NULL) if((*L!=NULL)&&((*L)->suivant!=NULL))
Alors
C ← L->suivant;
{ Courant=(*L)->suivant;
Tanque (C ≠ NULL) while(Courant!=NULL)
Faire { Insertion_Tete(L,Courant->valeur);
Insertion_Tete(L,C->valeur);
C ← C->suivant; Après insertion du premier, Il Courant=Courant->suivant;
Suppression_Pos(L,K); faut supprimer le 3ème Suppression_Pos(L,K);
K←K+1; K++;
FinFaire
FinSi
}
Fin }
}

03/03/2019 Khaled Hassine 91 01/03/2019 Khaled Hassine 92

LFSI 1 23
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Inverser une liste sur une nouvelle

liste
Fonction Inverser (VersMaillon tete) : VersMaillon
Variables VersMaillon p, nv_liste
Inversion d’une LISTE Début
/*écrit une liste existante
nv_liste ← NULL;
dans une nouvelle de droite
Le dernier élément dévient en tête et p ← tete; à gauche _ insertion en
Tanque (p ≠ NULL) tête*/
celui en tête dévient en queue : Faire
 sur la même liste insertion_en_tete(nv_liste, p->valeur);
p ← p->suivant;
 en créant une nouvelle liste FinFaire
Inverser ← nv_liste;
Fin

03/03/2019 Khaled Hassine 93 03/03/2019 Khaled Hassine 94

Inverser une liste sur une nouvelle Inverser une liste sur une nouvelle
liste en C liste
VersMaillon inverse (VersMaillon tete) Fonction Renverser(VersMaillon Tete) : VersMaillon
Variables VersMaillon Aux, Reste_a_inverser, Courant ;
{ /*écrit une liste existante dans une nouvelle de droite à Début
gauche _ insertion en tête*/ Si (Tete ≠ NULL) et ((Tete -> suivant ≠ NULL)
Alors
pmaillon *p; Aux ← Tete -> suivant;
Tete -> suivant ← NULL; /* On cré un premier élément avec la tete */
pmaillon *nv_liste=NULL; Reste_a_inverser ← Aux;
p=tete; Tanque (Reste_a_inverser ≠ NULL)
Faire
while (p!=NULL) Courant ← Reste_a_inverser;
{ insertion_en_tete(&nv_liste, p->valeur); Reste_a_inverser ← Reste_a_inverser -> suivant;
Courant -> suivant ← Tete;
p=p->suivant; Tete ← Courant;
FinFaire
} FinSi
return nv_liste; Renverser ← Tete;
Fin
}

03/03/2019 Khaled Hassine 95 03/03/2019 Khaled Hassine 96

LFSI 1 24
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Inverser une liste sur une nouvelle

liste en C
VersMaillon Renverser(VersMaillon Tete)
{ VersMaillon Aux, Reste_a_inverser, Courant ;
if ((Tete == NULL)||(Tete -> suivant == NULL)) return Tete;
Aux = Tete -> suivant;
Opérations particulières
Tete -> suivant = NULL; /* On cré un premier élément avec la tete */
Reste_a_inverser = Aux;  Recherche dans une liste
while (Reste_a_inverser != NULL)
 Concaténation de deux listes
{ Courant = Reste_a_inverser;
Reste_a_inverser = Reste_a_inverser -> suivant;  Fusion de deux listes
Courant -> suivant = Tete;
Tete = Courant;  Inversion d’une liste
}
 Tri d’une liste
return Tete;
}

03/03/2019 Khaled Hassine 97 01/03/2019 Khaled Hassine 98

Tri d’une LISTE Tri d’une LISTE

 Sur la même liste  Sur la même liste
 Sur une nouvelle liste  Sur une nouvelle liste

01/03/2019 Khaled Hassine 99 04/03/2019 Khaled Hassine 100

LFSI 1 25
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Tri par sélection sur elle même Tri par sélection sur elle même en C
Action Trier(Données/Résultat VersMaillon L)
Variables VersMaillon p, q; Entier Aux;
void Trier(VersMaillon L)
Début
Si (L ≠ NULL) et (L->suivant ≠ NULL)
/* Tri de la liste sur elle-même. Seules les valeurs sont modifiées.*/
Alors { VersMaillon p,q;
p = L;
Tanque (p->suivant ≠ NULL) int Aux;
Faire
Tanque (p->suivant ≠ NULL) if(L&&L->suivant)
Faire Tri de la liste sur elle-
Si (p->valeur>q->valeur) for(p=L;p->suivant;p=p->suivant)
même. Seules les valeurs
Alors
Aux ← p->valeur; sont modifiées.
for(q=p->suivant;q;q=q->suivant)
p->valeur ← q->valeur;
q->valeur=Aux;
if(p->valeur>q->valeur)
FinSi { Aux=p->valeur;
q ← q->suivant
FinFaire p->valeur=q->valeur;
p ← p->suivant
FinFaire q->valeur=Aux;
Fin
FinSi
}
}

04/03/2019 Khaled Hassine 101 04/03/2019 Khaled Hassine 102

Tri d’une liste sur elle-même par

sélection version 1 en C
void Trier(VersMaillon L)
/* Tri de la liste sur elle-même. Seules les valeurs sont modifiées.*/
{ VersMaillon p, q, Pmin;
int Min; Tri d’une LISTE
if(L&&L->suivant)
for(p=L;p->suivant;p=p->suivant)  Sur la même liste
{ Min = p->valeur ; Pmin = p;
for(q=p->suivant;q;q=q->suivant)  Sur une nouvelle liste
if( Min >q->valeur)
{ Min =q->valeur;
Pmin = q;
}
Echange (P->valeur, Pmin->valeur)
}
}

01/03/2019 Khaled Hassine 103 04/03/2019 Khaled Hassine 104

LFSI 1 26
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Tri par insertion Tri par insertion en C

Action Tri_Insertion (Données/Résultat VersMaillon Tete) void Tri_Insertion (VersMaillon *tete)
Variables VersMaillon ListeTrie; ELEMENT E; { VersMaillon ListeTrie;
Début
Si Tete = NULL
ELEMENT E;
Alors ListeTrie ← Tete; if (*tete == NULL) ListeTrie = *tete;
Sinon else while (*tete != NULL)
Tanque (Tete ≠ NULL) { E = (*tete)-> valeur;
Faire
Insertion_Valeur(&ListeTrie, E);
E ← Tete-> valeur;
Insertion_Valeur(ListeTrie, E); Suppression_Tete(tete);
Suppression_Tete(Tete); }
FinFaire
FinSi (*tete) = ListeTrie;
Tete ← ListeTrie;
Fin }

01/03/2019 Khaled Hassine 105 04/03/2019 Khaled Hassine 106

Tri par sélection sur une nouvelle Tri par sélection sur une nouvelle
liste liste en C …
Fonction Tri (VersMaillon Liste_a_trier) : VersMaillon for(Noeud_a_Placer = Reste_a_trier ; Noeud_a_Placer !=
Variables NULL ; Noeud_a_Placer = Reste_a_trier)
VersMaillon ListeTrie, Reste_a_trier; { Reste_a_trier = Reste_a_trier->suivant;
VersMaillon tmp, Noeud_a_Placer; * la boucle de tri sur la nouvelle liste on effectue un test
Début sur le premier élément séparément */
Si (Liste_a_trier = NULL) if(ListeTrie->valeur >= Noeud_a_Placer->valeur)
Alors ListeTrie ← NULL; { Noeud_a_Placer->suivant = ListeTrie;
Sinon ListeTrie = Noeud_a_Placer;
ListeTrie ← Liste_a_trier; continue;
Reste_a_trier ← Liste_a_trier->suivant; }
ListeTrie->suivant ← NULL;

04/03/2019 Khaled Hassine 107 04/03/2019 Khaled Hassine 108

LFSI 1 27
Faculté des Sciences de Gabes 05/03/2019
Département d’informatique
ASD II

Tri par sélection sur une nouvelle

liste en C … Conclusion sur les listes chaînées
for (tmp = ListeTrie; tmp->suivant != NULL && tmp-  Structure orientée vers les traitements séquentiels
>suivant->valeur < Noeud_a_Placer->valeur; tmp =  Peut être manipulée de façon itérative ou de façon
tmp->suivant); récursive
/*quand on sort de la boucle, on est sûr que le  L’implantation chaînée permet des ajouts et des
maillon tmp est celui qui doit être juste avant le suppressions sans déplacement
maillon à insérer */  Mais l’accès par position est proportionnel à la
Noeud_a_Placer->suivant = tmp->suivant; longueur de la liste
tmp->suivant = Noeud_a_Placer;  Le coût d’un algorithme est évalué en place occupée
} et en nombre de pointeurs parcourus ou affectés
return ListeTrie;  A utiliser chaque fois que les mises à jour sont plus
} importantes que les consultations

04/03/2019 Khaled Hassine 109 01/03/2019 Khaled Hassine 110

01/03/2019 Khaled Hassine 111

LFSI 1 28