國立清華大學電機工程學系. Outline

Transcription

1 國立清華大學電機工程學系 2410 ata Structure hapter 5 Trees (Part I) Outline Introduction inary Trees inary Tree Traversal dditional inary Tree Operations Threaded inary Trees Heaps ch5.1-2

2 Genealogical harts no inbreeding is allowed ch5.1-3 Simple Tree a subtree very Node can have many children nodes but can only have one parent node LVL egree The maximum no. of children nodes root 1 2 F G H I J 3 K L M 4 ch5.1-4

3 irect Representation of a Tree a subtree root F G H I J K L M Possible node structure for a tree of degree k ata hild1 hild2 hild k Wasteful! ch5.1-5 List Representation of Tree Representing a Tree as a List ( ( ((K,L), F), (G), (H(M), I, J) )) 0 F 0 G 0 I J 0 K L 0 H M 0 This type of node indicates a sub-tree ch5.1-6

4 Lemma 5.1 Lemma If T is a k-ary tree (I.e., a tree of degree k) with n nodes, each having a fixed size as shown in previous slide, then n(k-1) + 1 of the nk child fields are 0, n 1 Proof: The number of non-0 child fields in an n-node tree is exactly n-11 The total number of child fields in a k-ary tree with n nodes is nk Hence, the number of 0 fields is nk-(n-1) = n(k-1)+1 ch5.1-7 Left hild-right Sibling 嫡長子 - 庶子 Representation ata left child right sibling F G H I J F G H I J K L M K L M ch5.1-8

5 egree-two Tree F G H I J K L F G H K L M M I J ch5.1-9 inary Tree efinition binary tree is a finite set of nodes that either is empty or consists of a root and two disjoint binary trees called left subtree and right subtree Skewed Tree omplete Tree F G H I ch5.1-10

6 T of inarytree template <class KeyType> class inarytree // objects: finite set of nodes either empty or consisting of a root node, // left inarytree and right inarytree public: inarytree(); // creates an empty binary tree oolean Ismpty(); // if the binary tree is empty, return TRU (1); else return FLS (0) inarytree( inarytree bt1, lement<keytype> item, inarytree bt2); // creates a binary tree whose left subtree is bt1, whose right subtree is bt2 // and whose root node contains item inarytree Lchild(); // if Ismpty(), return error; else return the left subtree of *this lement<keytype> ata(); // if Ismpty(), return error; else return the data in the root node of *this inarytree Rchild(); // if Ismpty(), return error; else return the right subtree of *this ; ch Maximum Number of Nodes Lemma 5.2 (1) The maximum no. of nodes on level i of a binary tree is 2 i-1, i 1 (2) The maximum number of nodes in a binary tree of depth k is 2 k -1, k 1 Proof by induction Induction base: root is the only node on level i=0 Induction hypothesis: max. no. of nodes on level i-1 is 2 i-2 Induction step: max. no. of nodes on level i is 2 i-1 k k-1 (maximum no. of nodes on level i) = 2 i = 2 k -1 i=1 i=0 ch5.1-12

7 Leaf Nodes vs. egree-2 Nodes Lemma 5.3 For any nonempty binary tree, T, if n 0 is the number of leaf nodes and n 2 the number of nodes of degree 2 then n 0 = n Proof Let n be the total number of nodes Let n 1 be the number of nodes of degree 1 We have n = n 0 +n 1 +n 2 If is the number of branches, n = + 1 and = n 1 + 2n 2 Hence we obtain n = + 1 = n 1 + 2n Finally, we can reach n 0 = n ch Full inary Tree With Sequential Node Number Let n be the number of nodes The depth will be ceiling(log 2 (n+1)) Lemma 5.4 If a complete binary tree with n nodes is represented sequentially, then for any node with index i, 1 i n, we have (1) parent(i) is at i/2 if i 1 (2) Lefthild(i) is at 2i if 2i n. If 2i>n, then i has no left child. (3) Righthild(i) is at 2i+1 if 2i+1 n. If 2i+1>n, then i has no right child ch5.1-14

8 rray Representation of Tree rray H I F G rray - F G H I ch Linked Representation class Tree; // forward declaration class TreeNode friend class Tree; Lefthild data Righthild private: TreeNode *Lefthild; char data; TreeNode *Righthild; ; data class Tree public: // Tree operations private: TreeNode *root; ; Lefthild Righthild ch5.1-16

9 List Representation of Tree 0 0 H I F root G F 0 0 G 0 0 H 0 0 I 0 ch Outline Introduction inary Trees inary Tree Traversal dditional inary Tree Operations Threaded inary Trees Heaps ch5.1-18

10 inary Tree With rithmetic xpression * + Inorder Traversal / * * + * Postorder Traversal / * * + / Preorder Traversal +**/ ch Inorder Traversal of a inary Tree void Tree::inorder() // river calls workhorse for traversal of entire tree. The driver is declared // as a public member function of Tree inorder(root); void Tree::inorder(TreeNode *urrentnode) // workhorse traverses the subtree rooted at urrentnode (which is a pointer to // a node in a binary tree). The workhorse is declared as a private member // function of Tree if (urrentnode) inorder( urrentnode Lefthild); cout << urrentnode data); inorder ( urrentnode Righthild); left sub-tree current right sub-tree ch5.1-20

11 Trace of Inorder Traversal + * * / ch Preorder Traversal of a inary Tree void Tree::preorder() // river calls workhorse for traversal of entire tree. The driver is declared // as a public member function of Tree preorder(root); void Tree::preorder(TreeNode *urrentnode) // workhorse traverses the subtree rooted at urrentnode (which is a pointer to // a node in a binary tree). The workhorse is declared as a private member // function of Tree if (urrentnode) cout << urrentnode data); preorder( urrentnode Lefthild); preorder ( urrentnode Righthild); left sub-tree current right sub-tree ch5.1-22

12 Postorder Traversal of a -Tree void Tree::postorder() // river calls workhorse for traversal of entire tree. The driver is declared // as a public member function of Tree postorder(root); void Tree::postorder(TreeNode *urrentnode) // workhorse traverses the subtree rooted at urrentnode (which is a pointer to // a node in a binary tree). The workhorse is declared as a private member // function of Tree if (urrentnode) postorder( urrentnode Lefthild); postorder ( urrentnode Righthild); cout << urrentnode data); left sub-tree current right sub-tree ch Iterative Inorder Traversal void Tree::NonRecInorder() // non-recursive inorder traversal using a stack * * Stack<TreeNode*> s; // declare and initialize iti stack TreeNode *urrentnode = root; / while(1) while (urrentnode) // move down the Lefthild fields all the way s.dd(urrentnode); // add to stack urrentnode = urrentnode Lefthild; if (! s.ismpty() ) // stack is not empty urrentnode =*s.elete ( urrentnode ); // pop from stack cout << urrentnode data << endl; urrentnode = urrentnode Righthild; // to explore Right SubTree else break; + ch5.1-24

13 Traversal Using Iterator class InorderIterator Inorder Traversal Using Iterator public: char *Next(); InorderIterator(Tree tree): t (tree) urrentnode = t.root; private: + const Tree& t; Stack<TreeNode*> s; New data member (not needed in a list iterator) * TreeNode *urrentnode; ; char *InorderIterator::Next() * while (urrentnode) s.dd(urrentnode); / urrentnode = urrentnode Lefthild; if (! s.ismpty() ) urrentnode = *s.elete( urrentnode ); char& temp = urrentnode data; urrentnode = urrentnode Righthild; // update urrentnode return &temp; else return(0); // tree has been traversed, no more elements ch Level-Order Traversal void Tree::LevelOrder() // Traverse the binary tree in level order Queue<TreeNode*> q; // queue is needed here TreeNode *urrentnode = root; while ( urrentnode ) cout << urrentnode data << endl; if ( urrentnode Lefthild ) q.dd(urrentnode Lefthild); if (urrentnode Righthild) q.dd(urrentnode Righthild); urrentnode = *q.elete(urrentnode); * * + readth-first Traversal (FS) Level-order traversal: + * * / / ch5.1-26

14 Three Ways of Tree Traversal Without Stacks dd a parent field to each node oubly linked dtree Use Lefthild and Righthild To maintain the paths back to the root shown in the next slide Threaded inary Tree To be introduced later ch Traversal Without Stack void Tree::NoStackInorder() // Inorder traversal of binary tree using a fixed amount of additional storage if (! root ) return; // empty binary tree TreeNode *top = 0, *LastRight = 0, *p, *q, *r, *r1; p = q = root; while (1) while (1) if ( (! p Lefthild) && (! p Righthild ) ) // leaf node cout << p data; break; if ( (! p Lefthid ) // visit p and move to p Righthild cout << p data; r = p Righthild; p Righthild = q; 7 q = p; p = r; else // move to p Lefthild r = p Lefthild; p Lefthild = q; q = p; p = r; // end of inner while TO ONTINU q p 1 r ch5.1-28

15 while (1) previous page // p is a leaf Traversal node, move upward Without to a node whose right subtree Stack not explored yet TreeNode *av = p; while (1) if (p==root) return; if (! q Lefthild) // q is linked via Righthild r = q Righthild; q Righthild = p; p = q; q = r; else if (! q Righthild ) // q is linked via Lefthild r = q Lefthild; q Lefthild = p; p = q; q = r; cout << p data; else // check if p is a Righthild of q if ( q == LastRight ) r = top; LastRight = r Lefthild; top = r Righthild; // unstack r Lefthild = r Righthild = 0; r = q Righthild; q Righthild = p; p = q; q = r; else // p is Lefthild of q cout << q data; // visit q av Lefthild = LastRight; av Righthild = top; top = av; LastRight = q; r = q Lefthild; q Lefthild = p; // restore link to p r1 = q Righthild; q Righthild = r; p = r1; break; ch Outline Introduction inary Trees inary Tree Traversal dditional inary Tree Operations Threaded inary Trees Heaps ch5.1-30

16 opying inary Trees // opy constructor Tree::Tree( const Tree& s) // driver root = copy(s.root); TreeNode *Tree::copy(TreeNode *orignode) // Workhorse // The function returns a pointer to an exact copy of the binary tree rooted // at orginode if ( originode ) ThreeNode *temp = new TreeNode; temp data = orignode data; temp Lefthild = copy(orignode Lefthild); temp Righthild = copy(orignode Righthild); return temp; else return 0; ch Propositional alculus oolean Formula is often constructed by a set of variables x 1, x 2, x 3, 3 operators such as * (N) + (OR), and ~ (NOT) holds the value of true or false onstruction Rules of Propositional alculus (1) variable is an expression (2) if x and y are expressions, then x*y, x+y, and ~x are expressions (3) Parentheses can be used to alter the normal order of evaluation xample: P = x1 + (x2 * ~ x3) valuation when x1=false, x2=true, x3=false, then P = true ch5.1-32

17 Satisfiability Problem Satisfiability Problem for formulas of propositional calculus asks if there is an assignment of values to the variables that causes the value of the expression to be true xample P = x1 * ~x2 + ~x1 * x3 + ~x3 + + ~ * * x3 x1 ~ ~ x3 x2 x1 ch First Version of Satisfiability Problem enum oolean FLS, TRU ; enum TypesOfata NOT, N, OR, TRU, FLS class SatTree; // forward declaration class SatNode friend class SatTree; private: SatNode *Lefthild; TypesOfata data; oolean value; SatNode *Righthild; class SatTree public: void PostOrderval(); void rootvalue() cout << root value; ; private: SatNode *root; void PostOrderval ( SatNode *); ; for all 2 n possible value combinations for the n variables generate the next combination; replace the variable by their values; evaluate the formula by traversing the tree by PostOrderval(); if ( formula.rootvalue()) cout << combination; return; cout << no satisfiable combination ; ch5.1-34

18 valuating Formula void SatTree::PostOrderval() // river PostOrderval ( root ); void SatTree::PostOrderval(SatNode *s) // Workhorse if (s) PostOrderval ( s Lefthild ); PostOrderval ( s Righthild ); switch ( s data) case NOT: s value =! s Righthild value; break; case N: s value = s Lefthild value && s Righthild value; case OR: break; s value = s Lefthild value s Righthild value; break; case TRU: s value = TRU; break; case FLS: s value = FLS; break; ch Outline Introduction inary Trees inary Tree Traversal dditional inary Tree Operations Threaded inary Trees Heaps ch5.1-36

19 Threaded Tree LeftTread Lefthild data Righthild RightThread TRU FLS To utilize 0-links: left thread: inorder predecessor right thread: inorder successor H 2 I 3 F G ch class ThreadedNode friend class ThreadedTree; friend class ThreadedInorderIterator; private: oolean LeftThread; ThreadedNode *Lefthild; char data; ThreadedNode *Righthild; lass for Threaded inary lass For Threaded inary Trees oolean RightThread; ; class ThreadedTree friend class ThreadedInorderIterator; public: // Tree manipulation operations follow private: ThreadedNode *root; ; class ThreadedInorderIterator public: char *next(); ThreadedInorderIterator(ThreadedTree tree): t (tree) urrentnode = t.root; ; private: ThreadedTree t; ThreadedNode *urrentnode; ch5.1-38

20 Memory Representation of Threaded Tree F G H I ch Finding the Inorder Successor char *ThreadedInorderIterator::Next() // Find the inorder successor of urrentnode in a threaded binary tree ThreadedNode *temp = urrentnode Righthild; // rightchild or successor if (! urrentnode RightThread ) while (! temp LeftThread ) temp = temp Lefthild; urrentnode = temp; if ( urrentnode == t.root ) return 0; // last node has been reached else return (&urrentnode data); void ThreadedInorderIterator::Inorder() for (char *ch = Next(); ch; ch = Next() ) cout << *ch << endl; F G H I ch5.1-40

21 Inserting Node In Threaded Tree s r insert r s r s r insert r s r ch Inserting Operation void ThreadedTree::InsertRight( ThreadedNode *s, ThreadedNode *r) // Insert r as the right child of s r Righthild = s Righthild; r RightThread = s RightThread; r Lefthild = s; r LeftThread = TRU; // Lefthild is a thread s Righthild = r; // ttach r to s s RightThread = FLS; if (! r RightThread) ThreadedNode *temp = InorderSucc(r) ; // returns the inorder successor of r temp Lefthild = r; s s r insert r r ch5.1-42

22 Outline Introduction inary Trees inary Tree Traversal dditional inary Tree Operations Threaded inary Trees Heaps ch Priority Queue Priority Queue lements deleted is the one with the highest priority n element with arbitrary priority may be inserted This is called max priority queue min priority queue is defined similarly template<class Type> class MaxPQ public: virtual void insert(const lement<type>&) = 0; virtual lement<type>* eletemax( lement<type>&) = 0; ; ch5.1-44

23 Heap Max Heap is frequently used to implement a priority queue efinition max(min) tree is a tree in which the key value in each node is no smaller (larger) than the key values in its children (if any) max heap is a complete binary tree that is also a max tree min heap is a complete binary tree that is also a min tree ch lass efinition of Max Heap template <class KeyType> class MaxHeap : public MaxPQ<KeyType> // objects: complete binary tree of n > 0 elements organized in a way that // the value in each node is at least as large as those in its children public: MaxHeap( int sz = efaultsize); // reate an empty heap that can hold a maximum of sz elements oolean IsFull(); // If the number of elements in the heap is equal to the maximum size of the // heap, return TRU(1); otherwise, return FLS(0) void Insert(lement<KeyType> item); // If IsFull(), then error, else insert item into the heap oolean Ismpty() // If number of elements in heap is 0, return TRU(1); else return FLS(0) lement<keytype>* elete(keytype& x); private: lement<type> *heap; int n; // current size of max heap int MaxSize; // Maximum allowable size of heap ch5.1-46

24 Insertion To a Max Heap after adding a node new still a complete binary tree Final tree after inserting 5 Final tree after inserting 21 ch Insertion To a Max Heap template <class Type> void MaxHeap<Type>::Insert( const lement<type>& x) // insert x into the max heap original 20 if (n==maxsize) HeapFull(); return; n++; for(int i=n; 1;) 15 2 if (i==1) break; // at root if (x.key <= heap[i/2].key) break; x.key // move from parent to i heap[i] = heap[i/2]; adding 5 x 是節點物件,x.key 是關鍵值 adding 21 i=i/2; i heap[i] = x; // write in the data ch5.1-48

25 eletion From a Max Heap after deleting the root element 15 null after moving 15 after moving to the vacancy 10 to the vacancy null Final tree still complete binary tree ch eletion From a Max Heap after deleting the root element null after moving 19 to the vacancy null after moving 10 to the vacancy ch5.1-50

26 eletion From a Max Heap template <class Type> lement<type>* MaxHeap<Type>::eleteMax(lement<Type>& x) // elete from the max heap if (n==0) Heapmpty(); return 0; x = heap[1]; lement<type> k = heap[n]; n--; for ( int i=1; j=2; j<=n;) if (j<n) if (heap[j].key < heap[j+1].key) j++; // j points to the larger child if (k.key >= heap[j].key) break; heap[i] = heap[j]; // move child up i = j; j *= 2; // move i and j down heap[i] = k; return &x; i: vacant position j: larger child height of a heap = log 2 (n+1) complexity = O(log n) ch The nd of Trees Part I Next Topic: Trees Part II