Lecture 7. Binary Trees

Size: px

Start display at page:

Download "Lecture 7. Binary Trees"

Aubrie Hines
6 years ago
Views:

1 Lecture 7. Binary Trees Instructor: 罗国杰 School of EECS Peking University

2 Outline Preliminaries of trees Basic concepts Example: trees in a file system Binary trees Full, complete, extended ~ Properties Traversals 2

3 Preliminaries A tree is a collection of nodes and edges An edge is a ordered pair of nodes <u,v> Recursive definition An empty collection is a tree A single node collection is a tree This node is the root of this tree T is a tree, if T consist of a node r, non-empty subtrees T 1, T 2,, T k, and edges <r,r 1 >, <r,r 2 >,, <r,r k > where r 1, r 2, r k are the roots of the subtress, respectively. The distinguished node r is the root of T 3

4 Preliminaries Parent Child Node A is the parent of node B, if B is the root of one subtree of A. Node B is the child of node A, if A is the parent of B. Sibling Nodes with the same parent are siblings 4

5 Preliminaries Leaf A node is called a leaf if it has no children Internal node Path A nodes that a neither a leaf nor the root The sequence <k 0,k 1,,k s > is a path, if and only if <k 0,k 1 >, <k 1,k 2 >, <k s-1,k s > are edges 5

6 Preliminaries Ancestor (Recursively) node A is an ancestor of node B if A is either the parent of B, or A is the parent of some ancestor of B Descendant Node B is the descendant of node A, if A is an ancestor of node B If there is a path from j to k, j is k s ancestor and k is j s descendant 6

7 Preliminaries Depth (level) of a Node Depth of the root of a tree is 0; and the depth of any other node in the tree is one more than the depth of its parent (The length of path starting from the root) Depth (height, or height-1) of a Tree The depth of a tree is the maximum depth of any leaf in the tree (The longest path starting from the root) 7

8 Example: Unix File System 8

9 Example: Unix File System Static void ListDir(DirectoryOrFile D, int Depth) { if (D is a legitimate entry) { PrintName(D, Depth); if (D is a directory) for each child, C, of D ListDir(C, Depth +1); } } void ListDirectory(DirectoryOrFile D) { ListDir(D, 0); } 9

10 Example: Unix File System Static int SizeDirectory(DirectoryOrFile D) { int TotalSize = 0; if (D is a legitimate entry) { TotalSize = FileSize(D); if (D is a directory) for each child, C, of D TotalSize += SizeDirectory(C); } return TotalSize; } 10

11 Binary Trees Special binary trees Full ~ Complete ~ Extended ~ Properties of binary trees

12 Binary Trees: Definition Binary tree: a finite set of nodes An empty set is a binary tree A set is a binary tree, if it consists of one root node and two non-intersecting subtrees, named left subtree and right subtree, respectively 12

13 Binary Trees: Five Basic Forms 13

14 Full and Complete Binary Trees Full binary tree Every node other than the leaves has exactly two children Complete binary tree Every level, except possibly the last, is completed filled, and all nodes are as far left as possible A A B C B C D E D E F G F G H I J K L (A) 满二叉树 (b) 完全二叉树 14

15 Complete Binary Trees Properties Leaves are only presented in the bottommost two levels In all binary trees with the same number of nodes, a complete binary has the minimum internal path length Internal path length: the sum of the depths of all nodes in a tree 15

16 Extended Binary Trees

17 Extended Binary Trees Special nodes (null trees) are added Add one null leaf at every original internal node with only one child Add two null leaves at every original leaf (so that each original node has two children) A transformation into a full binary tree The number of null trees added equals the number of nodes in the original tree plus one 17

18 Extended Binary Trees Internal nodes: the nodes in the original tree External nodes: the null trees added Internal path length (I) the sum of the depths of all internal nodes in the extended binary tree External path length (E) the sum of the depths of all external nodes in the extended binary tree Property: E = I + 2n where n is the number of internal nodes 18

19 Extended Binary Trees For this example, E = = 39 I = = 19 It satisfies E = I + 2n where n = 10 19

20 Extended Binary Trees E = I + 2n (proof by induction) When n=1, we have I=0 and E=2, thus E=I+2n Assume E n = I n + 2n is satisfied, For an extended binary tree with (n+1) nodes Replace an original leaf with depth k by a null tree to get an extended binary tree with n nodes I n = I n+1 k E n = E n+1 2(k+1) + k = E n+1 k 2 According to these three equations, We get E n+1 = I n+1 + 2(n+1) 20

21 Properties of Binary Trees Property 1. There are at most 2 i nodes with depth i in a binary tree (i 0) (proof by induction) Property 2. A binary tree with depth k has at most 2 k+1-1 nodes (k 0) According to property 1, k n å 2 i = 2 k+1-1 i=0 21

22 Properties of Binary Trees Property 3. If a binary tree has n 0 leaves and n 2 nodes with two children, we have n 0 =n 2 +1 Proof. n = n 0 + n 1 + n 2 where there are n 1 nodes with only one child n = e + 1 = n 1 + 2n where e is the number of edges Thus, n 0 = n

23 Properties of Binary Trees Property 4. (Full Binary Tree Theorem) A non-empty full binary tree has the number of leaves equal to the number of internal nodes plus 1 (use property 3) Property 5. A non-empty binary tree has the number of null trees equal to the number of nodes plus 1 (use property 3) 23

24 Properties of Binary Trees Property 6. A complete binary tree with n nodes has depth k = log 2 (n+1) - 1 Proof. According to property 2 and the definition of completeness 2 k -1 < n 2 k+1 1 k < log 2 (n+1) k+1 d is an integer Thus, k = log 2 (n+1)

25 Properties of Binary Trees Property 7. If a complete binary tree has n nodes, and the nodes are labeled from left to right level-bylevel, we have the following for node i (0 i n-1) (1) If i = 0, node i is the root; if i > 0, its parent has label (i- 1)/2. (2) If 2i+1 n-1, the left child of i is (2i+1); otherwise node i has no left child. If 2i+2 n-1, the right child of i is (2i+2); otherwise node i has no right child. (3) If i is even and 0<i<n, the left sibling of i is (i-1); otherwise node i has no left sibling. If i is odd and i+1 < n, the right sibling of i is (i+1); otherwise node i has no right sibling. 25

26 Binary Tree ADT Abstract data type Depth-first search Breath-first search 26

27 Abstract Data Types Operations focus on accessing the information on the nodes access its left child, right child, or parent, or fetch the data on the node itself Some applications require a traversal The ADT defines the basic operations The ADT is independent of storage structures 27

28 Abstract Data Types: Node template <class T> class BinaryTreeNode { friend class BinaryTree<T>; // to access private members private: T info; // node data public: BinaryTreeNode(); // default constructor BinaryTreeNode(const T& ele); // constructor given the data BinaryTreeNode(const T& ele, // constructor given substrees BinaryTreeNode<T> *l, BinaryTreeNode<T> *r); 28

29 Abstract Data Types: Node }; T value() const; void setvalue(const T& val); BinaryTreeNode<T>* leftchild() const; BinaryTreeNode<T>* rightchild() const; void setleftchild(binarytreenode<t>*); void setrightchild(binarytreenode<t>*); bool isleaf() const; BinaryTreeNode<T>& operator = ( const BinaryTreeNode<T>& Node); 29

30 Abstract Data Types: Tree template <class T> class BinaryTree { private: BinaryTreeNode<T>* root; public: BinaryTree() { root = NULL; }; ~BinaryTree() { DeleteBinaryTree(root); } bool isempty() const; BinaryTreeNode<T>* Root() { return root; } 30

31 Abstract Data Types: Tree }; BinaryTreeNode<T>* Parent(BinaryTreeNode<T> *current); BinaryTreeNode<T>* LeftSibling(BinaryTreeNode<T> *current); BinaryTreeNode<T>* RightSibling(BinaryTreeNode<T> *current); void CreateTree(const T& info, BinaryTree<T>& lefttree, BinaryTree<T>& righttree); void PreOrder(BinaryTreeNode<T> *root); void InOrder(BinaryTreeNode<T> *root); void PostOrder(BinaryTreeNode<T> *root); void LevelOrder(BinaryTreeNode<T> *root); void DeleteBinaryTree(BinaryTreeNode<T> *root); 31

32 Traversal Traversal of a binary tree is to access the nodes sequentially in a certain order, such that each node is accessed exactly once The access can be read/write data from/to the nodes The traversal is essentially a linearization of the nodes in a binary treee 32

33 Depth-First Traversal Recursively define 3 strategies Preorder traversal (tlr order) Visit the root Traverse the left subtree in preorder Traverse the right subtree in preorder Inorder traversal (LtR order) Traverse the left subtree in inorder Visit the root Traverse the right subtree in inorder Postorder traversal (LRt order) Traverse the left subtree in postorder Traverse the right subtree in a postorder Visit the root 33

34 Traversal: Example Example + - H / * + * E - A B C D F G 34

35 Traversal: Example Preorder: +-/+AB*CD*E-FGH Inorder: A+B/C*D-E*F-G+H Postorder: AB+CD*/EFG-*-H H / * * E - A B C D F G 35

36 Traversal: Example Traversal of an expression tree Preorder: +-/+AB*CD*E-FGH Prefix expression (Polish notation) Inorder: A+B/C*D-E*F-G+H Infix expression Postorder: AB+CD*/EFG-*-H+ postfix expression (reverse Polish notation) 36

37 Depth-First Traversal template<class T> void BinaryTree<T>::PreOrder (BinaryTreeNode<T> *root) { if (root!= NULL) { Visit(root->value()); PreOrder(root->leftchild()); PreOrder(root->rightchild()); } } template<class T> void BinaryTree<T>:: InOrder (BinaryTreeNode<T> *root) { if (root!= NULL) { InOrder (root->leftchild()); 37

38 Depth-First Traversal Visit(root->value()); InOrder(root->rightchild()); } } template<class T> void BinaryTree<T>:: PostOrder (BinaryTreeNode<T> *root) { if (root!= NULL) { PostOrder(root->leftchild()); PostOrder (root->rightchild()); Visit(root->value()); } } 38

39 Depth-First Traversal Nonrecursive depth-first traversal Although the recursive algorithm is concise, there may be cases that do not pay recursion Solution: use a stack to simulate the recursive traversal Main idea of preorder traversal Visit a node, push the nonempty right child in the stack, and travers its left child When the traversal of its left child is finished, pop the nodes from the stack, and continue traversal 39

40 Depth-First Traversal: Preorder without Recursion template<class T> void BinaryTree<T>::PreOrderWithoutRecursion( BinaryTreeNode<T> *root) { using std::stack; stack<binarytreenode<t>* > astack; BinaryTreeNode<T> *pointer = root; astack.push(null); // push a dummy node while (pointer) { // or check!astack.empty() Visit(pointer->value()); 40

41 Depth-First Traversal: Preorder without Recursion } if (pointer->rightchild()!= NULL) astack.push(pointer->rightchild()); if (pointer->leftchild()!= NULL) pointer = pointer->leftchild(); else { // visit the right subtree pointer=astack.top(); astack.pop(); } } 41

42 Depth-First Traversal: Inorder without Recursion Main idea Push a node in the stack, before traversing its left subtree Pop the node and visit it after traversing the left subtree Traverse the right subtree 42

43 Depth-First Traversal: Inorder without Recursion template<class T> void BinaryTree<T>::InOrderWithoutRecursion( BinaryTreeNode<T> *root) { using std::stack; stack<binarytreenode<t>* > astack; BinaryTreeNode<T> *pointer = root; while (!astack.empty() pointer) { if (pointer) { 43

44 Depth-First Traversal: Inorder without Recursion } } } } else { astack.push(pointer); // descend from the left child pointer = pointer->leftchild(); pointer = astack.top(); astack.pop(); Visit(pointer->value()); // descend from the right child pointer = pointer->rightchild(); 44

45 Depth-First Traversal: Postorder without Recursion Main idea Push a node in the stack before traversing its left subtree Traverse the right subtree after traversing the left subtree Pop the node and visit it after traversing the right subtree How do you know which subtree has just been traversed? 45

46 Depth-First Traversal: Postorder without Recursion Solution Use an additional tag to indicate whether the right subtree is traversed Tags = {Left, Right} The left subtree has been traversed if tag == Left The right subtree has been traversed if tag == right 46

47 Depth-First Traversal: Postorder without Recursion enum Tags{Left,Right}; template <class T> class StackElement { public: BinaryTreeNode<T>* pointer; Tags tag; }; template<class T> void BinaryTree<T>::PostOrderWithoutRecursion( BinaryTreeNode<T>* root) { using std::stack; StackElement<T> element; 47

48 Depth-First Traversal: Postorder without Recursion stack<stackelement<t > > astack; BinaryTreeNode<T>* pointer; if (root == NULL) return; else pointer = root; while (!astack.empty() pointer) { while (pointer!= NULL) { element.pointer = pointer; element.tag = Left; astack.push(element); pointer = pointer->leftchild(); } element = astack.top(); 48

49 Depth-First Traversal: Postorder without Recursion } } astack.pop(); pointer = element.pointer; if (element.tag == Left) { element.tag = Right; astack.push(element); pointer = pointer->rightchild(); } else { Visit(pointer->value()); pointer = NULL; } 49

50 Breadth-First Traversal The process of traversal is Visit the node at level 0 (the root) Visit the nodes from left to right at level 1 Similarly, after visiting the nodes at level i, visit the nodes from left to right at level (i+1) Example on the right: A B C D E F G H I A B C D E F G H I 50

51 Breadth-First Traversal template<class T> void BinaryTree<T>::LevelOrder(BinaryTreeNode<T> *root) { using std::queue; queue<binarytreenode<t>*> aqueue; BinaryTreeNode<T> *pointer = root; if (pointer) aqueue.push(pointer); while (!aqueue.empty()) { pointer = aqueue.front(); aqueue.pop(); Visit(pointer->value()); if (pointer->leftchild()!= NULL) aqueue.push(pointer->leftchild()); if (pointer->rightchild()!= NULL) aqueue.push(pointer->rightchild()); } } 51

52 Recommended Readings Weiss, DS & Algo. Analysis in C++ (3 rd ed.) Section 4.1 Preliminaries Section 4.2 Binary Trees Section 4.6 Tree Traversals (Revisited) 52

Binary Trees, Binary Search Trees

Binary Trees, Binary Search Trees Trees Linear access time of linked lists is prohibitive Does there exist any simple data structure for which the running time of most operations (search, insert, delete)