-UdM/FST-

CHAPITRE VI : LES STRUCTURES DE DONNEES NON LINEAIRES

VI-1 LES TABLES

VI-1-1 Introduction
On utilise souvent en informatique une structure appelée "Table" ou dictionnaire pour ranger des Informations
en mémoire. Une table est un ensemble de couples <clé, information> où chaque clé n’apparaît qu’une seule fois
dans la table.
Exemples :
24) Annuaire téléphonique
Clé (Prénom) Information (Tél + Adresse)
MBALLA 699999999 Avenue Foé
KAMDEM 677777777 Rond pont Deido
. . .
25) Dictionnaire
Clé (Mot) Information (Signification/définition)
Arbre Graphe connexe sans cycle
Table Ensemble de couples <clé, info>
. .
26) Codage
Clé (Mot) Information(Code)

a 001
b 010
. .

Le problème posé est : comment organiser la table pour que les accès (recherche, insertion, suppression) soient
les plus rapides possibles ?

VI-1-2 Accès séquentiel

Il consiste à ranger les clés dans la table dans l’ordre de leur arrivée, les unes à la suite des autres, c’est-à-dire
que l’ajout se fait toujours à la fin de la table. La recherche d’une clé consiste à tester les éléments l’un après l’autre
jusqu’à la trouver c’est-à-dire passer par tous les éléments placés avant. Si la table est triée selon les valeurs des clés:
la recherche peut être dichotomique et plus rapide.

VI-1-3 Hachage (HashCoding)

a- Principe
C’est une technique très utilisée en informatique, elle se base sur une fonction h appelée fonction de hachage ou
de hashcoding, qui appliquée à la clé fournit l’indice correspondant dans la table.
Exemple : Codage

A. KENGNE || Algorithmique et structures de données 43

 -UdM/FST-
– Clé = Caractère (A, B, ···)
– N = 10
– h : Code ASCII mod N

b- Fonctions de Hachage
On trouve plusieurs types de fonctions utilisées en Hashcoding :
1. h(clé) = (CodeASCII ( 1er car) + Code ASCII(2eme`car) ) mod N Si la clé est une chaine de caractères (nom)
2. h(clé) = clé mod N Si clé est une valeur numérique.
3. Méthode du milieu du carré
– Clé = 453
– (Cl)2 = (453)2 = 205209
– h(453) = 52
Si n > 100, on prend 3 chiffres.
La fonction de hachage doit donner des valeurs entières dans l’intervalle des indices de la tables : 0 <=h(cle´) <= N.
En plus, cette fonction doit être la plus distribuée possible sur cet intervalle, pour que les informations
ne se concentrent pas dans une partie de la table.
Un exemple de cas :
Toute la difficulté consiste à écrire une fonction de hachage correcte. Comment transformer une chaîne de
caractères en un nombre unique ?
La fonction de hachage doit nous retourner un indice d’une case de la table, dans laquelle se trouve l’information.
Plus besoin de parcourir toutes les cases (comme c’est le cas avec les Liste Linéaires
Imaginons donc un tableau de 100 cases dans lequel on va stocker des pointeurs vers des structures Etudiants
Etudiant * tableau[100];
Nous devons écrire une fonction qui, à partir d'un nom, génère un nombre compris entre 0 et 99 (les indices du
tableau). C'est là qu'il faut être inventif. Il existe des méthodes mathématiques très complexes pour « hacher » des
données, c'est-à-dire les transformer en nombres. Les algorithmes MD5 et SHA1 sont des fonctions de hachage
célèbres, mais elles sont trop poussées.
On peut inventer notre propre fonction de hachage. Ici, pour faire simple, on peut simplement additionner les valeurs
ASCII de chaque lettre du nom de l’Etudiant, à laquelle somme on applique le modulo (reste de la division) de 100.
Ainsi, l’indice se trouvera forcement dans la table.
int hachage(char *chaine){
int i = 0, nombreHache = 0;
for (i = 0 ; chaine[i] != '\0' ; i++){
nombreHache += chaine[i];
}
nombreHache %= 100;
return nombreHache;
}

A. KENGNE || Algorithmique et structures de données 44

 -UdM/FST-
Grâce à cette fonction de hachage, ont sait donc dans quelle case de la table on doit placer les informations. Pour
y acceder plus tard pour en récupérer les données, il suffira de hacher à nouveau le nom de la personne pour
retrouver l'indice de la case du tableau où sont stockées les informations.
Cette fonction pose néanmoins un problèmes si on a des cas de noms anagrammes (MARIE et AIMER) la fonction
va retourner un même indice de la table. On parle de collision.

c- Problème de collisions
Un problème sérieux se pose avec les fonctions de hachage si deux clés différentes donnent lieu à une même
adresse lorsqu’on leur applique la fonction de hachage, c-à-d
h(cle´1) = h(cle´2).
Une telle situation est appelée « collision » et plusieurs solutions existent pour sa résolution.
c-1 Les listes linéaires chaînées
Elle consiste à placer toutes les clés qui donnent le même indice qu’une clé existante dans une liste linéaire
chainée, appelée liste de débordement :

c-2 Essai linéaire (adressage ouvert)

Cette méthode est généralement utilisée si le nombre d’informations est peu par rapport à la taille de la table. On
range la clé qui a causé la collision (k par exemple) dans la première position vide dans la séquence cyclique :
h(k1),h(k2),··· ,0,N1,N2,...,h(k + 1)
Exemple :

On doit garder, dans ce cas, une case toujours vide pour indiquer la fin de la recherche, c-à-d une valeur interdite
dans les clés.
c-2 Chaînage interne séparé
On ajoute à la table une partie réservée aux collisions de taille M. La taille de la table sera donc N + M.
On insère l’élément en collision dans la première place vide dans la partie des collisions et on le relie par un chaînage.
Exemple :

A. KENGNE || Algorithmique et structures de données 45

 -UdM/FST-

VI-1-4 Exercices
1- Proposer une structure de données efficace qui permet d’organiser et de stocker la liste des étudiants de
l’UdM. (Repérer les aspects statiques et dynamiques afin de proposer une structure de table)
1.1- Ecrire un algorithme qui insère un nouvel étudiant de IRT2.
1.2- Ecrire un algorithme qui recherche un étudiant à partir de son matricule.

2- On veut enregistrer un annuaire téléphonique sur micro, en utilisant la méthode de Hash-Coding. Chaque
entrée de la table représente les informations concernant une personne (Nom, prénom, Numéro de téléphone). La clé
considérée est le nom, et la fonction de hachage est donnée par :
H(cle) = (CodeASCII(1er car) + CodeASCII(2eme`car)) Mod N(5.1)
Où N qui est la taille de la table est égale à 100.
Remarque : les caractères peuvent être en majuscule ou en minuscule et il ne doit pas y avoir de distinction.
Questions :
– Décrire les structures de données nécessaires à la représentation des données en cas d’utilisation de la méthode
des LLCs pour résoudre les collisions.
– Ecrire les procédures de recherche, d’insertion et de suppression.
– Répéter les mêmes questions en utilisant la méthode d’essai linéaire.
– Répéter les mêmes questions en utilisant la méthode de chaînage interne séparé.

A. KENGNE || Algorithmique et structures de données 46

 -UdM/FST-
VI-2 LES ARBRES

1.Généralités sur les arbres

1.1. Principe
Un arbre est une structure de données qui permet de stocker des informations et aussi une organisation des
informations :

L'arbre est constitué de nœuds reliés entre eux de façon hiérarchique par des arrêtes. Le premier nœud est appelé
racine les derniers, ceux après lesquels il n'y a plus de nœud sont les feuilles. Un parcours de la racine vers une
feuille est une branche. Chaque nœud peut être considéré comme la racine d'un sous-arbre constitué de sa
descendance et de lui-même. L'arbre est de ce fait une structure récursive. Dans l'exemple ci-dessus chaque sous-
arbre correspond à un parenthésage. Une information parenthésée peut traduire un arbre.
L'expression : ( personne( nom, prénom, adresse( numéro, rue, ville, département) ) ) est celle de l'arbre :

Chaque étage de l'arbre est appelé niveau et les niveaux sont numérotés de 1 la racine à n la feuille la plus basse. La
hauteur d'un arbre c'est le niveau maximum atteint par une feuille. La hauteur de l'arbre ci-dessus est 3. Souvent on
parle de nœuds parents et de noeud fils. Les noeuds fils sont ceux qui descendent d'un noeud parent et seule la racine
n'a pas de parent. Dans l'exemple ci-dessus, personne est la racine, il est parent de nom, prénom et adresse qui sont
ses fils. Adresse est parent de numéro, rue, ville, département et numéro, rue, ville,département sont fils de adresse.
Les fils d'un même parent sont frères

1.2. Exemples d'utilisations des arbres

Expression arithmétique
Une expression arithmétique, comme nous l'avons déjà mentionné peut-être représentée par un arbre. L'expression :
(a + b) * ( (c - d) / (e + f) ) donne l'arbre suivant :

Un chapitre de cours
Un sommaire de livre scientifique, un chapitre de cours sont construits selon une arborescence, par exemple :

1.3. Nomenclature des arbres

A. KENGNE || Algorithmique et structures de données 47

 -UdM/FST-

Racine : C'est le nœud "sommet" pointé par aucun autre

Niveau : Le niveau de la racine est 1, les autres nœuds ont un niveau augmenté de 1 par rapport au niveau du nœud
dont ils dépendent.
Une branche : Une branche est constituée par le chemin à partir d'un nœud jusqu'à une feuille
Hauteur / profondeur d'un arbre : Pour un arbre donné c'est le niveau atteint par la branche la plus longue.
Degré d'un nœud : C'est le nombre de fils d'un nœud.
Degré d'un arbre : C'est le degré maximum atteint par les noeuds de l'arbre.
Noeuds externes ou feuilles : Ce sont les derniers noeuds suivis par aucun autre.
Noeuds internes : Ensemble des noeuds qui sont suivis par au moins un nœud.
Taille de l'arbre : Nombre total des noeuds de l'arbre.
Arbre ordonné : L'ordre des sous-arbres est significatifs.
Arbre binaire : Arbre ordonné de degré 2 (chaque nœud a au plus deux fils)
Arbre binaire complet : Arbre binaire de taille 2h – 1 ou h représente la hauteur de l'arbre

Exemple :

A est la racine.
B est parent de D et E
D et E sont enfants de B
D et E sont frères (ou siblings)
D, E, F, G, I sont les noeuds externes ou feuilles
A, B, C, H sont les noeuds internes
La hauteur (profondeur) de l'arbre est 4
E est à la profondeur 3
Le degré du noeud C est 3.

Répondre aux questions précédentes pour l’arbre suivant :

1.4 Les typologies d'arbres

Les principaux types d’arbres rencontrés sont soit des arbres binaires ou arbres n-aires. Dans ces deux
catégories ont peut retrouver
– Arbre m-aire : un arbre m-aire d’ordre n est un arbre ou le degré maximum d’un nœud est égal à n.
– B-Arbre : Un arbre B d’ordre n est un arbre où :
▪ La racine a au moins 2 fils
A. KENGNE || Algorithmique et structures de données 48
 -UdM/FST-
▪ Chaque nœud, autre que la racine, a entre n/2 et n fils
▪ Tous les nœuds feuilles sont au même niveau
– Arbre binaire : c’est un arbre ou le degré maximum d’un nœud est égal à 2.
– Arbre binaire de recherche : c’est un arbre binaire où la clé de chaque nœud est supérieure à celles de ses
descendants gauches, et inférieure à celles de ses descendants droits.

1.4.1 Arbre binaire

Ce sont des arbres au plus de degré 2, c'est à dire dans lesquels chaque nœud a au plus deux fils. Les fils
sont en général nommés fils gauche et fils droit. C'est un arbre ordonné, c'est à dire que les fils gauche et
droite ne sont pas interchangeables :

Les arbres binaires sont majoritairement utilisés dans les algorithmes.

1.4.2 Arbre n-aire

C'est un arbre dans lequel au moins un nœud possède plus de deux fils, c’est-à-dire un arbre de degré
supérieur à 2. Ces arbres sont en général peu utilisés dans les algorithmes parce qu'ils peuvent toujours être
convertis en arbres binaires qui sont plus simples à manipuler.

1.4.3 Transformer un arbre n-aire en arbre binaire

Un arbre binaire peut toujours être formé à partir d'un arbre n-aire en utilisant les liens premiers fils, frère
immédiat. Pour chaque nœud de l'arbre n-aire, le fils gauche de l'arbre binaire est donné par le premier fils
dans l'arbre n-aire et le fils droit par le premier frère de l'arbre n-aire, exemple :
L'arbre n-aire :

Devient l’arbre binaire

1.5 Représentations en mémoire

1.5.1 Arbre N-aire

Soit l'arbre suivant :

Il peut être représenté en mémoire sous trois formes :

• tableau de listes chainées
• tableau de structures à deux dimensions
• dynamique à partir de pointeurs

A. KENGNE || Algorithmique et structures de données 49

 -UdM/FST-

Tableau de listes chainées :

Avec comme structure de données

#define NBMAX 9
typedef struct noeud{
int val;
struct noeud *suiv;
}t_noeud;
t_noeud *tab[NBMAX];

Tableau de structures ou à deux dimensions

Avec comme structure de données

#define NBMAX 9
typedef struct noeud{
int val ;
int P1,P2,P3;
}t_noeud;
t_noeud tab[NBMAX];

Dynamique à partir de pointeurs

Avec comme structure de données

typedef struct noeud{
int val
struct noeud*P1,*P2,*P3;
}t_noeud;

A. KENGNE || Algorithmique et structures de données 50

 -UdM/FST-
1.5.2 Arbre Binaire

Soit l'arbre binaire suivant :

C'est un arbre à quatre niveaux. Le nombre maximum possible de noeuds avec quatre niveaux est 24-1 noeuds, c'est
à dire 16-1, 15 noeuds. Il faudrait pour ce faire que tous les noeuds du niveau trois possèdent deux fils, un à gauche,
un à droite. Un tel arbre binaire est dit un arbre binaire complet.

Tableau à une dimension

Un arbre binaire peut se ranger dans un tableau à une dimension avec la règle
suivante :
Soit la racine à l'indice 1, quelque soit le noeud à l'indice i du tableau :
 le fils gauche de i est à i*2 (si dans le tableau)
 le fils droit de i est à i*2+1 (si dans le tableau)

Pour notre arbre ci-dessus nous avons le tableau suivant :

Pour la structure de données

typedef struct noeud{
int val; // valeur du nœud
int g,d; // indice des fils gauche et droit
}t_noeud;

t_noeud *tab; // tableau de noeuds

Construit à partir de pointeurs

L'arbre binaire peut bien sur être construit dynamiquement à partir de pointeurs. La structure de données est alors :
Pour la structure de données
typedef struct noeud{
int val; // valeur du nœud
struct noeud *fg,*fd; // fils gauche et droit
}t_noeud;
t_noeud *racine; // pointeur sur la racine

2. Arbres binaires de recherche

Un arbre binaire de recherche est une structure de donnée qui permet de représenter un ensemble de valeurs si l’on
dispose d’une relation d’ordre sur ces valeurs. Les opérations caractéristiques sont l’insertion, la suppression et la
recherche d’une valeur. Ces opérations sont peu couteuses si l’arbre n’est pas trop déséquilibré. En pratique, les
valeurs sont des clés permettant d’accéder à des enregistrements.

A. KENGNE || Algorithmique et structures de données 51

 -UdM/FST-
2.1 Définition d’un ABR
Un arbre binaire de recherche (abrégé ABR) est un arbre binaire vérifiant la propriété suivante : soient x et y
deux noeuds de l’arbre :
• Si y est un nœud du sous-arbre gauche de x alors cle(y) ≤ cle(x)
• Si y est un nœud du sous-arbre droit de x alors cle(y) ≥ cle(x)
Exemple
L’arbre suivant est un ABR : pour tout noeud p de A, la valeur de p est strictement plus grande que les valeurs
figurant dans son sous-arbre gauche et strictement plus petite que les valeurs figurant dans son sous-arbre droit.

Remarques
1) Une clé n’apparait au plus qu’une seule fois dans un arbre de recherche.
2) Deux ABR peuvent contenir les mêmes valeurs de clés mais être différents.

On peut definir un ABR a travers la structure de données suivante

Type TNoeud = Structure
Clé : entier ;
Info : typeqq ;
Fg,Fd : *TNoeud ;
Fin ;
Var Racine : *TNoeud ;

Quelques opérations sur un ABR

– Allouer (N) : créer une structure de type TNoeud et rendre son adresse dans N.
– Liberer(N) : libérer la zone pointée par N.
– FG(N) : donne le fils gauche de N.
– FD(N) : donne le fils droit de N.
– Valeur(N) : donne le contenu du champs info du nœud pointé par N.
– Clé(N) : donne le contenu du champs Clé du nœud pointé par N.

2.2 Parcours d’un ABR

Le parcours d’un arbre peut s’effectuer en profondeur et préfixe, infixe ou postfixe ou en largeur

– Parcours en profondeur

Procédure PP( noeud : *TNoeud);

Début
Si (nœud ≠ NULL) Alors
PP(FG(noeud)) ;
PP(FD(noeud)) ;
Fin Si;
Fin;

A. KENGNE || Algorithmique et structures de données 52

 -UdM/FST-
Le listage des éléments de l’arbre en profondeur peut se faire en :
– préfixe (préordre) : Pére FG FD,
– infixe (inordre) : FG Père FD,
– postfixe (postordre) : FG FD Père.

Procédure PPréfixe( noeud : *TNoeud);

Début
Si (nœud ≠ NULL) Alors
Ecrire(Valeur(noeud)) ;
PPréfixe(FG(noeud)) ;
PPréfixe(FD(noeud)) ;
Fin Si;
Fin;
Avec l’arbre précèdent, on obtient la trace : 15 6 3 2 4 7 13 9 18 17 20

Procédure Infixe( noeud : *TNoeud));

Début
Si (nœud ≠ NULL) Alors
Infixe(FG(noeud)) ;
Ecrire(Valeur(noeud)) ;
Infixe(FD(noeud)) ;
Fin Si;
Fin;
Avec l’arbre précèdent, on obtient la trace : 2 3 4 6 7 9 13 15 17 18 20

Procédure Postfixe( noeud : *TNoeud);

Début
Si (nœud ≠ NULL) Alors
Postfixe(FG(noeud)) ;
Postfixe(FD(noeud)) ;
Ecrire(Valeur(noeud)) ;
Fin Si;
Fin;
Avec l’arbre précèdent, on obtient la trace : 2 4 3 9 13 7 6 17 20 18 15

– Parcours en largeur

Procédure PL( noeud : *TNoeud);

Var N : *TNoeud ;
Début
Si (noeud ≠ NULL) Alors
InitFile ;
Enfiler(noeud) ;
Tant que (Non(FileVide)) faire
Défiler(N) ;
Afficher(Valeur(N)) ;
Si (FG(N) ≠ NULL) Alors
Enfiler(FG(N)) ;
A. KENGNE || Algorithmique et structures de données 53
 -UdM/FST-
Fin Si;
Si (FD(N) ≠ NULL) Alors
Enfiler(FD(N)) ;
Fin Si;
Fin TQ;
Fin Si;
Fin;
Avec l’arbre précèdent, on obtient la trace : 15 6 18 3 7 17 20 2 4 16 9

2.3 Recherche dans un ABR

La fonction suivante retourne l’adresse du nœud contenant une valeur recherchée ou NULL si la valeur recherchée
ne se trouve pas dans l’arbre.

Fonction Rechercher( noeud : *TNoeud ; xClé : entier) : *TNoeud;

Var I : entier ; Trouv : Booleen ;
Début
Si ((noeud = NULL) ou Clé(noeud)=xClé)) Alors
retourner(nœud) ;
Sinon
Si (Clé(noeud) > xClé ) Alors
retourner Rechercher(FG(noeud)) ;
Sinon
retourner Rechercher(FD(noeud)) ;
Fin Si;
Fin Si;
Fin;
2.3 Insertions d’un nœud dans un ABR
L’élément à ajouter est inséré là où on l’aurait trouvé s’il avait été présent dans l’arbre. L’algorithme
d’insertion recherche donc l’élément dans l’arbre et, quand il aboutit à la conclusion que l’élément
n’appartient pas à l’arbre (l’algorithme aboutit sur NULL), il insère l’élément comme fils du dernier nœud
visité.

2.4 Suppression d’un nœud

Plusieurs cas de figure peuvent être trouvés : soit à supprimer le nœud N

Cas
Action
FG(N) FD(N) Exemple
NULL NULL Feuille (2,4,17) Remplacer N par NULL

NULL ≠NULL 7 Remplacer N par FD(N)

≠NULL NULL 13 Remplacer N par FG(N)
1- Rechercher le plus petit descendant à droite de N soit P (7)
≠NULL ≠NULL 6 2- Remplacer Valeur(N) par Valeur(P) (6 7)
3- Remplacer P par FD (P) (7 13 )

Exercice : Donner l’arbre après la suppression de 3 puis de 15.

A. KENGNE || Algorithmique et structures de données 54
 -UdM/FST-
3. Les Tas (Heaps)

3.1 Définition
Un tas (heap en anglais) est un arbre qui vérifie les deux propriétés suivantes :
3) C’est un arbre binaire complet c’est-à-dire un arbre binaire dont tous les niveaux sont remplis sauf
éventuellement le dernier où les éléments sont rangés le plus à gauche possible.
4) La clé de tout nœud est supérieure à celle de ses descendants.
5) L’élément le plus prioritaire se trouve donc toujours à la racine.
Exemple d’un tas :

3.2 Opérations sur les tas

3.2.1 Ajout
Pour ajouter un nouvel élément dans le tas on doit :
1. Créer un nœud contenant la valeur de cet élément,
2. Attacher ce nœud dans le dernier niveau dans la première place vide le plus à gauche possible (créer
un nouveau niveau si nécessaire). On obtient toujours un arbre binaire complet mais pas nécessairement
un tas.
3. Comparer la clé du nouveau nœud avec celle de son père et les permuter si nécessaire, puis
recommencer le processus jusqu’il n’y ait plus d’éléments à permuter.

Exemple : soit à ajouter l’élément de priorité 15 :

3.2.2 Retrait
L’élément le plus prioritaire se trouve toujours à la racine, donc le retrait consiste à lire la racine puis la supprimer.
Pour ce faire on doit :
1. Remplacer la valeur de la racine par la valeur de l’élément le plus à droite dans le dernier niveau.
2. Supprimer de l’arbre cet élément (le plus à droite dans le dernier niveau), on obtient un arbre binaire
mais pas nécessairement un tas.
3. On compare la valeur de la racine avec les valeurs de ses deux fils et on la permute avec la plus
grande. On recommence le processus jusqu’il n’y ait plus d’éléments à permuter.
Exemple :

A. KENGNE || Algorithmique et structures de données 55

 -UdM/FST-

3.2.3 Implémentation des Tas

Les tas peuvent être implémentés dynamiquement exactement comme les ABR, et sont utilisés par le même
modèle.
Une représentation statique très efficace utilisant des tableaux est très utilisée en pratique, elle consiste
à ranger les éléments du tas dans un tableau selon un parcours en largeur :

On remarque sur le tableau obtenu que le fils gauche d’un élément d’indice i se trouve toujours s’il
existe à la position 2i, et son fils droit se trouve à la position (2i + 1) et son père se trouve à la position
i/2. Les opérations d’ajout et de retrait sur le tas statique se font de la même façon que dans le cas du tas
dynamique. Avec ce principe les opérations d’ajout et de retrait se font d’une manière très simple et
extrêmement efficace. Les tas sont utilisés même pour le tri des tableaux : on ajoute les éléments d’un
tableau à un tas, puis on les retire dans l’ordre décroissant.

4.4 Exercices
1. Arbres de recherche binaires
(a) Compréhension
– Construire un arbre de recherche binaire à partir des clés ordonnées suivantes :
25 60 35 10 5 20 65 45 70 40 50 55 30 15
– Ajouter à l’arbre obtenu et dans l’ordre, les éléments suivants :
22 62 64 4 8
– Supprimer de l’arbre obtenu et dans l’ordre les éléments suivants :
15 70 50 35 60 25
(b) Écrire sur les arbres de recherche binaires les fonctions récursives qui retournent :
– Vrai si un nœud donné est une feuille et Faux sinon.
– Le nombre de feuilles de l’arbre.
– La taille de l’arbre.
– Le père d’un nœud donné.
– Le successeur d’un nœud donné (l’élément immédiatement supérieur).
– Le prédécesseur d’un nœud donné (l’élément immédiatement inférieur).
A. KENGNE || Algorithmique et structures de données 56
 -UdM/FST-
– Le maximum dans un arbre donné.
– Le minimum dans un arbre donné.
– La hauteur d’un arbre.
(c) Écrire les algorithmes d’insertion et de suppression dans un ABR.
(d) Écrire la fonction qui crée un arbre binaire de recherche équilibré à partir d’un tableau trié.
(e) Écrire un algorithme de parcours en profondeur dans un arbre de recherche binaire:
▪ Préordre (Père FG FD)
▪ Inordre (FG Père FD)
▪ PostOrdre (FG FD Père)
2. Tas
(a) Compréhension
– Construire un tas à partir des clés ordonnées suivantes :
25 60 35 10 5 20 65 45 70 40 50 55 30 15
– Ajouter au tas et dans l’ordre les éléments suivants :
22 62 64 4 8
– Supprimer du tas et dans l’ordre les éléments suivants :
15 70 50 35 60 25
(b) Écrire les algorithmes d’insertion et de suppression dans un tas statique.
(c) Écrire les algorithmes d’insertion et de suppression dans un tas dynamique.

A. KENGNE || Algorithmique et structures de données 57