Cours d’ASD

1ère année LISI

2022/2023, Semestre 2
Med Habib KAMMOUN & Héla FEHRI
Département Informatique et Communications
Université de Sfax

1
2022/2023
 Algorithmique

Types abstraits de données

2
 Introduction

l Un algorithme utilise des structures de données pour représenter

et manipuler les données du problème qu’il solutionne.

l Jusqu’ à présent, nous avons utilisé des données numériques

ainsi que des tableaux.

Objectif
voir comment spécifier de nouveaux types qui pourront être utilisés
dans un algorithme

3
 Introduction…
• Dans un programme de bonne taille, il faut identifier et spécifier
les structures de données assez tôt dans le processus de
développement
l Une fois la donnée complexe identifiée, nous nous intéressons à
sa spécification.
l Le but de la spécification est de définir l’interface d’utilisation
(représentation externe) de cette donnée et de lui donner une
sémantique abstraite indépendante de l’implantation
(représentation interne).

4
 Définition
l Un type abstrait est une spécification de données décrivant
l’ensemble des opérations associées à ces données et
l’ensemble des propriétés de ces opérations.
l Nous pouvons distinguer deux sortes de types abstraits :

ü Les types abstraits de base qui correspondent aux types

disponibles dans la plupart des langages de programmation.
Ces types abstraits sont utilisés pour construire d’autres types
abstraits.
ü Les types abstraits construits au moyens de types abstraits de
base ou bien d’autres types abstraits construits prédéfinis.

5
 Caractéristiques
l Un Type de Données Abstrait (TDA) est caractérisé par :

ü Son identité (nom, adresse en mémoire).

ü Le type des données qu'il manipule (ce qui définit son état ou
caractéristiques).

ü Les opérations sur les données (sous-programmes définis

dans le TDA).

ü Les propriétés de ces opérations (axiomes permettant de

définir le TDA).

6
 Caractéristiques…
l Un TAD spécifie:

ü Le type de données contenues

ü Une description détaillée des opérations qui peuvent être

effectuées sur les données

l Un TAD ne spécifie pas:

ü La façon dont les données sont stockées

ü Comment les méthodes sont implémentées

7
 Opérations sur les types
abstraits
l Les opérations sont divisées en plusieurs types :
ü les constructeurs : ils permettent de créer un nouvel “objet”
du type que l’on est en train de définir. Il peut y avoir plusieurs
constructeurs :
Ø nouvel objet neutre ou vide,
Ø nouvel objet paramétré,
Ø nouvel objet aléatoire, ...
ü les modificateurs : ils permettent de modifier les objets et
leur contenu.
ü les observateurs : ils donnent des informations sur l’état de
l’objet (valeurs, affichages, ...)
8
 Les structures de données
l Abstraits en 4 types de structures :

ü les structures séquentielles : les listes, et leurs cas particuliers

qui sont les piles et les files.

ü les structures arborescentes : les arbres (binaires ou

généraux).

ü les structures relationnelles : les graphes.

ü Les structures à accès par clé : les tables

9
Algorithmique

Les listes

10
 Introduction
l Deux catégories de structures de données :
§ Structure de données linéaire : relier des éléments en
séquence
• Tableau
• Liste
• Pile
• File
§ Structure de données non linéaire : relier un élément à
plusieurs autres éléments

• Arbre
11
 Introduction…
• Une liste est un regroupement ordonné de données effectué de
manière à ce que chaque composante sache où se trouve la
suivante.
l L'accès aux éléments d'une liste se fait de manière séquentielle
è Chaque élément permet l'accès au suivant
l Chaque élément contient :
ü Une valeur
ü Un lien sur la composante suivante
• Une liste est accessible par l’adresse de sa première
composante.
12
 Introduction…
l Structure linéaire souple
§ peut grandir ou rétrécir à volonté
§ ses élément peuvent être insérés ou supprimés à n’importe
quel endroit
• Deux types de listes :
§ Liste statique (on ne peut pas modifier la taille)
§ Liste dynamique (peut être étendue)
l Techniques de représentation de la structure liste :
§ Représentation statique (contiguë) à l’aide du tableau
§ Représentation dynamique (chainée) avec des pointeurs
(simple, double et circulaire)
13
 Liste chaînée
Une liste chaînée :
• est une structure linéaire qui n'a pas de dimension fixe à sa
création.
• ses éléments de même type sont éparpillés dans la mémoire
et reliés entre eux par des pointeurs.
• est accessible uniquement par sa tête de liste c’est-à-dire son
premier élément.
• la séquence est mise en œuvre par le pointeur porté par
chaque élément qui indique l'emplacement de l'élément
suivant.
• le dernier élément de la liste ne pointe sur rien (Null).
• On accède à un élément de la liste en parcourant les éléments
grâce à leurs pointeurs.
14
 Liste chaînée…
Dans une liste chaînée :
• Les éléments sont chainés entre eux : chaque élément de la
liste contient une référence à l’élément suivant sous la forme
d’un pointeur.
• La position d’un élément de la liste est représentée par un
pointeur.
• La dernier élément de la liste contient un pointeur ayant la
valeur Null.
• Le premier élément de la liste est toujours accessible par un
pointeur noté généralement premier.
• La marque de fin d’une liste est repérée par une valeur de
pointeur à Null
15
 Liste Simplement Chaînée
• Chaque élément est relié à son successeur par un simple lien.

• L’accès aux éléments de la liste se fait de gauche à droite à partir

de la tête de la liste.

• La tête de la liste est une référence sur le premier nœud.

• Si la valeur de la tête de liste est Null ð la liste est vide

• Les opérations d’ajout, suppression et récupération nécessitent

un parcours séquentiel de la liste.

• Le parcours se fait uniquement du début vers la fin : parcours

unidirectionnel.
16
 Liste Simplement Chaînée…
• Un élément de la liste est représenté par une structure à deux
champs :
ü Valeur : la valeur de l’élément
ü Lien : pointeur vers l’élément suivant è Lien = Null si l’élément
en question est le dernier de la liste
• Le type Liste est défini par :

Type En C :
Element = Structure struct Element {
Val : Type (Exemple : Entier) Type val;
Suivant : ^ Element struct Element * Suivant;
Fin Structure };
Type Liste = ^ Element struct Element *Liste;

17
 Liste Simplement Chaînée…
l Une liste vide est initialisée à Null
§ L : Liste
§ L ← Null

• Exemple d’une liste non vide:

18
 représentant graphiquement l'organisation des éléments de la liste chaînée.

Exemple:
Reprenons l'exemple du tableau paragraphe 1.1. page 1. La liste chaînée corres
Liste
être : Simplement Chaînée…
3 @:2
Tête 10
1
@ :3 @:4 @:1
12 14 24
4 2 Nil
Null

1er1erélément
- LeLe élémentdedelalaliste
listevaut
vaut1212ààl'adresse
l'adresse33 (début
(début de
de la
la liste
liste chaînée)
chaînée)
- LeLe22 e élément de la liste vaut 14 à l'adresse 4 (car le pointeur de la
ème
élément de la liste vaut 14 à l'adresse 4 (car le pointeur de la cellule d’adress
cellule d’adresse
e 3 est égal à 4 )
Le 3 élément de la liste vaut 10 à l'adresse 2 (car le pointeur de la cellule d’adress
- Le 3ème
e
élément de la liste vaut 10 à l'adresse 2 (car le pointeur de la
Le 4d’adresse
cellule élément de la liste
4 est égal vaut
à 2 )24 à l'adresse 1 (car le pointeur de la cellule d’adress
- Le 4ème élément de valeur
Si P a pour la liste 3vaut 24 à l'adresse 1 (car le pointeur de lavaleur 2
Si P a pour
cellule d’adresse
P^.Info 2 est égal valeur
a pour à 1 ) 12 P^.Info a pour vale
P^.Suivant a pour valeur 4 P^.Suivant
19 a pour vale
 Avant d'écrire des algorithmes manipulant une liste chaînée, il est utile de m
représentant graphiquement l'organisation des éléments de la liste chaînée.

Exemple:
Liste Simplement Chaînée…
Reprenons l'exemple du tableau paragraphe 1.1. page 1. La liste chaînée corres
être :

3 @:2
Tête 10
1
@ :3 @:4 @:1
12 14 24
4 2 Nil
Null

Le 1er élément de la liste vaut 12 à l'adresse 3 (début de la liste chaînée)

Soit P:
e Liste
Le 2 élément de la liste vaut 14 à l'adresse 4 (car le pointeur de la cellule d’adress
Si P ae pour valeur 3 Si P a pour valeur 2
Le 3 élément de la liste vaut 10 à l'adresse 2 (car le pointeur de la cellule d’adress
P^.Val a pour valeur 12 P^.Val a pour valeur 10
e
Le 4 élément de la liste vaut 24 à l'adresse 1 (car le pointeur de la cellule d’adress
P^.Suivant a pour valeur 4 P^.Suivant a pour valeur 1
Si P a pour valeur 3 Si P a pour valeur 2
P^.Info a pour valeur 12 P^.Info 20 a pour vale
P^.Suivant a pour valeur 4 P^.Suivant a pour vale
 Liste Simplement Chaînée…
Les traitements qui peuvent être effectués sur des listes sont les
suivants :

• Créer une liste.

• Ajouter un élément.

• Supprimer un élément.

• Modifier un élément.

• Parcourir une liste.

• Rechercher une valeur dans une liste.

• ….
21
 Liste Simplement Chaînée…
Création d’une liste

Procédure CréerListe (x : entier, var L : Liste)

Variables
tete : Liste
tete ← allouer (taille (Liste))
tete^.Val ← x
tete^.suivant ← Null
L ← tete
FinProcédure

22
 Liste Simplement Chaînée…
Tester si une liste est vide

Fonction ListeEstVide (L : Liste) : Booléen

Si (L=Null) Alors
Retourner (Vrai)
Sinon
Retourner (Faux)
FinSi
FinFonction

23
 Avant d'écrire des algorithmes manipulant une liste chaînée, il est utile de mo
représentant graphiquement l'organisation des éléments de la liste chaînée.

Exemple:
Liste Simplement Chaînée…
Reprenons l'exemple du tableau paragraphe 1.1. page 1. La liste chaînée corresp
être :
Insertion en tête
7 3 @:2

×
Tête Tête 10
1
@: 7 L
@ :3 @:4 @:1
X 12 14 24
4 2 Nil
Null

Le 1er élément de la liste vaut 12 à l'adresse 3 (début de la liste chaînée)

Procédure Insérer_Tete
e
(var L: Liste, X : entier)
Variables teteLe 2 élément de la liste vaut 14 à l'adresse 4 (car le pointeur de la cellule d’adresse
: Liste
e
Le 3 élément de la liste vaut 10 à l'adresse 2 (car le pointeur de la cellule d’adresse
tete ← allouer (taille(Liste))
e
tete^.val ← X Le 4 élément de la liste vaut 24 à l'adresse 1 (car le pointeur de la cellule d’adresse
tete^.suivant ← L
Si P a pour valeur 3 Si P a pour valeur 2
L ← tete P^.Info a pour valeur 12 P^.Info a pour valeu
FinProcédure P^.Suivant a pour valeur 4 P^.Suivant a pour valeu

2.3. Traitements de base d'utilisation d'une liste chaînée

24 simple
Avant d'écrire des algorithmes manipulant une liste chaînée, il est utile de montrer un schéma
représentant graphiquement l'organisation des éléments de la liste chaînée.

Exemple:
Liste Simplement Chaînée…
Reprenons l'exemple du tableau paragraphe 1.1. page 1. La liste chaînée correspondante pourrait
être :
Insertion en queue de liste P
(3) 9
3 @:2
Tête
L P 10 P elt
P
(1) (2) 1 (4) @: 9
@ :3 @:4 @:1
12 14 24 X
4 2 × 9
Nil
Null Null

Procédure Insérer_Queue (var L: Liste, X : entier)

Le 1erVariables
élément de
P, la
eltliste vaut 12 à l'adresse 3 (début de la liste chaînée)
: Liste
Si (L=Null) alors
Le 2e élément de la liste X)
Insérer_Tête(L, vaut 14 à l'adresse 4 (car le pointeur de la cellule d’adresse 3 est égal à 4)
Sinon
Le 3e élément
P ← Lde la liste vaut 10 à l'adresse 2 (car le pointeur de la cellule d’adresse 4 est égal à 2)
Tant que (P^.suivant != Null)
Le 4e élément
P← de la liste vaut 24 à l'adresse 1 (car le pointeur de la cellule d’adresse 2 est égal à 1)
P^.suivant
Fin tant que
eltP←a allouer
Si (taille(Liste))
pour valeur 3 Si P a pour valeur 2
elt^.val ← X
P^.Info
P^.suivanta ←pour
eltvaleur 12 P^.Info a pour valeur 10
Elt^.suivant
P^.Suivant ← Null
a pour valeur 4 P^.Suivant a pour valeur 1
Finsi FinProcédure
2.3. Traitements de base d'utilisation d'une liste chaînée simple 25
 Liste Simplement Chaînée…
Longueur d’une liste

Fonction Longueur_Liste (L: Liste) : Entier

Variables Long : entier
Long ← 0
Tant que (L != Null)
L ← L^.suivant
Long ← Long + 1
Fin tant que
Retourner (Long)
FinFonction

26
 Liste Simplement Chaînée…
Recherche si un élément ayant la valeur X existe ou non dans la
liste
Fonction Parcourir_Liste (L: Liste, X: Entier) : Booléen
Variables Trouve : booléen
P : Liste
Trouve ← Faux
P←L
Tant que (P != Null)
Si ( P^.val = X) alors Retourner (Vrai)
Sinon
P ← P^.suivant
FinSi
Fin Tant Que
Retourner (Trouve)
FinFonction
27
 Liste Simplement Chaînée…
Affichage du contenu d’une liste

Procédure Affichage (L: Liste)

Variables
P : Liste
P←L
Tant que (P != Null)
Ecrire ("Element", P^.val)
P ← P^.suivant
Fin Tant Que
Fin Procédure

28
 Fin Structure

Le pointeur Precedent du premier élément ainsi que le pointeur Suivant du

contiennent la valeur Nil.
Liste Doublement Chaînée
Tête Queue
3 5

@:3 @:4 @:2 @:5

Nil
Null 3 4 2
12 14 10 24
4 2 5 Nil
Null

l Dans une liste doublement

A l'initialisation chaînée, chaînée
d'une liste doublement chaque les
élément d’une
pointeurs Tete liste
et Queue con
référence
Nil. l’élément suivant et l’élément précédent à l’aide de deux
pointeurs :
§ Successeur et éléments d'une liste doublement chaînée
Afficher les
§ Prédécesseur
• AIll'initialisation
est possible d'une
de parcourir la liste doublement
liste doublement chaînée
chaînée les du premier
pointeurs Tete etélément v
Queue
pointeur contiennent la valeur
de parcours, P, estNull.
initialisé avec l'adresse contenue dans Tete. Il
successives des pointeurs Suivant de chaque élément de la liste. 29
Le parcours
pointeur de parcours a la valeur Nil. Cet algorithme est analogue à celui du pa
 Liste Doublement Chaînée…
l Un élément de la liste est représenté par une structure à 3 champs :
§ Valeur : représente la valeur de l’élément
§ Prédécesseur : le pointeur prédécesseur (Prédécesseur = Null si
l’élément considéré est le premier)
§ Successeur : le pointeur successeur (Successeur = Null si
l’élément considéré est le dernier)

• Le parcours de la liste se fait dans les deux sens : depuis la tête et

la queue.
§ La tête est la référence sur le premier nœud.
§ La queue est la référence sur le dernier élément.
30
 Liste Doublement Chaînée…
Structure

Type
Element = Structure
Val : Type
Suivant : ^ Element
Precedent : ^ Element
Fin Structure
Type ListeDC = ^ Element

31
 Liste Doublement Chaînée…
Création d’un élément : Liste contenant un seul élément

Procédure CréerListeD (x : entier, var L : ListeDC)

Variables
tete : ListeDC
tete ← allouer (taille (ListeDC))
tete^.Val ← x
tete^.suivant ← Null
tete^.Precedent ← Null
L ← tete
Fin Procédure

32
 Liste Doublement Chaînée…
Insertion en tête

Procédure Insérer_Tête (var L: ListeDC, X : entier)

Variables tete : ListeDC
tete ← allouer (taille(ListeDC))
tete^.val ← X
tete^.suivant ← L
tete^.precedent ← Null
L^.precedent ← tete
L ← tete
Fin Procédure

33
 le pointeur de parcours a la valeur Nil.

Procedure AfficherListeArriere (Entrée Queue : ListeDC)

Variables locales
P : ListeDC

Liste Circulaire
DEBUT
P ! Queue
TANT QUE P <> NIL FAIRE
• Une liste circulaire est une liste
Ecrire(P^.Info) dont le dernier élément pointe sur
P ! P^.Precedent
le premier.
FIN TANT QUE
FIN
• Elle peut être simplement ou doublement chaînée.
2.5. Listescellule
• La dernière chaînéesdecirculaires
la liste ne comporte pas Null comme
pointeur
Une liste sur l’élément
chaînée peut être suivant,
circulaire, mais
c'est à l’adresse
dire que le de la première
pointeur du dernier élément co
cellule dedulapremier.
l'adresse liste.
Exemples:
Ci-dessous l'exemple d'une liste simplement chaînée circulaire : le dernier élément pointe
Listepremier.
simplement chaînée circulaire : le dernier élément pointe
sur le premier.
Tête
3

@ :3 @ :25 @ :8 @ :56
12 4 10 24
25 8 56 3
34
Puis l'exemple d'une liste doublement chaînée circulaire. : Le dernier élément pointe sur le pr
et le premier élément pointe sur le dernier.
Ci-dessous l'exemple d'une liste simplement chaînée circulaire : le dernier élément
premier.

Tête
3

Liste Circulaire…
@ :3 @ :25 @ :8 @ :56
12 4 10 24
Liste
25 doublement chaînée
8 circulaire.
56 : Le dernier 3élément
pointe sur le premier, et le premier élément pointe sur le
Puis l'exemple d'une liste doublement chaînée circulaire. : Le dernier élément pointe
dernier.
et le premier élément pointe sur le dernier.

Tête Queue
3 56

@ :3 @ : 25 @:8 @ :56
56 3 25 8
12 14 10 24
25 8 56 3

WEBOGRAPHIE

http://www.siteduzero.com/tutoriel-3-36245-les-listes-chainees.html 35
http://liris.cnrs.fr/pierre-antoine.champin/enseignement/algo/listes_chainees/
http://deptinfo.cnam.fr/Enseignement/CycleA/SD/cours/structuress%E9quentiellescha
 Exemples de fonctions en C
Déclaration et Initialisation d’une liste
#include <stdlib.h>
typedef struct Element T_element; /*déclaration du type T_element*/
struct Element
{
int val;
struct Element * suivant;
};
typedef T_element* Liste; /*déclaration du type liste*/
void main()
{
/* Déclarons 3 listes chaînées de façons différentes mais équivalentes */
Liste ma_liste1 = NULL;
T_element * ma_liste2 = NULL;
struct element * ma_liste3 = NULL;
……………….
} il est important de toujours initialiser la liste à NULL

36
 Exemples de fonctions en C…
Ajout en tête d’une liste simplement chaînée
liste ajouterEnTete(Liste L, int valeur)
{
/* On crée un nouvel élément */
T_element* nouvelElement = malloc(sizeof(Element));

/* On assigne la valeur au nouvel élément */

nouvelElement->val = valeur;

/* On assigne l'adresse de l'élément suivant au nouvel élément */

nouvelElement->suivant = L;

/* On retourne la nouvelle liste, ie. le pointeur sur le premier élément */

return nouvelElement;
}
37
 Exemples de fonctions en C…
Ajout en queue d’une liste simplement chaînée
Liste ajouterEnFin(liste L, int valeur)
{ /* On crée un nouvel élément */
T_element* nouvelElement = malloc(sizeof(Element));
/* On assigne la valeur au nouvel élément */
nouvelElement->val = valeur;
/* On ajoute en fin donc aucun élément ne va suivre */
nouvelElement->suivant = NULL;
if(L == NULL) /* Si la liste est vide, il suffit de renvoyer l'élément crée */
{
return nouvelElement;
}
else /* Sinon on parcours la liste à l'aide d'un pointeur temporaire et on indique que le dernier élément
de la liste est relié au nouvel élément */
{
element* p = L;
while(p->suivant != NULL)
{
p = p->suivant;
}
p->suivant = nouvelElement;
return L;
}
}
38
 Exemples de fonctions en C…
Suppression du premier élément d’une liste simplement
chaînée
Liste supprimerElementEnTete(liste L)
{
if(L != NULL)
{
/* Si la liste est non vide, on se prépare à renvoyer l'adresse de
l'élément en 2ème position (nouvelle tête) */
Element* nouv_tete = L->suivant;
/* On libère le premier élément */
free(L);
/* On retourne le nouveau début de la liste */
return nouv_tete;
}
else
{
return NULL;
}
}
39