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. These terms can be hard to distinguish. Students will need to remember which is which, since this notation will be used several times during the course.

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. This theorem is important, because it helps us to calculate space requirements. It tells us how many nodes are internal and how many are leaf. We need to know this if we have separate implementations for internal and leaf nodes

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) -- 10 8 6 4 2 Frère droite 9 7 5 3 1 Frère gauche Fils de droite 11 Fils de gauche Parent Position This is a good example of logical representation vs. physical implementation. Since the complete binary tree is so limited in its shape (there is only one possible shape for n nodes), it is reasonable to expect that space efficiency can be achieved.

Arbre binaire complets(2) Parent (r) = (r-1)/2 si r0 Leftchild(r) = 2r+1 si 2r+1 < n Rightchild(r) = 2r+2 si 2r+2 < n Leftsibling(r) = r-1 si r>0 est pair Rightsibling(r) = r+1 si rn est impair Parent(r) = (r-1)/2 if r <> 0 and r < n. Leftchild(r) = 2r + 1 if 2r + 1 < n. Rightchild(r) = 2r + 2 if 2r + 2 < n. Leftsibling(r) = r - 1 if r is even, r > 0, and r < n. Rightsibling(r) = r + 1 if r is odd and r + 1 < n.

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 isLeaf(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 buildHeap(); };

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 (!isLeaf(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-5) (7-6) (b) (5-2), (7-3), (7-1), (6-1) How to get a good number of exchanges? Induction leads to the following algorithm: Heapify the root’s subtrees, then push the root to the correct level.

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/2i = (n). i=1 car (i-1) is number of steps down, n/2i is number of nodes at that level.

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)