Vous êtes sur la page 1sur 1

ARBES

Arit: max ocuk says // Profondeur


Hauteur
Complet:nocuklu prf<h
Lineaire:feuille hari 1 fils
Parfait: nocuklu prf<h-1 ve fazlalar
fils solda
Equilibr: n sousarben fils says +1 eit olmal
Binaire:0,1,2/entiere:0,2 /parfait:
0,2 hlar eit

if(valeur==v) resultat = 1;
else {
if(valeur>v)
{ fils_gauche(a,&g);
resultat =
recherche(g, v); }
else { fils_droit(a,&d);
resultat = recherche(d,
v); }
}
} return resultat; }

Implementation par pointeur


typedef struct s_noeud { int valeur ;
struct s_noeud *gauche;
struct s_noeud *droit; } noeud;
typedef noeud* arbre;

MIN- MAX
int minimum(arbre a, arbre *m) {
int erreur=0; arbre g;
if(est_vide(a)) erreur=-1;
else { fils_gauche(a,&g); If
(est_vide(g)) *m=a;
else
minimum(g,m); } return erreur; }
int maximum(arbre a, arbre *m) {
int erreur=0; arbre d;
if(est_vide(a)) erreur=-1;
else { fils_droit(a,&d); if (est_vide(d))
*m=a;
else
maximum(d,m); } return erreur; }

arbre cree_arbre() { return NULL; }


int est_vide(arbre a) { return (a ==
NULL);}
ACCES:int racine(arbre a, int *r) {int
erreur = 0;
if(est_vide(a)) erreur = -1;
else *r = a->valeur;
return
erreur; }
int fils_gauche(arbre a, arbre *f) {
nt erreur = 0;
if(est_vide(a)) erreur = -1;
else *f = a->gauche;
}

return erreur;

INSERTION:
arbre enracine(int v, arbre a1, arbre
a2) { noeud *n;
if((n = (noeud *)
malloc(sizeof(noeud))) != NULL) {
n->valeur = v; n->gauche = a1;
n->droit = a2; } return n; }
ARBRE BINAIRE DE RECHERCHE
PARCOURS
Prfix:racine-gauche-droit
Suffix: gauche-droit-racine
nfix: gauche-racine-droit
Implmentation par pointeur:
RECHERCHE
int recherche(arbre a, int v) {
int resultat=0,valeur; arbre g,d;
if(!est_vide(a)) { racine(a,&valeur);

Successeur et prdcesseur
int predecesseur(arbre a, arbre *p) {
int erreur=0; arbre g;
if(est_vide(a)) erreur=-1;
else{fils_gauche(a,&g);if(est_vide(g))e
rreur=-1;
else
maximum(g,p); }
return erreur; }
int successeur(arbre a, arbre *s) {
int erreur=0; arbre d;
if(est_vide(a)) erreur=-1;
else { fils_droit(a,&d); if(est_vide(d))
erreur=-1;
else
minimum(d,s); } return erreur; }
Insertion
int insere(arbre *a, int v) {
int valeur,erreur=0; arbre g,d;

if(est_vide(*a))
*a=enracine(v,cree_arbre(),
cree_arbre());
else { racine(*a,&valeur);
fils_gauche(*a,&g);
fils_droit(*a,&d);
if(v<valeur) { insere(&g, v);
*a =enracine(valeur,g,d);}
else {
if(valeur<v) { insere(&d,
v);
*a =
enracine(valeur,g,d); }
else erreur=-1;}
} return erreur; }

Suppression
int supprime(arbre *a, int v) {
int erreur=0,valeur,valtemp; arbre
g,d,temp;
if(est_vide(*a)) erreur=-1;
else { racine(*a,&valeur);
fils_gauche(*a,&g);
fils_droit(*a,&d);
if(v<valeur)
{ supprime(&d,v);
*a =
enracine(valeur,g,d); }
else if(v>valeur)
{ supprime(&d,v);
*a =
enracine(valeur,g,d); }
else {
if(est_vide(g)) {
if(est_vide(d)) {
free(*a);*a=cree_arbre(); }
else { temp=*a;
*a = d;
free(temp); }
}else {

if(est_vide(d))
{ temp=*a;
*a = g;
free(temp); }
else{ redecesseur(*a,&temp);
racine(temp,&valtemp);
supprime(&g,valtemp);
*a =
enracine(valtemp,g,d); }
}
}
} return erreur; }
ARBES AVL
FE=hg-hd 1,0,1
Avec n sommet :log(1+n) 1+ h
log(2 + n)
Toujours n 2 h+1 - 1 donc
log(1+n) 1+ h
Nmbr min desommet N(h) = 1 + N(h1) + N(h-2)
LES B-ARBES chaque noeud
contient balises
b = 2a -1, arbre a-b appel:b-arbre
d'ordre a-1
Si arbre a-b,hauteur h avec n
feuilles, alors
h-1

2a n b donc logn/logb
h1+log(n/2)/loga