Arbres binaires complets Arbre binaire plein Chaque nud

Arbres binaires complets Arbre binaire plein : Chaque nœud possède 0 ou 2 enfants. Arbre binaire complet: Si la hauteur de l’arbre est d, alors les d-1 premiers niveaux sont complets. Les nœuds du dernier niveau sont tous à gauche.

Théorème des arbres pleins (1) Theorème: Le nombre de feuilles dans un arbre binaire plein est un de plus que le nombre de nœuds internes. Preuve (par induction mathématique): Base: Avec un seul nœud interne, on a deux feuilles. Hypothèse d’induction: Supposons que tous les arbres binaires pleins avec n-1 nœuds internes possèdent n feuilles.

Théorème des arbres pleins (2) Pas d’induction: Étant donné un arbre binaire plein avec n nœuds internes, on choisit un nœud interne I avec 2 enfants. On enlève les enfants de I pour obtenir un arbre T’. Par hypothèse d’induction, T’ est un arbre binaire plein avec n feuilles. Si on replace les deux enfants de I, le nombre de nœuds internes augmente de 1 et le nombre de feuilles augmente de 1.

Arbre binaire complets (1) Position 1 2 3 4 5 6 7 8 9 10 11 -- 0 0 1 1 2 2 3 3 4 4 5 Fils de gauche 1 3 5 7 9 11 -- -- -- Fils de droite 2 4 6 8 10 -- -- Frère gauche Frère droite -- -- 1 --- 2 -- 4 -- 5 -- 7 -- 9 6 -- 8 -- 10 -- --- Parent 0 3 --

Arbre binaire complets(2) Parent (r) = (r-1)/2 si r 0 Leftchild(r) = 2 r+1 si 2 r+1 < n Rightchild(r) = 2 r+2 si 2 r+2 < n Leftsibling(r) = r-1 si r>0 est pair Rightsibling(r) = r+1 si r n est impair

Monceau (heap) Monceau (ou tas): Arbre binaire complet possédant la propriété suivante: • Monceau-min: La valeur d’un nœud est plus petite que la valeur de ses enfants. • Monceau-max: La valeur d’un nœud est plus grande que la valeur de ses enfants. Les valeurs sont partiellement ordonnées. Représentation: Tableau.

Monceau: TDA template<class Elem> class maxheap{ private: Elem* Heap; int size; int n; void siftdown(int); public: maxheap(Elem* h, int num, int max); int heapsize() const; bool is. Leaf(int pos) const; int leftchild(int pos) const; int rightchild(int pos) const; int parent(int pos) const; bool insert(const Elem&); bool removemax(Elem&); bool remove(int, Elem&); void build. Heap(); };

Insérer un élémement template <class Elem> bool maxheap<Elem>: : insert(const Elem& val) { if (n >= size) return false; int curr = n++; Heap[curr] = val; while ( (curr!=0) && (Heap[curr] >= Heap[parent(curr)] ) { swap(Heap, curr, parent(curr)); curr = parent(curr); } return true; }

Enlever la valeur maximum template <class Elem> bool maxheap<Elem>: : removemax(Elem& it) { if (n == 0) return false; swap(Heap, 0, --n); if (n != 0) siftdown(0); it = Heap[n]; return true; }

Siftdown (1) template <class Elem> void maxheap<Elem>: : siftdown(int pos) { while (!is. Leaf(pos)) { int j = leftchild(pos); int rc = rightchild(pos); if ((rc<n) && (Heap[j] Heap[rc])) j = rc; if (Heap[pos] Heap[j]) return; swap(Heap, pos, j); pos = j; } }

Construire le monceau (a) (4 -2) (4 -1) (2 -1) (5 -2) (5 -4) (6 -3) (6 -5) (7 -6) (b) (5 -2), (7 -3), (7 -1), (6 -1)

Siftdown (2)

Coût pour construire un monceau Pour construire le monceau rapidement: – On commence au bas de l’arbre. – On appelle siftdown pour chaque noeud. – Inutile d’appeler siftdown pour les feuilles. log n (i - 1) n/2 i = (n). i=1 car

Tri par monceau (1) template <class Elem> void heapsort(Elem A[], int n) { Elem mval; maxheap<Elem> H(A, n, n); for (int i=0; i<n; i++) H. removemax(mval); }

Tri par monceau (2) template <class Elem> void sort(Elem* array, int n) { heapsort<Elem>(array, n); } Temps: (n log n)