Data Structure Chapter 5. Binary Trees

Transcription

1 ata Structure hapter 5 Binary Trees r. Patrick han School of omputer Science and Engineering South hina University of Technology Outline Recursion (h.4) Binary Trees (h 5) Introduction (h 5.) Traversal (h 5.) Implementation (h 5.) Binary Search Trees (h 5.4) Priority Queues and Heaps (h 5.5) Huffman oding Trees (h 5.6)

2 Recursion A recursion is a procedure which calls itself The recursive procedure call must use different arguments from the original one Otherwise the procedure would always get into an infinite loop Recursion ans = 4 Example: Factorial function n! = n (n-) f ( n) = n f ( n ) if n = else 4 * factorial() factorial()=6 * factorial() factorial()= * factorial() factorial()= factorial(4) factorial() factorial() int factorial(int n) { if (n == ) return ; else return n * factorial(n-); * factorial() factorial()= factorial() factorial() 4

3 Recursion int factorial(int n) { if (n == ) return ; else return n * factorial(n-); factorial(4) factorial() factorial() factorial() factorial() Recursive all alls to the current method Each recursive call should be defined so that it makes progress towards a base case Base ase Values of the input variables for which we perform no recursive calls are called base cases At least one base case Every possible chain of recursive calls must eventually reach a base case 5 Recursion Example has two Recursive alls p( x, n) = x p( x,( n ) / ) p( x, n / ) if x= if x> is odd if x> is even 4 = (4/)* = ( 4/ ) = ( ) = 4 = 6 5 = +(4/)* = ( 4/ ) = ( ) = (4 ) = 6 = (6/ )* = ( 6/ ) = ( ) = 8 = 64 = +(6/)* = ( 6/ ) = ( ) = (8 ) = 8 int power(int x, int n) { if (n == ) return ; if (n % == ) { y = Power(x, (n - )/); return x * y * y; else { y = Power(x, n/); return y y; Base ase Recursive all It is important that we used a variable twice here rather than calling the method twice 6

4 Recursion Tower of Hanoi A B Recursion: Tower of Hanoi More than steps Break own Recursive all More than steps More than steps Recursive all step 8

5 Recursion: Tower of Hanoi More than steps Break own Recursive all More than steps More than steps Recursive all step 9 Recursion: Tower of Hanoi More than steps Break own Base ase Base ase step step step

6 Recursion: Tower of Hanoi The solution Recursion: Tower of Hanoi Solution: void solvetowers(int count, char source, char destination, char spare) { if (count == ) { cout << "Move top disk from pole " << source << " to pole " << destination); else { solvetowers(count-, source, spare, destination); // Left solvetowers(, source, destination, spare); // step solvetowers(count-, spare, destination, source); // Right // end if // end solvetowers

7 Recursion: Observation : Same Algorithm Break down the problem into smaller parts and eventually reach a base case Binary Tree: Introduction A binary tree is made up of a finite set of nodes that is either empty or consists of a node called the root together with two binary trees which are disjoint from each other and from the root A B E F H G I J 4

8 Binary Tree: Introduction Root epth: Level: Parent of V R Ancestors of V Internal Node epth: Level: epth: Level: epth: Level: Sibling of V H Subtree rooted at V P G V F B Edge Leaf Node escendants of V epth: 4 Level: 4 Height is 5 hildren of V J 5 Binary Tree Full binary tree Each node being either Leaf Internal node with exactly two non-empty children B F A E H B B A E H F G A 6

9 Binary Tree A omplete binary tree If the height of the tree is d, then all levels except possibly level d- are completely full The bottom level has all nodes filled in from the left side A T A B B H E H E T J I G Binary Tree Full Binary Tree Theorem Theorem The number of leaves in a non-empty full binary tree is one more than the number of internal nodes A H E A Leaves 4 Internal Nodes T B B F E H G Leaves 5 Internal Nodes 4 I H 8

10 Binary Tree Full Binary Tree Theorem Theorem The number of null pointers in a non-empty binary tree is one more than the number of nodes in the tree A H E A T B Leaves 4 Internal Nodes Null Pointers Nodes 4 x = = B F E H G H Leaves 5 Internal Nodes 4 Null Pointers Nodes 5 x = = 9 I 9 Binary Tree: Node AT Template <class Elem> class BinNode { public: virtual Elem& val( ) =; virtual BinNode* left( ) const = ; virtual BinNode* right( ) const = ; virtual void setval( const Elem& ) = ; virtual void setleft( BinNode* ) = ; virtual void setright( BinNode* ) = ; virtual bool isleaf( ) = ; B A E H F G I J

11 Binary Tree: Node // Binary tree node class template <class Elem> class BinNodePtr : public BinNode<Elem> { private: Elem it; // The node's value BinNodePtr* lc; // Pointer to left child BinNodePtr* rc; // Pointer to right child public: BinNodePtr() { lc = rc = ; BinNodePtr(Elem e, BinNodePtr* l=, BinNodePtr* r=) { it = e; lc = l; rc = r; Elem& val() { return it; void setval(const Elem& e) { it = e; inline BinNode<Elem>* left() const { return lc; void setleft(binnode<elem>* b) { lc = (BinNodePtr*)b; inline BinNode<Elem>* right() const { return rc; void setright(binnode<elem>* b) { rc = (BinNodePtr*)b; BinNodePtr anode(); bool isleaf() { return (lc == ) && (rc == ); ; Binary Tree: Traversals Traversal is a process for visiting the nodes in some order Any traversal that lists every node in the tree exactly once is called an enumeration of the tree s nodes A B E H F G I J

12 Binary Tree: Traversals Preorder traversal Visit each node before visiting its children A B E F G H I J Postorder traversal Visit each node after visiting its children B F G E J I H A Inorder traversal Visit the left subtree, then the node, then the right subtree B A F E G I J H A B E H F G I J Binary Tree: Traversals Preorder traversal Visit each node before visiting its children Postorder traversal Visit each node after visiting its children Inorder traversal Visit the left subtree, then the node, then the right subtree template <class Elem> void preorder(binnode<elem>* subroot) { if (subroot == ) return; // Empty visit(subroot); // Perform some actions preorder(subroot->left()); // left preorder(subroot->right()); // right template <class Elem> void postorder(binnode<elem>* subroot) { if (subroot == ) return; // Empty postorder(subroot->left()); // left postorder(subroot->right()); // right visit(subroot); // Perform some actions template <class Elem> void inorder(binnode<elem>* subroot) { if (subroot == ) return; // Empty inorder(subroot->left()); // left visit(subroot); // Perform some actions inorder(subroot->right()); // right 4

13 Binary Tree: Traversals Which one is better? B A () template <class Elem> void preorder(binnode<elem>* subroot) { if (subroot == ) return; // Empty F visit(subroot); // Perform some action preorder(subroot->lc()); preorder(subroot->rc()); check if the tree is empty at first E H G I J () template <class Elem> void preorder(binnode<elem>* subroot) { visit(subroot); // Perform some action if (subroot->left()!= ) preorder(subroot->lc()); if (subroot->right()!= ) preorder(subroot->rc()); check if the right and left point are empty 5 Binary Tree: Traversals Which one is better? Advantage of ase Reduce half recursive calls (refer to Theorem in slide 9) Advantage of ase Only one base case checking For complex traversals, checking criteria may be very complicated Avoid the bugs E.g. the initial call passes an empty tree ase should be used B A E H F G I J 6

14 Binary Tree ifferent Leafs & Internal Nodes Each node stores the same kind of data A Internal nodes and leaves store different types of data - B * c F * + G H 4 x * a x 4x(x+a) -c Binary Tree ifferent Leafs & Internal Nodes Three implementation methods Union Inheritance Inheritance with virtual function 8

15 Binary Tree: ifferent Leafs & Internal Nodes Union Implementation enum Nodetype {leaf, internal; class VarBinNode { // Generic node class public: Nodetype mytype; // Store type for node union { struct { // Internal node VarBinNode* left; // Left child VarBinNode* right; // Right child Operator opx; // Value intl; Operand var; ; // Leaf constructor VarBinNode(const Operand& val) { mytype = leaf; var = val; // Internal node constructor // Leaf: Value only Indicate if it is an internal node or a leaf Two types of information Two different constructor VarBinNode(const Operator& op, VarBinNode* l, VarBinNode* r) { mytype = internal; intl.opx = op; intl.left = l; intl.right = r; bool isleaf() { return mytype == leaf; VarBinNode* leftchild() { return intl.left; VarBinNode* rightchild() { return intl.right; ; 9 Binary Tree: ifferent Leafs & Internal Nodes Union Implementation // Preorder traversal void traverse(varbinnode* subroot) { if (subroot == ) return; if (subroot->isleaf()) cout << "Leaf: << subroot->var << "endl"; else { cout << "Internal: << subroot->intl.opx << "endl"; traverse(subroot->leftchild()); traverse(subroot->rightchild()); isadvantage A node is total sizes for leaf and internal node

16 Binary Tree: ifferent Leafs & Internal Nodes Inheritance Implementation class VarBinNode { // Abstract base class public: virtual bool isleaf() = ; ; class LeafNode : public VarBinNode { // Leaf private: Operand var; // Operand value public: LeafNode(const Operand& val) { var = val; // onstructor bool isleaf() { return true; Operand value() { return var; ; class IntlNode : public VarBinNode { // Internal node private: VarBinNode* left; // Left child VarBinNode* right; // Right child Operator opx; // Operator value public: IntlNode(const Operator& op, VarBinNode* l, VarBinNode* r) { opx = op; left = l; right = r; bool isleaf() { return false; VarBinNode* leftchild() { return left; VarBinNode* rightchild() { return right; Operator value() { return opx; ; Binary Tree: ifferent Leafs & Internal Nodes Inheritance Implementation void traverse(varbinnode *subroot) { // Preorder traversal if (subroot == ) return; // Empty if (subroot->isleaf()) // o leaf node cout << "Leaf: " << ((LeafNode *)subroot)->value() << endl; else { // o internal node cout << "Internal: " << ((IntlNode *)subroot)->value() << endl; traverse(((intlnode *)subroot)->leftchild()); traverse(((intlnode *)subroot)->rightchild()); isadvantage The traverse is still complicated (if-then-else is used)

17 Binary Tree: ifferent Leafs & Internal Nodes Inheritance with virtual function class VarBinNode { // Abstract base class public: virtual bool isleaf() = ; virtual void trav() = ; ; class LeafNode : public VarBinNode { // Leaf private: Operand var; // Operand value public: LeafNode(const Operand& val) { var = val; // onstructor bool isleaf() { return true; Operand value() { return var; void trav() { cout << "Leaf: " << value() << endl; ; Binary Tree: ifferent Leafs & Internal Nodes Inheritance with virtual function class IntlNode : public VarBinNode { private: VarBinNode* lc; // Left child VarBinNode* rc; // Right child Operator opx; // Operator value public: IntlNode(const Operator& op, VarBinNode* l, VarBinNode* r) { opx = op; lc = l; rc = r; bool isleaf() { return false; VarBinNode* left() { return lc; VarBinNode* right() { return rc; Operator value() { return opx; void trav() { cout << "Internal: " << value() << endl; if (left()!= ) left()->trav(); if (right()!= ) right()->trav(); ; 4

18 Binary Tree: ifferent Leafs & Internal Nodes Inheritance with virtual function // Preorder traversal void traverse(varbinnode *root) { if (root!= ) root->trav(); omparisons Inheritance Implementation Easily to add new methods to the tree class that traverse the tree Inheritance with virtual function More preferred if the internal behavior of the nodes should be hided 5 Binary Tree Space Requirements Overhead Space Amount of space necessary to maintain the data structure i.e any space not used to store the data records Overhead Fraction Amount of overhead space divided by amount of total space used 6

19 Binary Tree Space Requirements Example Full tree with all nodes are the same (two pointers to children and one element): Total space required: n(p + d) n: number of nodes p: the amount of space required by a pointer d: the amount of space required by a data value Overhead Space: pn Overhead Fraction: p / (p + d) If p = d, it means / of total space is taken up in overhead Small Quiz!!!! Q. Write a recursive function that returns the height of a binary tree template <class Elem> int findheight(binnode<elem>* subroot){... if (subroot == ) return ; // Empty subtree return + max(height(subroot->left()), height(subroot->right())); A B E H F G 8

20 Small Quiz!!!! Q. Write a recursive function that search value K in a binary tree. The function returns true if value K is exist template <class Key, class Elem, class KEomp> bool search(binnode<elem>* subroot, Key K){... if (subroot == ) return false; if (subroot->value() == K) return true; elseif (search(subroot->left())) return true; else return search(subroot->right()); B A E H F G 9 Binary Search Trees Binary Search Tree (BST) is a special case of Binary Tree All elements stored in the left subtree of a node with value K have values < K All elements stored in the right subtree of a node with value K have values >= K

21 Binary Search Trees: AT // BST implementation for the ictionary AT template <class Key, class Elem, class KEomp, class EEomp> class BST : public ictionary<key, Elem,KEomp, EEomp> { private: BinNode<Elem>* root; // Root of the BST int nodecount; // Number of nodes void clearhelp(binnode<elem>*); BinNode<Elem>* inserthelp(binnode<elem>*, const Elem&); BinNode<Elem>* deletemin(binnode<elem>*,binnode<elem>*&); BinNode<Elem>* removehelp (BinNode<Elem>*,const Key&,BinNode<Elem>*&); bool findhelp(binnode<elem>*, const Key&,Elem&) const; void printhelp(binnode<elem>*, int) const; public: BST() { root = ; nodecount = ; ~BST() { clearhelp(root); void clear() { clearhelp(root); root = ; nodecount = ; 4 Binary Search Trees: AT bool insert(const Elem& e) { root = inserthelp(root, e); nodecount++; return true; bool remove(const Key& K, Elem& e) { BinNode<Elem>* t = ; root = removehelp(root, K, t); if (t == ) return false; e = t->val(); nodecount; delete t; return true; 4

22 Binary Search Trees: AT bool removeany(elem& e) { // elete min value if (root == ) return false; // Empty BinNode<Elem>* t; root = deletemin(root, t); e = t->val(); delete t; nodecount; return true; bool find(const Key& K, Elem& e) const { return findhelp(root, K, e); int size() { return nodecount; void print() const { if (root == ) cout << "The BST is empty.\n"; else printhelp(root, ); 4 Binary Search Trees: AT inserthelp function template <class Key, class Elem, class KEomp, class EEomp> BinNode<Elem>* BST<Key,Elem,KEomp,EEomp>:: inserthelp( BinNode<Elem>* subroot, const Elem& val ) { root if (subroot == ) // Empty: create node return new BinNodePtr<Elem>(val,,); if (EEomp::lt(val, subroot->val())) subroot->setleft(inserthelp(subroot->left(), val)); else subroot->setright(inserthelp(subroot->right(), val)); return subroot; // Return subtree with node inserted subtree= B R R Return bool insert(const Elem& e) { root = inserthelp(root, e); nodecount++; return true; Base ase root=inserthelp(root,); root Recursive all Recursive all 44

23 Binary Search Trees: AT inserthelp function template <class Key, class Elem, class KEomp, class EEomp> BinNode<Elem>* BST<Key,Elem,KEomp,EEomp>:: inserthelp( BinNode<Elem>* subroot, const Elem& val ) { root root if (subroot == ) // Empty: create node return new BinNodePtr<Elem>(val,,); if (EEomp::lt(val, subroot->val())) subroot->setleft(inserthelp(subroot->left(), val)); else subroot->setright(inserthelp(subroot->right(), val)); return subroot; // Return subtree with node inserted subtree= subtree= B R R Return.L B R R Return root=inserthelp(root,); root=inserthelp(root,); bool insert(const Elem& e) { root = inserthelp(root, e); nodecount++; return true; Base ase root Recursive all Recursive all 45 Binary Search Trees: AT inserthelp function template <class Key, class Elem, class KEomp, class EEomp> BinNode<Elem>* BST<Key,Elem,KEomp,EEomp>:: inserthelp( BinNode<Elem>* subroot, const Elem& val ) { root root if (subroot == ) // Empty: create node return new BinNodePtr<Elem>(val,,); if (EEomp::lt(val, subroot->val())) subroot->setleft(inserthelp(subroot->left(), val)); else subroot->setright(inserthelp(subroot->right(), val)); return subroot; // Return subtree with node inserted subtree= B R R Return.L subtree= B R R Return root=inserthelp(root,); root=inserthelp(root,); root=inserthelp(root,9);.r 9 subtree= B R R Return bool insert(const Elem& e) { root = inserthelp(root, e); nodecount++; return true; Base ase root Recursive all Recursive all 9 46

24 Binary Search Trees: AT deletemin function template <class Key, class Elem, class KEomp, class EEomp> BinNode<Elem>* BST<Key, Elem, KEomp, EEomp>:: deletemin(binnode<elem>* subroot, BinNode<Elem>*& min) { if (subroot->left() == ) { root min = subroot; return subroot->right(); else { root Base ase // ontinue left subroot->setleft( deletemin(subroot->left(), min)); return subroot; subtree= subtree= B R.L.R (9) B R Recursive all root=deletemin(root,amin); amin root 9 4 bool remove(const Key& K, Elem& e) { BinNode<Elem>* t = ; Binary Search Trees: AT root = removehelp(root, K, t); if (t == ) return false; e = t->val(); nodecount; delete t; removehelp function return true; template <class Key, class Elem, class KEomp, class EEomp> BinNode<Elem>* BST<Key,Elem,KEomp,EEomp>:: removehelp(binnode<elem>* subroot, const Key& K, BinNode<Elem>*& t) { if (subroot == ) return ; annot find the target else if (KEomp::lt(K, subroot->val())) Searching subroot->setleft(removehelp(subroot->left(), K, t)); else if (KEomp::gt(K, subroot->val())) 99 subroot->setright(removehelp(subroot->right(), K, t)); else { // Found it: remove it Found the target BinNode<Elem>* temp; subroot 4 t = subroot; if (subroot->left() == ) te = subroot = subroot->right(); t (abnode) else if (subroot->right() == ) 4 subroot = subroot->left(); else { // Both children are non-empty subroot->setright(deletemin(subroot->right(), temp)); Elem te = subroot->val(); subroot->setval(temp->val()); temp->setval(te); t = temp; return subroot; root root root=removehelp(root,,abnode); Left Right Bingo! 99.L 4 Left Right Bingo! 4.L temp Left Right Bingo! 5 48

25 Binary Search Trees: AT removehelp function No Left hild No Right hild Have both hildren Binary Search Trees: AT clearhelp functions void clear() { clearhelp(root); root = ; nodecount = ; template <class Key, class Elem, class KEomp, class EEomp> void BST<Key,Elem,KEomp,EEomp>:: clearhelp(binnode<elem>* subroot) { if (subroot == ) return; clearhelp(subroot->left()); clearhelp(subroot->right()); delete subroot; clearhelp(root); elete the node Base ase Recursive all Recursive all root 8 9 5

26 Binary Search Trees: AT printhelp functions template <class Key, class Elem, class KEomp, class EEomp> void BST<Key,Elem,KEomp,EEomp>:: printhelp(binnode<elem>* subroot, int level) { if (subroot == ) return ; printhelp(subroot->left(), level+); for (int i=; i<level; i++) cout << ; cout << subroot->val() << \n ; printhelp(subroot->right(), level+); printhelp(root, ); Base ase Recursive all Print the node Recursive all root Small Quiz!!!! Q. raw the BST that results from each of the following commands: abst abst.insert(); abst.removeany(temp); abst.removeany(temp); abst.remove(45, temp); abst.remove(6, temp); abst.remove(9, temp); abst.remove(64, temp); abst.print(); 5

27 Small Quiz!!!! abst.insert(); abst.removeany(temp); abst.removeany(temp); abst.remove(45, temp); abst.remove(6, temp); abst.remove(9, temp); abst.remove(64, temp); abst.print(); Binary Search Trees: AT ost of BST Operations Assume d = depth of the tree Find:Θ(d) Insert: Θ(d) elete: Θ(d) d is Θ(log n) if tree is balanced The worst case: Θ(n) The average case:θ(log n)

28 Binary Tree Array-Based omplete BT Simple and compact array implementation approach for complete binary tree No overhead space omplete binary Tree is useful: Heap data structure External sorting algorithm A B H E T J I G 55 Binary Tree Array-Based omplete BT Parent(r) = (r - ) / if r and r < n Leftchild(r) = r + if r+ < n Rightchild(r) = r + if r + < n Leftsibling(r) = r - if r is even, r > and r < n Rightsibling(r) = r + if r is odd, r + < n 8 9 Position Parent Left hild 5 9 Right hild Left Sibling 5 9 Right Sibling

29 Heaps Heap is a data structure with the following properties: omplete Binary Tree Value stored in a heap are partially ordered There is a relationship between the value stored at any node and values of its children Two types of heaps Min-heap: All values less than or equal to child values Max-heap: All values greater than or equal to child values Heap can be implemented simply by using the array-based complete binary tree 5 Heaps Max-heap Min-heap

30 Heaps: AT template<class Elem,class omp> class maxheap{ private: Elem* Heap; // Pointer to the heap array int size; // Maximum size of the heap int n; // Number of elems now in heap void siftdown(int); // Put element in place 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(); ; 59 Heaps buildheap function public void buildheap() // Heapify contents { for (int i=n/-; i>=; i) siftdown(i); on t need to call siftdown on leaf nodes template <class Elem, class omp> void maxheap<elem,omp>::siftdown(int pos) { while (!isleaf(pos)) { aheap.buildheap(); aheap.siftdown(); int j = leftchild(pos); aheap.siftdown(); int rc = rightchild(pos); aheap.siftdown(); if ((rc<n) && omp::lt(heap[j],heap[rc])) j = rc; if (!omp::lt(heap[pos], Heap[j])) return; swap(heap, pos, j); pos = j; Position Parent Left hild Right hild Left Sibling Right Sibling Position value j 5 pos j rc

31 Heaps buildheap function aheap.buildheap(); aheap.siftdown(); aheap.siftdown(); aheap.siftdown(); aheap.siftdown(); aheap.siftdown(); aheap.siftdown(); Heaps removemax function template <class Elem, class omp> bool maxheap<elem, omp>:: removemax(elem& it) { if (n == ) return false; // Heap is empty swap(heap,, n); // Swap max with end if (n!= ) siftdown(); it = Heap[n]; // Return max value return true; aheap.removemax(avalue); avalue = 4 6

32 Heaps remove function Refer to Figure 5., pp template <class Elem, class omp> bool maxheap<elem, omp>::remove(int pos, Elem& it) { bool flag = false; if ((pos < ) (pos >= n)) return false; swap(heap, pos, n); while ((pos!= ) && (omp::gt(heap[pos],heap[parent(pos)]))) { swap(heap, pos, parent(pos)); pos = parent(pos); flag=true; if (!flag) siftdown(pos); it = Heap[n]; return true; 64 9 avalue = aheap.remove(, avalue); Heaps remove function 6 Refer to Figure 5., pp template <class Elem, class omp> bool maxheap<elem, omp>::remove(int pos, Elem& it) { bool flag = false; if ((pos < ) (pos >= n)) return false; swap(heap, pos, n); while ((pos!= ) && (omp::gt(heap[pos],heap[parent(pos)]))) { swap(heap, pos, parent(pos)); pos = parent(pos); flag=true; if (!flag) siftdown(pos); it = Heap[n]; return true; avalue = 9 aheap.remove(, avalue);

33 Heaps insert function template <class Elem, class omp> // Insert element bool maxheap<elem, omp>::insert(const Elem& val) { if (n >= size) return false; // Heap is full int curr = n++; Heap[curr] = val; // Start at end of heap // Now sift up until curr's parent > curr while ((curr!=) && (omp::gt(heap[curr], Heap[parent(curr)]))) { swap(heap, curr, parent(curr)); curr = parent(curr); 9 return true; 59 6 aheap.insert(9); Small Exercise!!!! ah.buildheap(); ah.removemax(temp); ah.remove(, temp); ah.insert(45); public void buildheap() { for (int i=n/-; i>=; i) siftdown(i); ah.siftdown(5); 55 ah.siftdown(); ah (maxheap) 66

34 Small Exercise!!!! ah.siftdown(5); ah.siftdown(); ah.siftdown(); ah.siftdown(4); ah.siftdown(); ah.siftdown(); Small Exercise!!!! ah.removemax(temp);

35 Small Exercise!!!! ah.remove(, temp); Small Exercise!!!! ah.insert(45);

36 Heaps When a heap with size n is created, there are two choices: Buildheap function Insert n values to a heap using insert function Which one is better? Heaps Time omplexity Insert n values to a heap Insert one value takes Θ(log n) in the worst case Move from the bottom to the top of the tree Buildheap function (n values in the array) epends on number of shiftdown calls n i= logn i= log i=θ( n log n n ( i ) i = Θ( n) ) x x 4x We should use buildheap to build the heap 4 i- n/ i 8 4 n=6

37 Heaps: Priority Queues A priority queue stores objects, and on request releases the object with greatest value Example: Scheduling jobs in a multi-tasking operating system Heaps: Priority Queues Possible Solutions: Linked List Insert appends to a linked list ( O() ) Remove max value determines the maximum by scanning the list ( O(n) ) Sorted Linked List (decreasing order) Insert places an element in its correct position ( O(n) ) Remove max value simply removes the head of the list ( O() ) Heap Both insert and remove max value are O( log n ) operations 4

38 Huffman oding Trees An entropy encoding algorithm used for lossless data compression Use a variable-length code table for encoding a source symbol erived based on the estimated probability of occurrence for each possible value 5 Huffman oding Trees Fixed-Length oding ASII codes: 8 bits per character E : : Variable-Length oding an take advantage of relative frequency of letters to save space K F U L E Use larger number of bits to store it Use smaller number of bits to store it 6

39 Huffman oding Trees Build the tree with minimum external path weight ombine the two smallest values each time K 4 M 4 L U 4 E Huffman oding Trees 6 9 K 65 4 M 86 E 9 4 L U 4 Letter E M K L U Freq ode Bit

40 Huffman oding Trees Huffman oding has the prefix property No code in the set is the prefix of another Non-prefix example: A: B: : What is? More than one solutions AA BA ecode: U M E Letter Freq ode 4 E M 4 K L 4 U Bit Huffman oding Trees Expected ost Expected ost per letter (how many bits have been used for a letter in average?) Letter Freq ode Bit (*+*+4*+5*4+6*9) 6 = 85/6 E M =.5 K 6 L 4 U 6 8

41 Huffman oding Trees Huffman Node AT template <class Elem> class HuffNode { // Node abstract base class public: virtual int weight() = ; 65 4 M 9 K virtual bool isleaf() = ; virtual HuffNode* left() const = ; virtual void setleft(huffnode*) = ; virtual HuffNode* right() const = ; virtual void setright(huffnode*) = ; ; 8 Huffman oding Trees FreqPair template <class Elem> class FreqPair { // An element/frequency pair private: Elem it; // An element of some sort int freq; // Frequency for the element public: FreqPair(const Elem& e, int f) // onstructor { it = e; freq = f; ~FreqPair() { // estructor int weight() { return freq; // Return the weight Elem& val() { return it; // Return the element ; 65 4 M 9 K 8

42 Huffman oding Trees Leaf Node template <class Elem> // leaf node subclass class LeafNode: public HuffNode<Elem> { private: Freqpair<Elem>* it; // Frequency pair 65 4 M 9 K public: LeafNode(const Elem& val, int freq) //constructor { it = new Freqpair<Elem>(val,freq); int weight() Freqpair<Elem>* val() { return it; bool isleaf() { return true; virtual HuffNode* left() const { return ; virtual void setleft(huffnode*) { virtual HuffNode* right() const { return ; virtual void setright(huffnode*) { ; { return it->weight(); //Return frequency 8 Huffman oding Trees Internal Node template <class Elem> //Internal node subclass 4 9 class IntlNode: public HuffNode<Elem> { M private: HuffNode<Elem>* lc; //left child K HuffNode<Elem>* rc; //right child int wgt; //Subtree weight public: IntlNode(HuffNode<Elem> * l; HuffNode<Elem> * r) { wgt = l->weight() + r->weight(); lc = l; rc = r; int weight() { return wgt; // Return frequency bool isleaf() { return false; HuffNode<Elem>* left() const { return lc; void setleft(huffnode<elem>* b) { lc = (HuffNode*)b; HuffNode<Elem>* right() const { return rc; void setright(huffnode<elem>* b) { rc = (HuffNode*)b; ; 65 9 K 84

43 Huffman oding Trees Huffman Tree template <class Elem> class HuffTree { private: HuffNode<Elem>* theroot; public: HuffTree(Elem& val, int freq) { theroot = new LeafNode<Elem>(val,freq); HuffTree(HuffTree<Elem>* l, HuffTree<Elem>* r) { theroot = new IntlNode<Elem>(l->root(), r->root()); ~HuffTree() { 65 4 M 9 K HuffNode<Elem>* root() { return theroot; int weight() { return theroot->weight(); ; 85 Huffman oding Trees Huffman ompare 4 M template <class Elem> class HHompare { public: static bool lt(hufftree<elem>* x, HuffTree<Elem>* y) { return x->weight() < y->weight(); static bool eq(hufftree<elem>* x, HuffTree<Elem>* y) { return x->weight() = = y->weight(); static bool gt(hufftree<elem>* x, HuffTree<Elem>* y) { return x->weight() > y->weight(); ; 65 9 K 86

44 Huffman oding Trees Build Huffman Tree template <class Elem> HuffTree<Elem>* Use Huffman ompare in SLL buildhuff(sllist<hufftree<elem>*,hhompare<elem>>* f) { HuffTree<Elem>* temp, *temp, *temp; for (f->setstart(); f->leftlength() + f->rightlength()>; f->setstart()) { //While at least two items left f->remove(temp); // Pull first two trees off the list f->remove(temp); temp = new HuffTree<Elem>(temp, temp); f->insert(temp); // Put the new tree back on list delete temp; // elete the remnants delete temp; return temp; temp temp f Sorted Linked List (SLL) Element of SLL is Huffman Tree 9 K K 4 M temp 8 Huffman oding Trees Build Huffman Tree: Example U 9 K K M 4 M K 4 L 4 M U U U K 4 L 4 L 4 L 4 M E E E E 4 L U K 4 L 4 M U K E E 4 M 88

45 Huffman oding Trees Build Huffman Tree: Example U L 65 9 K E 4 M U L K E 4 M 89