0% ont trouvé ce document utile (0 vote)

51 vues91 pages

DataStructers ABN

Le document présente les structures de données dynamiques, en mettant l'accent sur les listes chaînées et leurs opérations de base. Il décrit les avantages et inconvénients des tableaux par rapport aux listes chaînées, ainsi que les différentes manières d'ajouter, supprimer et parcourir des éléments dans une liste chaînée. Enfin, il fournit des algorithmes et des exemples de code en C pour illustrer la création et la manipulation de listes chaînées simples.

Transféré par

sindasahmima

Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.

Formats disponibles

Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd

0% ont trouvé ce document utile (0 vote)

51 vues91 pages

DataStructers ABN

Transféré par

sindasahmima

Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.

Formats disponibles

Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd

LES STRUCTURES DE

DONNÉES DYNAMIQUES

anis.bennacib@gmail.com A.U 2023-2024

INTRODUCTION
 Structure de données
o Une manière particulière de stocker et d'organiser les données dans un support afin qu'elles
puissent être utilisées efficacement.
o Il s'agit d'un groupe d'éléments de données regroupés sous un même nom.
o Il est également appelé "Type de données abstrait (ADT)"

 Dans quel but?

Pour plus d'efficacité et la facilité de :
o Stockage des données
o Récupération de données
o Manipulation de données

 Problème de conception :
Le défi est de sélectionner la structure de données la plus appropriée pour le problème
LISTE DES STRUCTURES DE DONNÉES(DE BASE)

Les tableaux(Arrays) Listes chaînées (Linked Lists)

Les Files(Queues) Les Arbres(Trees)

Les Piles(Stacks)
CLASSIFICATION DES STRUCTURES DE DONNÉES
 Basé sur l’existence:

 Structures de données physiques

Peut être créé indépendamment :
• Tableau
• Liste chaînée

 Structures de données logiques

Ne peut pas être créé indépendamment
• Pile
• Files
• Les Arbres
• Les graphes
CLASSIFICATION DES STRUCTURES DE DONNÉES
 Basé sur l’allocation de mémoire :

 Structures de données statiques (ou de taille fixe)

Tels que les tableaux

 Structures de données dynamiques (modifier la taille selon les besoins)

Telles que les listes chaînées

CLASSIFICATION DES STRUCTURES DE DONNÉES
 Basé sur la représentation:

 Structures de données linéaires

• Les tableaux
• Les listes chaînées
• Les piles
• Les files

 Structures de données non linéaires

• Les arbres
• Les graphes
LES OPÉRATIONS DE BASE SUR LES STRUCTURES DE DONNÉES

 Parcourir tous les éléments

 Rechercher un élément ou son emplacement

 Insérer un élément(au début, à la fin, avant ou après un élément donné…),

 Supprimer un élément

 Trier les éléments(croissant ou décroissant)

 Fusionner les éléments de deux (ou plus) structures de données

LES TABLEAUX (ADT)
LES TABLEAUX ADT
 Sauvegarde de donnée
Collection séquentielle des éléments de même type et de nombre fixe.
 Opération
 Créer(Allocation dynamique)

 Remplir un tableau

 Afficher les éléments d'un tableau

 Insérer un élément

 Recherche d'un élément

 Supprimer un élément

 Fusionner deux tableaux(ou plus)

LES LISTES CHAÎNÉES
SIMPLES - DOUBLES - CIRCULAIRES
LISTES CHAÎNÉES (POURQUOI?)
Les tableaux peuvent être utilisés pour stocker des données linéaires de types similaires, mais les
tableaux présentent les limitations suivantes.
 La taille des tableaux est fixe.
 L’insertion d’un nouvel élément dans un tableau d’éléments est coûteuse.
 La suppression est également coûteuse avec les tableaux jusqu’à ce que des techniques spéciales
ne soient utilisées.

 Avantages
 Taille dynamique
 Simplicité d’insertion/suppression

 Inconvénients
 L’accès aléatoire n’est pas autorisé. Nous devons accéder aux éléments séquentiellement à partir du
premier nœud.
 Un espace mémoire supplémentaire pour un pointeur est requis pour chaque élément de la liste.
LES LISTES CHAÎNÉES SIMPLES
I. LISTES CHAÎNÉES SIMPLES
 Définition

Une liste chaînée est une structure dynamique formée d’éléments(nœuds) de même
types reliés par des liens(des pointeurs). Les nœuds de la liste sont éparpillés dans
la mémoire.

Tête

Chaque nœud de la liste est constitué de deux parties :

NULL

un champ qui contient L'adresse

un champ de données de l'élément suivant(Pointeur)
I. LISTES CHAÎNÉES SIMPLES
 Remarques

Tête

NULL

 Une liste chainée est caractérisée par l’adresse de son premier élément(Le pointeur Tête).

 Le dernier élément d’une liste chainée simple contient un pointeur vers NULL.

 Une liste chaînée d'un élément contient un pointeur(tête) vers l'unique nœud de liste qui
pointe vers NULL.
 Le dernier élément existant, son champ suivant vaut NULL.

 Une liste vide ne contient pas de nœud, le pointeur Tête pointe donc vers la valeur NULL.
DÉCLARATION
I. LISTES CHAÎNÉES SIMPLES
 Déclaration En algorithme

TYPE
Nom_noeud= Enregistrement
donnee : Type_donnee
suivant : Pointeur sur Nom_noeud
FinNom_noeud
Nom_Liste = Pointeur sur Nom_noeud

NB.
• La partie "donnée" de nœud peut être de type prédéfini ou définie par l'utilisateur.

• Le pointeur suivant pointe sur l'enregistrement dont il fait partie de ses champs, il s'agit d'une déclaration
récursive.
I. LISTES CHAÎNÉES SIMPLES
 Déclaration En C
//Définition de la structure Nom_Noeud
typedef struct nom_Noeud
{
type_donnee data;
struct nom_noeud* next;
} Nom_Noeud;

//Définition de la liste chaînée

typedef Nom_Noeud * Nom_Liste;

NB.
Pour faciliter la manipulation de la liste, on définit le nouveau type Nom_Liste comme étant un
pointeur sur un Nom_Noeud.
 Créer une Liste chaînée simple(LSC) vide.
 Tester si une LCS est vide
 Ajouter un élément à une LSC(au début, à la fin et
avant ou après un élément donné)
 Parcourir une LCS / Affichage
 Compter le nombre d'éléments d'une LCS
 Supprimer un élément d'une LSC
OPERATIONS SUR LES
 Mettre à jour les données d'un élément d'une LSC
LISTES CHAÎNÉES
 Chercher un élément dans une LSC
SIMPLES
 Trier les éléments d'une LSC(croissant et
décroissant)
 Fusionner deux LSC,
 Etc,
I. LISTES CHAÎNÉES SIMPLES
Soit les déclarations suivantes :

Déclaration En algorithme Déclaration En C

//Définition de la structure Nom_Noeud

TYPE
typedef struct noeud
Noeud = Enregistrement {
donnee : entier int data;
suivant : Pointeur sur Noeud struct noeud* next;
} Noeud;
FinNoeud
//Définition de la liste chaînée
PNoeud = Pointeur sur Noeud typedef Noeud* PNoeud;

NB.
Dans tout ce qui suit, nous supposons qu'une liste chaînée simple contenant les identifiants des membres d'un
club a été créé et qu'on dispose de la variable pointeur "Tete_Liste" qui pointe sur le premier élément de la
liste.
CRÉATION D'UNE LISTE CHAÎNÉE SIMPLE VIDE
(INITIALISATION DE LA LISTE)

TESTER SI UNE LISTE CHAÎNÉE SIMPLE EST

VIDE
I. LISTES CHAÎNÉES SIMPLES
 Création d'une liste chaînée simple vide (initialisation de la liste)

Algorithme de la procédure Creer_Liste

Procédure Créer_Liste(var Tete_Liste : PNoeud)
Début
Tete_Liste ⃪ NULL
Fin

Implémentation de la procédure Creer_Liste en C

PNoeud Creer_Liste(void)
{
int main()
return NULL;
{
}
PNoeud Tete_Liste = Creer_liste();
}
I. LISTES CHAÎNÉES SIMPLES
 Tester si une liste chaînée simple est vide

Algorithme de la fonction estVide

Fonction estVide(Tete_Liste : PNoeud):booléen
Début
Retourner Tete_Liste=NULL
Fin

Implémentation de la procédure Creer_Liste en C

int estVide(PNoeud Tete_Liste)
{
return Tete_Lsite==NULL;
}
AJOUTER UN ÉLÉMENT (NOEUD)
AU DÉBUT(TÊTE) D'UNE LISTE
I. LISTES CHAÎNÉES SIMPLES
 Ajouter un élément(nœud) au début d'une liste(en tête)
 1er cas : La liste est vide  2ème cas : La liste n'est pas vide

221 Tête 201

Tête NULL
NULL

Tête
201
221 201
NULL
NULL

Tête
Tête 201 221 201

NULL NULL
I. LISTES CHAÎNÉES SIMPLES
 Ajouter un élément(nœud) au début d'une liste(en tête)
Algorithme de la procédure Ajouter_Debut

Procédure Ajouter_Début(var Tete_Liste : PNoeud; id : entier)

Var
nouveau : PNoeud
Début
nouveau ⃪ Allouer (taille (Noeud))
*nouveau.donnee ⃪ id
*nouveau.suivant ⃪ Tete_Liste
Tete_Liste ⃪ nouveau
Fin
I. LISTES CHAÎNÉES SIMPLES
 Ajouter un élément(nœud) au début d'une liste(en tête)
Implémentation en C

PNoeud Ajouter_Debut(PNoeud Tete_Liste; int id)

{
PNoeud nouveau = (PNoeud)malloc (sizeof (Noeud));
if(!nouveau)
{
printf("erreur d'allocation ! ");
}
nouveau->donnee = id;
nouveau->suivant = Tete_Liste;
Tete_Liste = nouveau; //Tete_Liste = nouveau;
Return Tete_Liste ;
}
 Remarque :

 Ne pas confondre l’utilisation du point "." et l’utilisation de la flèche "->" pour accéder
aux champs d’une structure. On utilise le point pour une variable de type structure, et
une flèche pour une variable de type pointeur sur structure.

 La fonction renvoie la nouvelle adresse de la tête de liste.

Avec des insertions en tête de liste, la liste obtenue est classée à l’envers, le dernier
élément saisi étant le premier élément de la liste. Pour obtenir les éléments à l’endroit,
il faudrait faire les insertions en queue de liste .
PARCOURIR UNE LISTE CHAÎNÉE
I. LISTES CHAÎNÉES SIMPLES
 Parcourir une liste chaînée simple

L’idée du parcours de liste chaînée est de :

 Prendre un pointeur auxiliaire p.

 On fait pointer p sur la première cellule, puis le pointeur p passe à la cellule suivante (par une

affectation p=p->suivant), etc.

 Le parcours s’arrête lorsque p vaut le suivant de la dernière cellule, c’est-à-dire lorsque p vaut NULL

Tête

NULL
I. LISTES CHAÎNÉES SIMPLES
 Parcourir une liste chaînée simple(dans l'ordre)
Algorithme de la procédure Afficher_LSC

Procédure Afficher_LSC(Tete_Liste : PNoeud)

Var
P : PNoeud
Début
Si estVide(Tete_Liste) Alors
Ecrire("Liste vide")
Sinon
P ⃪ Tete_Liste Répéter
TantQue(P≠NULL)faire Ecrire(*P.donnee)
Ecrire(*P.donnee) Ou bien P ⃪ *P.suivant
P ⃪ *P.suivant Jusqu'à (P = NULL)
finTantQue
finSi
Fin
AJOUTER UN ÉLÉMENT (NOEUD)
EN FIN(QUEUE) D'UNE LISTE
I. LISTES CHAÎNÉES SIMPLES
 Ajouter un élément(nœud) en fin de liste (en queue)
L’insertion d’un élément en queue de liste est un peu plus compliquée que l’insertion en tête de
liste.

 Elle nécessite un parcours de la liste pour rechercher l’adresse du dernier élément.

 La condition d’arrêt est lorsque p->suivant égale à NULL parce que nous cherchons l’adresse
de dernier élément.

 C’est un cas différent du parcours de liste chaînée, où il faut traiter le dernier élément comme
les autres.(Affichage)

 L’insertion en queue de liste permet de saisir une liste chaînée à l’endroit.

I. LISTES CHAÎNÉES SIMPLES
 Ajouter un élément(nœud) en fin de liste (en queue)

Tête

NULL

301
I. LISTES CHAÎNÉES SIMPLES
 Ajouter un élément(nœud) en fin de liste (en queue)

Tête

NULL

301
 Ajouter un élément(nœud) en fin de liste (en queue)
Algorithme de la procédure Ajouter_Fin

Procédure Ajouter_Fin(var Tete_Liste : PNoeud; tel : entier)

Var
P, nouveau : PNoeud
Début
nouveau ⃪ Allouer (taille (Noeud))
*nouveau.donnee ⃪ tel
*nouveau.suivant ⃪ NULL
Si estVide(Tete_Liste) Alors
Tete_Liste ⃪ nouveau
Sinon
P ⃪ Tete_Liste
TantQue(*P.suivant≠NULL)faire
P ⃪ *P.suivant
finTantQue
*P.suivant ⃪ nouveau
finSi
Fin
 Compléments :

 La création d’une liste chaînée par insertions en queue prend un nombre d’opérations
quadratique (O(n2)) par rapport au nombre de nœuds. On peut éviter cela et écrire un
algorithme linéaire (O(n)) en maintenant tout au long de l’algorithme un pointeur sur le
dernier nœud, sans le rechercher à chaque fois par un parcours de liste.

(voir exemple_complet_lsc02.C)
INSÉRER UN ÉLÉMENT (NOEUD) À
UNE POSITION SELON UN CRITÈRE
EXERCICE D’APPLICATION
Écrire un module qui prend en paramètre une liste chaînée supposée triée
dans l'ordre croissant, un entier (val) à insérer dans la liste de façon que les
valeurs entières de liste restent classées en ordre croissant.
I. LISTES CHAÎNÉES SIMPLES
 Insérer un élément dans une liste triée
1er cas : Si la liste est vide, le nouveau élément à insérer devient le premier

Tête
10
nouveau NULL

 2ème cas : La liste n'est pas vide mais il faut insérer au début parce que la nouvelle valeur est inférieure à
celle du premier élément : si nouveau->val < premier->val

Tête
Tête
10 20
10 20
nouveau NULL nouveau
NULL
I. LISTES CHAÎNÉES SIMPLES
 Insérer un élément(Noeud) dans une liste triée
3ème cas : Dernier cas, l'élément est à insérer quelque part dans la liste.
Pour ce faire il faut chercher la bonne place et conserver l'adresse de l'élément qui précède.

Tête
10 30 60 70 140 200

50 NULL

nouveau
I. LISTES CHAÎNÉES SIMPLES
 Insérer un élément(Noeud) dans une liste triée
3ème cas : Dernier cas, l'élément est à insérer quelque part dans la liste.
Pour ce faire il faut chercher la bonne place et conserver l'adresse de l'élément qui précède.

Tête
10 30 60 70 140 200

50 NULL

nouveau
 Insérer un élément(Noeud) dans une liste triée
Algorithme de la procédure Insérer_Asc
Procédure Insérer_Asc(var Tete_Liste : PNoeud; val : entier)
Var
nouveau, courant, precedent : PNoeud
Début
nouveau ⃪ Allouer (taille (Noeud))
*nouveau.donnee ⃪ val
Si (estVide(Tete_Liste) ou *nouveau.donnee≤*Tete_Liste.donnee) Alors
*nouveau.suivant ⃪ Tete_Liste
Tete_Liste ⃪ nouveau
Sinon
courant ⃪ Tete_Liste
precedent ⃪ Tete_Liste
TantQue(courant≠NULL et *nouveau.donnee>*courant.donnee)faire
precedent ⃪ courant
courant ⃪ *courant.suivant
finTantQue
*nouveau.suivant ⃪ courant
*precedent.suivant ⃪ nouveau

finSi
Fin
DÉTRUIRE UNE LISTE CHAÎNÉE
(LIBÉRATION MÉMOIRE)
I. LISTES CHAÎNÉES SIMPLES
Détruire une liste chaînée simple.
Pour libérer la mémoire d’une liste chaînée, il faut détruire chacun des éléments(Nœud)

Tête

10 20 70

NULL