struct_cours6

Type abstrait Implantation Arbres modifiables Extensions

Conception de structures de donnees

Cours 6

Arbres binaires

22 avril 2013

Struct 1/30


Pourquoi les arbres ?

Struct 2/30


Pourquoi les arbres ?

Structure de donnees omnipresente en Informatique :

structure naturelle : arbre de decision, tournoi, genealogie,arborescence des repertoires, expressions arithmetiques, ...

en algorithmique du texte (Huffamn, prefix-trees) :compression, recherche de motifs, detection de repetitions, ...

en geometrie algorithmique (quadtrees, octrees, KD-trees,arbres rouge-noir, ...) ;

en linguistique et en compilation (arbres syntaxiques) ;

pour la gestion du cache, les bases de donnees, les systemesde fichiers, ... (B-trees,).

Struct 2/30


Definition des arbres BINAIRES

Un arbre binaire est une structure permettant de stockerune collection de donnees de meme type.

Definition recursive : un arbre binaire est :

soit vide,soit un noeud contenant une donnee et ayant 2 fils (gauche etdroit) qui sont eux-memes des arbres binaires.

L’espace memoire utilise par un arbre n’est pas contigu.

La taille d’un arbre est inconnue a priori ;

Un arbre binaire est constitue de noeuds qui sont lies entreeux par des pointeurs. On ne peut acceder directement qu’au1er element (la racine) de l’arbre.

Pour acceder a un element quelconque d’un arbre , il fautdescendre dans l’arbre jusqu’a cet element.

! ! ! Un arbre n’est PAS une structure LINEAIRE ! ! !

Struct 3/30


Representation graphique d’un arbre binaire

3

1 8

1 29 170

2 48

Struct 4/30


Arbres binaires recursifs

Struct 5/30


Type abstrait : BTree

typedef ... BTree;

BTree makeEmptyBTree(void); // renvoie un arbre vide

int isEmptyBTree(BTree bt); // teste si l’arbre est vide

BTree makeNode(Element e, Btree l, Btree r);

// renvoie un arbre de racine e ayant l et r pour fils gauche et droit

Element root(BTree bt); // renvoie l’element a la racine de l’arbre

BTree leftChild(BTree bt); // renvoie le fils gauche de l’arbre

BTree rightChild(BTree bt); // renvoie le fils droit de l’arbre

BTree makeLeaf(Element e); // renvoie une feuille contenant l’element e

int isLeaf(BTree bt); // teste si bt est une feuille

void freeNode(Btree bt); // libere l’espace occupe par la racine de bt

Struct 6/30


Ecrire une fonction recursive sur les arbres.

Fonction recursive fonctionRec sur une arbre (bt) :

Cas de base :

isEmptyBTree(bt) /* arbre vide */

isLeaf(bt) /* arbre reduit a une feuille */

Cas general (recursif) : resoudre le probleme sur des arbres pluspetits (les sous-arbres gauche et droit) et combiner les solutions.

fonctionRec(leftChild(bt))

fonctionRec(rightChild(bt))

/* combiner les deux (eventuellement avec la racine)*/

Struct 7/30


Exemples

Calculer la taille (nombre de noeuds) de l’arbre ;

Liberer l’espace memoire occupe par l’arbre ;

Afficher l’arbre ;

Renvoyer la liste des feuilles de l’arbre ;

Calculer la hauteur, la somme des elements, la longueur decheminement, le nombre de Strahler ...

Compter le nombre de noeuds (ou de feuilles) a hauteur k,

Tester l’egalite, l’isomorphisme, l’inclusion de 2 arbres, ...

Fabriquer une copie ou le miroir d’un arbre, ...

Chercher un element quelconque, le min (ou max), lepremier ancetre commun de 2 noeuds, ...

Struct 8/30


Les fonctions size et freeBTree

int size(BTree bt){

if(isEmptyBTree(bt))

return 0;

else return 1+size(leftChild(bt))+size(rightChild(bt));

}

void freeBTreeRec(BTree bt){ /* fonction recursive */

if(!isEmptyBTree(bt)){

BTree l=leftChild(bt); /* liens vers les fils */

BTree r=rightChild(bt);

freeNode(bt); /* liberer le noeud */

freeBTreeRec(l); /* liberer les fils recursivement */

freeBTreeRec(r);

}

}

/* fonction non recursive */

void freeBTree(BTree *bt){ freeBTreeRec(*bt); *bt= NULL;}

Struct 9/30


La fonction printBTree

void shift(int n){

int i;

for(i = 0;i < n;i++)

printf("\t");

}

void printBTree(BTree bt, int level){

if ( !isEmptyBTree(bt) ) {

printBTree( rightChild(bt), level+1 );

shift(level);

printf("%d\n", root(bt));

printBTree( leftChild(bt), level+1 );

}

}

Struct 10/30


La fonction listOfLeaves

/* concatenation de 2 listes */

Rlist append(Rlist l1, Rlist l2){ ... }

Rlist listOfLeaves(BTree bt){

if( isEmptyBTree(bt) )

return newEmptyRlist();

else

if( isLeaf(bt) )

return cons( root(bt) , newEmptyRlist() );

else{

Rlist ll=listOfLeaves( leftChild(bt) );

Rlist lr=listOfLeaves( rightChild(bt) );

} return append( ll , lr );

}

Struct 11/30


Parcourir un arbre en profondeur

La structure d’arbre n’impose pas un ordre total sur leselements, or on voudrait avoir un ordre sur ces elements.Pour cela, on fixe une methode de parcours de l’arbre qui trieles elements par orde de visite.

11

87

101 5

0 6 2

9

3

4

Struct 12/30


Parcours prefixe (la racine en 1er)

11

87

101 5

0 6 2

9

3

4

Struct 13/30



11

87

101 5

0 6 2

9

3

4 11

Struct 13/30



11

87

101 5

0 6 2

9

3

4 11 7

Struct 13/30



11

87

101 5

0 6 2

9

3

4 11 7 1

Struct 13/30



11

87

101 5

0 6 2

9

3

4 11 7 1 0

Struct 13/30



11

87

101 5

0 6 2

9

3

4 11 7 1 0 3

Struct 13/30



11

87

101 5

0 6 2

9

3

4 11 7 1 0 3 4

Struct 13/30



11

87

101 5

0 6 2

9

3

4 11 7 1 0 3 4 5

Struct 13/30



11

87

101 5

0 6 2

9

3

4 11 7 1 0 3 4 5 6

Struct 13/30



11

87

101 5

0 6 2

9

3

4 11 7 1 0 3 4 5 6 8

Struct 13/30



11

87

101 5

0 6 2

9

3

4 11 7 1 0 3 4 5 6 8 9

Struct 13/30



11

87

101 5

0 6 2

9

3

4 11 7 1 0 3 4 5 6 8 9 10

Struct 13/30



11

87

101 5

0 6 2

9

3

4 11 7 1 0 3 4 5 6 8 9 10 2

Struct 13/30


Parcours infixe (la racine au milieu)

11

87

101 5

0 6 2

9

3

4

Struct 14/30


Parcours infixe (la racine au milieu)

11

87

101 5

0 6 2

9

3

4 0 1 3 4 7 6 5 11 9 8 10 2

Struct 14/30


Parcours postfixe (la racine en dernier)

11

87

101 5

0 6 2

9

3

4

Struct 15/30


Parcours postfixe (la racine en dernier)

0 4 3 1 6 5 7 9 2 10 8 11

11

87

101 5

0 6 2

9

3

4

Struct 15/30


Les 3 fonctions de parcours

void printPrefixOrder(BTree bt){


printf("%d ",root(bt));

printPrefixOrder(leftChild(bt));

printPrefixOrder(rightChild(bt));

}

}

void printInfixOrder(BTree bt){


printInfixOrder(leftChild(bt));

printf("%d ",root(bt));

printInfixOrder(rightChild(bt));

}

}

void printPostfixOrder(BTree bt){ ... }

Et une version iterative ? Et le parcours en largeur ?

Struct 16/30


Arbres binaires en C

Struct 17/30


Definition d’un arbre binaire en C

arbre vide:

3

1 8

1 29 170

2 48

arbre contenant 8 éléments

Struct 18/30


Definition d’un arbre binaire en C (suite)

typedef int Element;

typedef struct node{

Element elem;

struct node *left;

struct node *right;

}Node;

typedef Node *BTree;

BTree makeEmptyBTree(void){

return (BTree)NULL;

}

int isEmptyBTree(BTree bt){

return (bt==NULL);

}

Struct 19/30



BTree makeNode(Element e, BTree l, BTree r){

BTree new;

if ((new=(BTree)malloc(sizeof(Node)))==NULL)

erreur("Allocation ratee!");

new->elem=e;

new->left=l;

new->right=r;

return new;

}

BTree makeLeaf(Element e){return makeNode(e,makeEmptyBTree(),makeEmptyBTree());

}

Element root(BTree bt){

if(isEmptyBTree(bt))

erreur("Pas de noeud a la racine!");

return bt->elem;

}

Struct 20/30



BTree leftChild(BTree bt){

if(isEmptyBTree(bt)) erreur("Pas de fils gauche!");

return bt->left;

}

BTree rightChild(BTree bt){

if(isEmptyBTree(bt)) erreur("Pas de fils droit!");

return bt->right;

}

int isLeaf(BTree bt){return !isEmptyBTree(bt) &&

isEmptyBTree(leftChild(bt)) &&

isEmptyBTree(rightChild(bt));

}

void freeNode(Node *c){

free(c);

}

Struct 21/30


Arbres binaires modifiables

Struct 22/30


Quelques fonctions de modification

Fonctions “bas niveau” pour inserer ou supprimer des elementsdans un arbre :

void insertRight(Node *n, Element e);

void insertLeft(Node *n, Element e);

Element deleteRight(Node *n);

Element deleteLeft(Node *n);

void insertRightmostNode(BTree *bt, Element e);

void insertLeftmostNode(BTree *bt, Element e);

Element deleteRightmostNode(BTree *bt);

Element deleteLeftmostNode(BTree *bt);

Attention : ces fonctions modifient les arbres ;elles ne fabriquent pas des copies !

Struct 23/30



void insertRight(Node *n, Element e){

if(!isEmptyBTree(n) && isEmptyBTree(rightChild(n)))

n->right=makeLeaf(e);

else erreur("insertRight impossible!");

}

void insertLeft(Node *n, Element e){

if(!isEmptyBTree(n) && isEmptyBTree(leftChild(n)))

n->left=makeLeaf(e);

else erreur("insertLeft impossible!");

}

Element deleteRight(Node *n){

if(isEmptyBTree(n) || !isLeaf(rightChild(n)))

erreur("deleteRight imossible!");

Element res=root(n->right);

n->right=makeEmptyBTree();

return res;

}

Struct 24/30



Element deleteLeft(Node *n){

if(isEmptyBTree(n) || !isLeaf(leftChild(n)))

erreur("deleteLeft imossible!");

Element res=root(n->left);

n->left=makeEmptyBTree();

return res;

}

void insertRightmostNode(BTree *bt, Element e){

if(isEmptyBTree(*bt))

*bt=makeLeaf(e);

else{

BTree tmp=*bt;

while(!isEmptyBTree(rightChild(tmp)))

tmp=rightChild(tmp);

insertRight(tmp,e);

}

}

Struct 25/30



Element deleteLeftmostNode(BTree *bt){

Element res;

if(isEmptyBTree(*bt))

erreur("deleteLeftmostNode imossible!");

if(isEmptyBTree(leftChild(*bt))){

res=root(*bt);

*bt=rightChild(*bt);

}

else{

BTree tmp=*bt;

while(!isEmptyBTree(leftChild(leftChild(tmp))))

tmp=leftChild(tmp);

res=root(leftChild(tmp));

tmp->left=(tmp->left)->right;

}

return res;

}

Struct 26/30


Extensions

Struct 27/30


Extensions

Problemes avec les arbres binaires (a n noeuds) :

Chercher un element coute cher : O(n) ;

Inserer un element (pas n’importe ou !) : O(n) ;

Supprimer un element : on ne peut pas toujours...

Solution ? Ordonner (trier) les elements dans l’arbre...

Un arbre binaire de recherche (BST) est :

soit vide,

soit un noeud :

contenant une donnee (la racine),dont le fils gauche est un BST dontles elements sont inferieurs a la racine,dont le fils droit est un BST dontles elements sont superieurs a la racine.

8

105

111 7

0 6

3

9

2

4

Struct 28/30


Extensions (suite)

Arbre binaire equilibre (AVL) : les hauteurs des deux sous-arbres d’un meme noeud different au plus de 1.

8

105

111 7

0 6

3

9

2

4

BST (pas AVL)

7

94

101 6

0 5 11

8

2

3

AVL

Difficulte : conserver l’equilibrage. Gain : meilleure complexite !

Struct 29/30


Extensions - fin

Un arbre general (chaque noeud a une liste de fils :)

8

63

1113 1

0 1814

10

5

4

7

1512

169

2

Struct 30/30

struct_cours6

Documents

Transcript of struct_cours6