19/03/2020
1
Les arbres
1
19/03/2020
2
Introduction
L'arbre est une structure de donnée qui
généralise la liste : alors qu'une cellule de liste a un seul successeur (leur suivant), dans un arbre elle peut en avoir plusieurs. On parle alors de noeuds(au lieu de cellule).
Un noeud père peut avoir plusieurs noeuds fils.
Un fils n'a qu'un seul père, et tous les noeuds ont un ancêtre commun appelé la racine de l'arbre (le seul noeud qui n'a pas de père).
2
19/03/2020
3
Définition récursive
• Un arbre A est
• un arbre vide: ()
• Ou
• (r,A1,A2,…,An) r un élément, A1,A2,…,An des arbres distincts
A= () ou
3
19/03/2020
4
Définitions et terminologie
• Définition
• Un arbre est un ensemble organisé de noeuds dans lequel chaque noeud a un père et un seul, sauf un noeud que l’on appelle la racine.
• Un nœud peut être de n'importe quel type.
4
19/03/2020
5
Exemple d’arbre
5
19/03/2020
6
terminologies
• père d’un sommet : le prédécesseur d’un sommet.
• fils d’un sommet : les successeurs d’un sommet
• frères : des sommets qui ont le même père
• noeud = sommet
• racine : noeud sans père
• feuille : noeud sans fils
6
19/03/2020
7
terminologies
• Chemin :
• On considère une suite de nœuds d’un
arbre(x1,…, xk) tel que: xi= pere(xi+1) pour 1 i k- 1, cette suite est appelée chemin entre le nœud x1 et le nœud xk. La longueur d’un chemin est égale au nombre de nœuds qu’il contient moins un. Il existe un chemin de longueur zéro entre tout nœud et lui même. Tout nœud peut être
atteint en suivant un chemin unique de la racine à ce nœud.
7
19/03/2020
8
terminologies
• Ancêtre:
• L’ancêtre d’un nœud v est tout nœud sur le chemin de la racine à v. En particulier la racine est l’ancêtre de tous les autres nœuds.
• Descendant:
• le descendant d’un nœud v est tout nœud sur le chemin de v à une feuille de l’arbre. En
particulier, tous les nœuds sont descendants de la racine.
8
19/03/2020
9
terminologies
• Branche: un chemin qui commence par la racine et se termine par une feuille
• Sous-arbre: un nœud accompagné de toute sa descendance
• Niveau (profondeur ou hauteur) d’un noeud : Longueur du chemin qui relie la racine à ce nœud.
• La racine est de hauteur 0, ses fils sont de hauteur 1, et les autres noeuds de hauteur supérieure à 1.
• Hauteur d’un arbre : profondeur maximale d’un nœud d’un arbre.h(A) = Max{h(x) ; x noeud de A}.
• Par convention, un arbre vide a une hauteur de -1.
• Taille d’un arbre : nombre de ses sommets
9
19/03/2020
10
terminologies
• Nœuds internes: Un nœud qui n’est pas une feuille.
• Degré d’un nœud: Le nombre de fils de ce nœud.
• Degré d’un arbre: Est le plus grand degré des nœuds de l’arbre. Un arbre de degré n est dit n-aire.
10
19/03/2020
11
Exemple
•
11
niveau 0 niveau 1 niveau 2 niveau 3
racine
nœuds internes
feuilles
parent et fils
11
19/03/2020
12
Arbre ordonné
– Un arbre où la position respective des sous arbres reflète une relation d'ordre. En d'autres termes, si un nœud a k fils, il existe un 1er fis, un 2ème fils, …, et un kème fils.
– Les deux arbres de la figure qui suit sont différents si on les regarde comme des arbres ordonnés, mais identiques si on les regarde comme de simples arbres.
12
19/03/2020
13
Arbres dégénéré ou filiforme
• Est un arbre dont chaque nœud a au plus un fils.
13
19/03/2020
14
14
Arbres binaires
• Un Arbre Binaire est un arbre où chaque nœud admet au plus 2 fils.
19/03/2020
15
Arbre binaire complet
Arbre binaire dont chaque niveau est rempli.
chaque nœud autre qu’une feuille admet deux descendants et toutes les feuilles sont au même niveau;
14
10
15 12
8
16 18
15
19/03/2020
16
16
Arbres Binaires parfaits
• Arbre Binaire parfait : les feuilles sont toutes situées dans les deux derniers niveaux. Les feuilles du dernier niveau sont toutes à gauche.
14
10
15 12
8
16
7 9 11 13
18
19/03/2020
17
Arbre binaire équilibré
• Facteur d'équilibre d'un nœud d'un arbre binaire :
– Hauteur du sous arbre partant du fils gauche du nœud moins la hauteur du sous arbre partant de son fils droit.
• Arbre binaire équilibré (au sens des hauteurs) :
– Un arbre binaire tel que pour chaque nœud, la valeur absolue du facteur d'équilibre est inférieure ou égal à un.
– Sur l'exemple qui suit, on place à côté de chaque nœud son facteur d'équilibre.
17
19/03/2020
18
18
1 0
1 4 4
8 1
6 2
6
1 2
0 1
0 0
0
0
-1 1
19/03/2020
19
ARBRES BINAIRES
19
19/03/2020
20
ARBRE BINAIRE
• un arbre est binaire si chacun de ses nœuds a au plus deux fils (zéro, un ou deux fils).
• Les deux fils d’un nœud sont appelés fils gauche et fils droit.
20
19/03/2020
21
• Les propriétés d’un arbre binaire:
• *un nœud interne à au plus deux fils.
• *les fils d’un nœud forment une paire ordonnée (fils gauche et fils droit)
21
19/03/2020
22
Définition récursive
• Un arbre binaire A est :
– soit vide (A = ( )),
– soit de la forme A = <r, A1, A2>, c-à-d composé :
• d'un nœud rappelé racinecontenant un élément
• et de deux arbres binaires disjoints A1et A2, appelés respectivement sous arbre gauche(ou fils gauche) et sous arbre droit(ou fils droit).
22
19/03/2020
23
TAD Arbres binaires
Type Arbre_Binaire
Utilise pnoeud, Elément, Booléen Opérations
arbre_vide : Arbre_Binaire
est_vide : Arbre_Binaire Booléen
cons : pnoeud x Arbre_Binaire x Arbre_Binaire Arbre_Binaire
racine : Arbre_Binaire pnoeud
gauche : Arbre_Binaire Arbre_Binaire droit : Arbre_Binaire Arbre_Binaire contenu : pnoeud Elément
Préconditions
racine(A) est-défini-ssi est_vide(A) = faux gauche(A) est-défini-ssi est_vide(A) = faux droite(A) est-défini-ssi est_vide(A) = faux Axiomes
Soit, r : pnœud; A1, A2 : Arbre_Binaire racine(<r, A1, A2>) = r
gauche(<r, A1, A2>) = A1 droite(<r, A1, A2>) = A2
23
19/03/2020
24
Opérations primitives sur les arbres binaires
• Création d’un arbre binaire vide
• arbre_vide: → Arbre_Binaire
• Création d’un arbre binaire non vide
• cons: pnoeudx Arbre_Binairex Arbre_Binaire→
• Arbre_Binaire
• cons : (p, a1, a2) ↦arbre (p, a1, a2)
• Test d’arbre vide
• est_vide: Arbre_Binaire → Booléen
• Est_vide: arbre_vide() ↦vrai
• Est_vide: cons(p, a1, a2) ↦faux
•
24
19/03/2020
25
Opérations primitives sur les arbres binaires
• Racine d’un arbre
• racine: Arbre_Binaire → pnoeud
• racine : () ↦erreur !
• racine : cons(p, a1, a2) ↦p
• Sous-arbre gauche de la racine d’un arbre
• gauche: Arbre_Binaire → Arbre_Binaire
• gauche : () ↦erreur !
• gauche : cons(p, a1, a2) ↦a1
• Sous-arbre droit de la racine d’un arbre
• droit : Arbre_Binaire → Arbre_Binaire
• droit : () ↦erreur !
• droit : cons(p, a1, a2) ↦a2
25
19/03/2020
26
Autres opérations
• Feuille: teste de feuille (racine d’un arbre
binaire dont les deux sous-arbres sont vides),
• Hauteur: hauteur d’un arbre binaire,
• Taille: nombre de noeuds
26
19/03/2020
27
REPRESENTATION CHAÎNEE DES ARBRES BINAIRES
• Chaque nœud est une structure qui contient un champs pour les données, et deux pointeurs :
• *un vers le fils gauche et
• *un vers le fils droit.
27
19/03/2020
28
Représentation chaînée du TAD Arbre binaire
• A
B
F D
C
E
G H
I
28
racine A
B E
C D F I
G H
19/03/2020
29
Réalisation chaînée en c d'un arbre binaire
• typedef int element;
• typedef struct Noeud nœud ;
• typedef nœud * pnoeud ;
• typedef pnoeud arb_bin;
• struct Noeud{
• pnoeud fg ;
• pnoeud fd ;
• element info ;
• } ; 29
19/03/2020
30
Réalisation chaînée en c d'un arbre binaire
• Arb_bin arbre_vide(){return NULL;}
• int est_vide(arb_bin A){return (A==NULL);}
• arb_bin cons(pnoeud n, arb_bin g, arb_bin d){
• n->fg=g;
• n->fd=d;
• return n;
• }
30
19/03/2020
31
Réalisation chaînée en c d'un arbre binaire
• pnoeud racine (arb_bin A){
• if (est_vide(A))erreur(« arbre vide »);
• return A;
• }
• element contenu(pnoeud n){return n->info;}
31
19/03/2020
32
Réalisation chaînée en c d'un arbre binaire
• arb_bin droit(arb_bin A){
• if (est_vide(A)) erreur(« arbre vide »);
• return A->fd;
• }
• arb_bin gauche(arb_bin A){
• if (est_vide(A)) erreur(« arbre vide »);
• return A->fg;
• }
32
19/03/2020
33
Parcours d’un arbre binaire
• Beaucoup d'algorithmes sur les arbres nécessitent de parcourir (traiter) tous les sommets.
• Exemple:
• Tester l'existence d'une valeur particulière dans un arbre.
• Afficher un arbre.
33
19/03/2020
34
Parcours d’un arbre binaire
• Il y a plusieurs manière de parcourir un arbre suivant l’ordre dans lequel on énumère un nœud et ses sous-arbre gauche et droit :
• On peut parcourir de gauche à droite, ou de droite à gauche.
• Une fois ce choix fait, on distingue les parcours
• en largeur
• en profondeur
• 34
19/03/2020
35
35
Parcours d’un arbre binaire
• On définit trois parcours en profondeur
– Le parcours préfixe, – Le parcours infixe et – Le parcours postfixe.
19/03/2020
36
36
Parcours en profondeur Parcours préfixe
• En abrégé RGD (Racine, Gauche, Droit)
• Consiste à effectuer dans l'ordre :
– Le traitement de la racine,
– Le parcours préfixe du sous arbre gauche et – Le parcours préfixe du sous arbre droit.
19/03/2020
37
Parcours en profondeur Parcours préfixe
• void prefix(arb_bin A){
• if(!est_vide(A)){
printf(« %d\t »,A->info);
prefix(A->fg);
prefix(A->fd);
} }
37
19/03/2020
38
38
Parcours en profondeur Parcours infixe
• En abrégé GRD (Gauche, Racine, Droit)
• Consiste à effectuer dans l'ordre :
– Le parcours infixe du sous arbre gauche, – Le traitement de la racine et
– Le parcours infixe du sous arbre droit.
19/03/2020
39
Parcours en profondeur Parcours infixe
• void infix(arb_bin A){
• if(!est_vide(A)){
infix(A->fg);
printf(« %d\t »,A->info);
infix(A->fd);
} }
39
19/03/2020
40
40
Parcours en profondeur parcours postfixe
• En abrégé GDR (Gauche, Droit, Racine)
• Consiste à effectuer dans l'ordre :
– Le parcours postfixe du sous arbre gauche, – Le parcours postfixe du sous arbre droit et – Le traitement de la racine.
19/03/2020
41
Parcours en profondeur parcours postfixe
• void postfix(arb_bin A){
• if(!est_vide(A)){
postfix(A->fg);
postfix(A->fd);
printf(« %d\t »,A->info);
} }
41
19/03/2020
42
42
Parcours en largeur
• On explore les noeuds :
– niveau par niveau, – de gauche à droite,
– en commençant par la racine.
19/03/2020
43
Exemple de Parcours
•
• Par application à l’arbre binaire ci-dessus:
43
19/03/2020
44
• en ordre préfixe : on visite un nœud, puis sa
branche de gauche, puis sa branche de droite: 1, 2, 3, 4, 5, 6, 7,8
• en ordre infixe : on visite la branche de gauche, puis le nœud lui-même, puis la branche de droite:
3, 2, 4, 1, 7, 6, 5, 8
• en ordre postfixe (ou sufixe) : on visite la branche de gauche, puis la branche de droite, puis le
nœud lui-même: 3, 4, 2, 7, 6, 8, 5, 1
• Le parcours en largeur 1, 2, 5, 3, 4, 6, 8, 7
44
19/03/2020
45
Arbres binaires de recherche
• Un arbre binaire A est un arbre binaire de recherche si, pour tout nœud s de A, les
contenus des nœuds du sous-arbre gauche de s sont strictement inférieurs au contenu de s, et que les contenus des nœuds du sous-arbre droit de s sont strictement supérieurs au
contenu de s
45
19/03/2020
46
Exemple d’arbre binaire de recherche
•
46
19/03/2020
47
Arbres binaires de recherche
• Dans un arbre binaire de recherche:
• Si un nœud possède un fils gauche, son
prédécesseur dans le parcours infixe est le nœud le plus à droite dans son sous-arbre gauche. Ce nœud n’est pas nécessairement une feuille, mais il n’a pas de fils droit.
• le parcours infixe fournit les contenus des nœuds en ordre croissant.
47
19/03/2020
48
Le type abstrait arbre binaire de recherche
• Le type abstrait arbre binaire de recherche est décrit de la même manière que le type Arbre_Binaire
• On reprend les opérations de base des arbres binaires.
48
19/03/2020
49
Le type abstrait arbre binaire de recherche
• Opérations supplémentaires
• Opérations
• Rechercher : Element×Arbre_rech Arbre_rech
• Minimum : Arbre_rech Arbre_rech
• Insérer : Element×Arbre_rech Arbre_rech
• Supprimer : Element×Arbre_rech Arbre_rech
• Préconditions
Minimum(a) : est défini ssiest_vide(a) = faux
• Axiomes
• Rechercher(e, ArbreVide()) = Arbre_Vide()
• Rechercher(e, cons(r, g, d))
• = cons(r, g, d) si e = contenu(r)
• = Rechercher(e, g) si e ∈g
• = Rechercher(e, d) si e ∈d
• = ArbreVide() sinon 49
19/03/2020
50
Le type abstrait arbre binaire de recherche
• Recherche d’un élément
• Recherche : Element x Arbre_rech -> Arbre_rech
Ajout d’un élément : 2 étapes
• Recherche de la place de l’élément à insérer
• Insertion de l’élément
• Ajouter : Element x Arbre_rech -> Arbre_rech
50
19/03/2020
51
Le type abstrait arbre binaire de recherche
• Suppression d’un élément
• Chercher l’élément
• Supprimer l’élément
• Réorganiser l’arbre
• Supprimer : Element x Arbre_rech -> Arbre_rech
51
19/03/2020
52
Opérations sur les arbres binaires de recherche
• Les opérations spécifiques de ce type d'arbre (en tenant compte du critère d'ordre) sont:
– la recherche d'un élément dans l'arbre ; – l'insertion d'un élément dans l'arbre ; – la suppression d'un élément de l'arbre.
52
19/03/2020
53
La recherche d’un élément
• Principe de la recherche :
• Soit A un arbre binaire de recherche et un élément e – On compare e au contenu de la racine de l'arbre ; – Si e est supérieure au contenu de la racine, on
effectue une recherche dans le fils droit ; – Si e est inférieure au contenu de la racine, on
effectue une recherche dans le fils gauche ; – La recherche s'arrête quand on ne peut plus
continuer (échec) ou quand l'élément cherché est égale au contenu de la racine d'un sous arbre
(succès). 53
19/03/2020
54
La recherche d’un élément Réalisation en C
• Le résultat est le sous-arbre dont l'élément recherché est la racine.
• Version récursive:
• pnoeud recherche(arb_bin A, element e){
if(est_vide(A))return A;
if(e==contenu(A))return A;
if(e<contenu(A))return recherche(A->fg,e);
else return recherche(A->fd,e);
}
54
19/03/2020
55
La recherche d’un élément Réalisation en C
• Version iterative:
• pnoeud recherche(arb_bin A,element e){
• While((!est_vide(A)&&(e!=contenu(A)){
if(e<contenu(A)) A=A->fg;
else A=A->fd;
}
return A;
}
55
19/03/2020
56
L’insértion d’un élément
• L'insertion d'un élément commence par une recherche : on cherche l’élément à insérer ; lorsqu'on arrive à une feuille, on ajoute le
nœud comme fils de la feuille en le comparant au contenu de la feuille : si il est inférieure, le nouveau nœud sera à gauche ; sinon il sera à droite.
56
19/03/2020
57
L’insértion d’un élément Réalisation en C
• pnoeud cree_noeud(element e){
• pnoeud p;
• p=(pnoeud)malloc(sizeof(nœud));
• If (p!=NULL){ p->info=e;
• p->fd=NULL;
• p->fg=NULL;
• }
• return p;
• }
57
19/03/2020
58
L’insértion d’un élément Réalisation en C
• pnoeud pere(element e, arb_bin A){
• if(est_vide(A)) return A;
• if(e<=contenu(A)){
• if(A->fg!=NULL) return pere(e, A->fg);
• return A;}
• else {
• if(A->fd!=NULL) return pere(e, A->fd);
• return A;}
• }
58
19/03/2020
59
L’insértion d’un élément Réalisation en C
• arb_bin ajouter(element e, arb_bin A){
• pnoeud p=pere(e, A);
• pnoeud q=cree_noeud(e);
• if(est_vide(A))A=q;
• else if(p->info<e) p->fd=q;
• else p->fg=q;
• return A;
• }
59
19/03/2020
60
Exemple d’insertion
60
• on insére 31
19/03/2020
61
La suppression d’un élément
• Plusieurs cas sont à considérer, une fois que le nœud à supprimer a été trouvé :
• Suppression d'une feuille : Il suffit de l'enlever de l'arbre vu qu'elle n'a pas de fils.
• Suppression d'un nœud avec un enfant : Il faut l'enlever de l'arbre en le remplaçant par son fils.
• Suppression d'un nœud N avec deux fils: On remplace le contenu de N par celui de son
prédécesseur (le nœud le plus à droite du sous- arbre gauche). Puis on applique à nouveau la procédure de suppression au prédécesseur, qui est un nœud avec un seul fils.
61
19/03/2020
62
Suppression du nœud 17
•
62
19/03/2020
63
Algorithme de suppression d’un élément
Localiser le nœud à supprimer par une recherche récursive.
Une fois le nœud trouvé, il faut distinguer 3 cas:
1. Le nœud est une feuille 2. Le nœud possède un fils;
3. Le nœud possède deux fils.
Cas 1, il suffit de supprimer le nœud.
Cas 2, il suffit de remplacer le nœud à supprimer par son fils.
Cas 3 :
Rechercher la clé maximale dans le sous arbre gauche du nœud à supprimer.
Recopier cet élément dans le nœud à supprimer.
Supprimer le nœud que l’on vient de recopier (cas 2). 63
19/03/2020
64
Algorithme de suppression d’un élément Réalisation en C
• arb_bin max(arb_bin A){
• if(est_vide(A->fd)) return A;
• return max(A->fd);
• }
• arb_bin supprimer(arb_bin A, element e){
• if (est_vide(A)) return A;
• if(e==contenu(A)) return supprime_rac(A);
• if(e<contenu(A)) A->fg=supprimer(A->fg, e);
• else A->fd=supprimer(A->fd, e);
• return A;
• } 64
19/03/2020
65
Algorithme de suppression d’un élément Réalisation en C
• arb_bin supprime_rac(arb_bin A){
• if (est_vide(A->fg)) return A->fd;
• if (est_vide(A->fd)) return A->fg;
• pnoeud f=max(A->fg);
• A-> info = f->info;
• A->fg= supprimer(A->fg, f->info);
• return A;
• }
65
19/03/2020
66
Arbres Maximiers ou Tas (Heaps)
66
19/03/2020
67
Arbre parfait complet
• le dernier niveau est complet car il contient tous les enfants
67
19/03/2020
68
Arbre parfait incomplet
• le dernier niveau est incomplet car il manque 3 enfants, mais ils sont manquant à la droite du niveau, les feuilles sont regroupées à
gauche
68
19/03/2020
69
• Définition
• Un tas est un arbre binaire parfait tel que le contenu de chaque nœud soit supérieur ou égal à celui de ses fils.
• Propriété d’un tas
• Dans un tas, la valeur associée à la racine (donc le premier élément du vecteur) est le maximum de tous les éléments : v[1] v[1..n]. 69
19/03/2020
70
Exemple d’un tas
70
19/03/2020
71
Opérations de base
• insertion d’un nouvel élément
• Trouver le maximum
• Modifier la valeur de la racine
• Supprimer le maximum
71
19/03/2020
72
Représentation par tableau
• On représente un tas à l’aide d’un simple tableau. Les nœuds d’un arbre parfait sont numérotés en largeur, de gauche à droite. Ces numéros sont des indices dans un tableau.
72
19/03/2020
73
Représentation par tableau
•Soit il'indice d'un nœud:
•t[i div2] est le père de t[i] pour i > 1
•t[2 * i] et t[2 * i + 1] sont les deux fils, s'ils existent, de t[i] :
• racine=1
• Parent(i)= i/2
• Fils gauche=2*i
• Fils droit=2*i+1
73
19/03/2020
74
Représentation par tableau
74
19/03/2020
75
insertion
• L’insertion d’un nouvel élément se fait en deux étapes:
• Placer l’élément à insérer dans la première position libre
• Permuter avec le père jusqu’à ce qu’on obtient un tas
75
19/03/2020
76
insertion
• Soit T le tas suivant:
76
19/03/2020
77
• pour insérer la valeur 21 dans le tas T:
• On le place dans la première position libre du tableau (11).
• On le permute avec le père jusqu’à ce qu’à l’obtention d’un tas.
77
19/03/2020
78
insertion
• le tas T après insertion de la valeur 21.
78
19/03/2020
79
• Typedef int element;
• #define N 300
• Typedef struct {element elements[N];
• int nbelem;} cellule;
• Typedef cellule * tas;
79
19/03/2020
80
Réalisation en c de l’insertion
• void Ajouter(element e, tas t)
• {
• int i;
• i= ++(t->nbelem);
• while (i > 0 && t->elements[i /2] < e)
• {
• t->elements[i] = t->elements[i/2];
• i = i /2;
• }
• t->elements[i] = e;
• } 80
19/03/2020
81
Suppression du Maximum
• Principe :
–Remplacer le contenu du nœud racine par le contenu du nœud situé le plus à droite du dernier niveau du tas. Ce dernier nœud est alors supprimé ;
–Réorganiser l'arbre, pour qu'il respecte la définition du tas, en faisant descendre
(fonction descendre) l'élément de la racine à sa bonne place en permutant avec le plus
grand des fils. 81
19/03/2020
82
Suppression du Maximum
• Le tas T après suppression du maximum
82
19/03/2020
83
Suppression du Maximum en c
• void descendre(tas t, int i, int n){
• int k;
• k=2*i;
• if((k<=n)&&(t->elements[k+1]> t->elements[k]))
• k=k+1;
• if((k<=n)&&(t->elements[i]< t->elements[k]))
• { echanger(t, i, k);
• descendre(t, k, n);
• }
• } 83
19/03/2020
84
Algorithme de tri par tas (heapsort)
• On veut trier un vecteur V[1..n]. on décompose ce tri en deux parties :
• *transformation de V pour qu’il vérifie la propriété du tas (la fonction tas_t).
• *utilisation de cette propriété pour trier le vecteur. on les supprime un par un (pour les mettre à droite du tableau (position n, puis n- 1,…). Ceci donne une méthode de tri appelée tri par tas
84
19/03/2020
85
Construction d’un tas Exemple
• Le problème est le suivant : soit un tableau V de n éléments, on souhaite le convertir en tas max.
• L'idée est de placer chacun des noeuds du tableau, à une place qui ne contredira pas la propriété du tas-max. On remarque que les éléments du sous-tableau a [(n/2)+1, .., n]
sont des feuilles donc des tas.
• Chaque feuille vérifie la propriété du tas,
• On commencera donc le parcours par le sous
arbre n div 2 85
19/03/2020
86
Construction d’un tas Exemple
• On va illustrer les différentes étapes de l’algorithme de construction du tas sur un tableau d'entiers contenant 10 éléments:
• V=
• Remarquer que les nœuds qui portent les
valeurs 9, 10, 14, 8 et 7 sont biens des feuilles, et donc des tas à un élément.
86
4 1 3 2 16 9 10 14 8 7
19/03/2020
87
Construction d’un tas Exemple
• Pour transformer V en tas, on commence au sous arbre 5
• i=5 i=4
87
2
14 8
1 16 7
4
3
9 10
1
2 3
4 5 6 7
8 9 10 2
14 8
1 16 7
4
3
9 10
1
2 3
4 5 6 7
8 9 10
19/03/2020
88
Construction d’un tas Exemple
• i=3 i=2
88
14
2 8
1 16 7
4
3
9 10
1
2 3
4 5 6 7
8 9 10 14
2 8
1 16 7
4
10
9 3
1
2 3
4 5 6 7
8 9 10
19/03/2020
89
Construction d’un tas Exemple
• i=1 le tas obtenu
89
14
2 8
16 7 1
4
10
9 3
1
2 3
4 5 6 7
8 9 10
8
2 4
14 7 1
16
10
9 3
1
2 3
4 5 6 7
8 9 10
19/03/2020
90
Construction d’un tas en c
• void tas_t(tas t){
• int i;
• i=(t->nbelem) / 2;
• while(i>0){
• descendre(t, i, t->nbelem);
• i=i-1;
• }
•
• }
90
19/03/2020
91
Tris par tas Exemple
• On souhaite trier le vecteur suivant en utilisant la méthode du tris par tas
• V=[7, 4, 3, 1, 2]
91
19/03/2020
92
92
Tris par tas Exemple
descendre(V, 1, 4) descendre(V, 1, 3)
descendre(V, 1, 2) descendre(V, 1, 1)
19/03/2020
93
93
Tris par tas Exemple
19/03/2020
94
Le tri par tas en c
• void tri_tas(tas t){
• int i;
• tas_t(t);
• i=t->nbelem;
• while(i>0){
• echanger(t, 1, i);
• descendre(t,1,i-1);
• i=i-1;
• }
•
• } 94
