DataStruct 7. Trees. Michael T. Goodrich, et. al, Data Structures and Algorithms in C++, 2 nd Ed., John Wiley & Sons, Inc., 2011.

Transcription

1 DataStruct 7. Trees Michael T. Goodrich, et. al, Data Structures and Algorithms in C++, 2 nd Ed., John Wiley & Sons, Inc., November 6, 2013 Advanced Networking Technology Lab. (YU-ANTL) Dept. of Information & Comm. Eng, College of Engineering, Yeungnam University, KOREA (Tel : ; Fax : ytkim@yu.ac.kr)

2 General Trees Tree Traversal Algorithms Binary Trees Outline DS 7-2

3 7.1 General Tree In computer science, a tree is an abstract model of a hierarchical structure A tree consists of nodes with a parent-child relation Applications: Organization charts File systems Programming environments US Computers R Us Sales Manufacturing International Laptops Desktops R&D Europe Asia Canada DS 7-3

4 Formal Tree Definitions (1) Root: node without parent (A) Internal node: node with at least one child (A, B, C, F) External node (a.k.a. leaf ): node without children (E, I, J, K, G, H, D) Ancestors of a node: parent, grandparent, grand-grandparent, etc. Depth of a node: number of ancestors Height of a tree: maximum depth of any node (3) Descendant of a node: child, grandchild, grandgrandchild, etc. Subtree: tree consisting of a node and its descendants E B F I J K A G C H subtree D DS 7-4

5 Formal Tree Definitions (2) parent, child, subtree root parent child sibling: nodes that are children of the same parent external node: leaf node that has no children internal node: node that has one or more children ancestor descendent subtree DS 7-5

6 Edges and paths Formal Tree Definitions (3) edge of tree T is a pair of nodes (u, v) such that u is the parent of v, or vice versa path of T is a sequence of nodes such that any two consecutive nodes in the sequence form an edge Ordered Tree a tree is ordered if there is a linear ordering defined for the children of each node e.g.) structured document DS 7-6

7 Tree Functions We use positions to abstract nodes Generic methods: integer size() // returns the number of nodes in the tree boolean empty() // return true if the tree is empty Accessor methods: position root() // return a position for the tree s root list<position> positions() // return a position list of all the nodes of the tree Position-based methods: position p.parent() // return the parent of p list<position> p.children() // return a position list containing the children of p Query methods: boolean p.isroot() boolean p.isexternal() Additional update methods may be defined by data structures implementing the Tree ADT DS 7-7

8 C++ Tree Interface Informal interface for a position in a tree template <typename E> // base element type class Position<E> { // a node position public: E& operator*(); // get element Position parent() const; // get parent PositionList children() const; // get node's children bool isroot() const; // root node? bool isexternal() const; // external node? }; Informal interface for the tree ADT template <typename E> // base element type class Tree<E> { public: // public types class Position; // a node position class PositionList; // a list of positions of children public: // public functions int size() const; // number of nodes bool empty() const; // is tree empty? Position root() const; // get the root PositionList positions() const; // get positions of all nodes }; DS 7-8

9 Linked Structure for General Trees linked structure of general tree parent element children container (a) Node Structure (b) Portion of data structure associated with a node and its children DS 7-9

10 Depth 7.2 Tree Traversal Algorithms p : a node of a tree T depth of p is the number of ancestors of p int depth(const Tree& T, const Position& p) { if (p.isroot()) return 0; // root has dept else return (1 + depth(t, p.parent())); // 1 + (depth of parent) } DS 7-10

11 Height if p is external, then the height of p is 0 height of a node p in a tree T is one plus the maximum height of a child of p height of a tree T is the height of the root of T int height2(const Tree& T, const Position& p) { if (p.isexternal()) return 0; // leaf has height 0 int h = 0; PositionList ch = p.children(); // list of children for (Iterator q = ch.begin(); q!= ch.end(); ++q) h = max(h, height2(t, *q)); return 1 + h; // 1 + max height of children } DS 7-11

12 Preorder Traversal A traversal visits the nodes of a tree in a systematic manner In a preorder traversal, a node is visited before its descendants Application: print a structured document Algorithm preorder(v) visit(v) for each child w of v preorder (w) DS 7-12

13 preorderprint void preorderprint(const Tree& T, const Position& p) { cout << *p; // print element PositionList ch = p.children(); // list of children for (Iterator q = ch.begin(); q!= ch.end(); ++q) { cout << " "; preorderprint(t, *q); } } DS 7-13

14 Postorder Traversal In a postorder traversal, a node is visited after its descendants Application: compute space used by files in a directory and its subdirectories Algorithm postorder(v) for each child w of v postorder (w) visit(v) DS 7-14

15 postorderprint void postorderprint(const Tree& T, const Position& p) { PositionList ch = p.children(); // list of children for (Iterator q = ch.begin(); q!= ch.end(); ++q) { postorderprint(t, *q); cout << " "; } cout << *p; // print element } DS 7-15

16 7.3 Binary Trees A binary tree is a tree with the following properties: Each internal node has at most two children (exactly two for proper binary trees) The children of a node are an ordered pair We call the children of an internal node left child and right child Alternative recursive definition: a binary tree is either a tree consisting of a single node, or a tree whose root has an ordered pair of children, each of which is a binary tree Applications: arithmetic expressions decision processes searching D B H E I A F C G DS 7-16

17 Arithmetic Expression Tree Binary tree associated with an arithmetic expression internal nodes: operators external nodes: operands Example: arithmetic expression tree for the expression (2 (a 1) + (3 b)) + 2 a 1 3 b DS 7-17

18 Decision Tree Binary tree associated with a decision process internal nodes: questions with yes/no answer external nodes: decisions Example: dining decision Want a fast meal? Yes How about coffee? No On expense account? Yes No Yes No Starbucks Spike s Al Forno Café Paragon DS 7-18

19 BinaryTree ADT The BinaryTree ADT extends the Tree ADT, i.e., it inherits all the methods of the Tree ADT Additional methods: position p.left() position p.right() Update methods may be defined by data structures implementing the BinaryTree ADT Proper binary tree: Each node has either 0 or 2 children DS 7-19

20 Traversals of a Binary Tree Preorder Traversal Algorithm binarypreorder(t, p) perform the visit action for node p if p is an internal node then binarypreorder(t, p.left()) binarypreorder(t, p.right()) In-order Traversal Algorithm binaryinorder(t, p) if p is an internal node then binaryinorder(t, p.left()) perform the visit action for node p if p is an internal node then binaryinorder(t, p.right()) Post-order Traversal Algorithm binarypostorder(t, p) if p is an internal node then binarypostorder(t, p.left()) binarypostorder(t, p.right()) perform the visit action for node p DS 7-20

21 Inorder Traversal In an inorder traversal a node is visited after its left subtree and before its right subtree Application: draw a binary tree x(v) = in-order rank of v y(v) = depth of v 2 6 Algorithm inorder(v) if v.isexternal() inorder(v.left()) visit(v) if v.isexternal() inorder(v.right()) DS 7-21

22 Print Arithmetic Expressions Specialization of an inorder traversal print operand or operator when visiting node print ( before traversing left subtree print ) after traversing right subtree + Algorithm printexpression(v) if v.isexternal() print( ( ) inorder(v.left()) print(v.element()) if v.isexternal() inorder(v.right()) print ( ) ) 2 a 1 3 b ((2 (a 1)) + (3 b)) DS 7-22

23 Evaluate Arithmetic Expressions Specialization of a postorder traversal recursive method returning the value of a subtree when visiting an internal node, combine the values of the subtrees + Algorithm evalexpr(v) if v.isexternal() return v.element() else x evalexpr(v.left()) y evalexpr(v.right()) operator stored at v return x y DS 7-23

24 Euler Tour Traversal Generic traversal of a binary tree Includes a special cases the preorder, postorder and inorder traversals Walk around the tree and visit each node three times: on the left (preorder) from below (inorder) on the right (postorder) L R B DS 7-24

25 Class Position C++ Binary Tree Interface template <typename E> // base element type class Position<E> { // a node position public: E& operator*(); // get element Position left() const; // get left child Position right() const; // get right child Position parent() const; // get parent bool isroot() const; // root of tree? bool isexternal() const; // an external node? }; DS 7-25

26 Class BinaryTree template <typename E> // base element type class BinaryTree<E> { // binary tree public: // public types class Position; // a node position class PositionList; // a list of positions public: // member functions int size() const; // number of nodes bool empty() const; // is tree empty? Position root() const; // get the root PositionList positions() const; // list of nodes }; DS 7-26

27 Properties of Proper Binary Trees Notation n number of nodes e number of external nodes i number of internal nodes h height Properties: e = i + 1 n = 2e 1 h i h (n 1)/2 e 2 h h log 2 e h log 2 (n + 1) 1 DS 7-27

28 Maximum Number of Nodes in the levels of a Binary Tree DS 7-28

29 Linked Structure for Binary Trees A node is represented by an object storing Element Parent node Left child node Right child node Node objects implement the Position ADT B B A C D E A D C E DS 7-29

30 Linked Binary Tree (1) /** LinkedBinaryTree.h */ #ifndef LINKEDBINARYTREE_H #define LINKEDBINARYTREE_H #include <iostream> #include <list> using namespace std; typedef int Elem; // base element type class LinkedBinaryTree { protected: // TreeNode declaration struct TreeNode { // a node of the tree Elem elt; // element value TreeNode* parent; // parent TreeNode* left; // left child TreeNode* right; // right child TreeNode() : elt(), parent(null), left(null), right(null) { } // constructor TreeNode(Elem e) : elt(e), parent(null), left(null), right(null) { } // constructor }; DS 7-30

31 Linked Binary Tree (2) /** LinkedBinaryTree.h (2) */ public: // Position declaration class Position { // position in the tree private: TreeNode* v; // pointer to the TreeNode public: Position(TreeNode* _v = NULL) : v(_v) { } // constructor Elem& operator*() { return v->elt; } // get element Position left() const { return Position(v->left); } // get left child Position right() const { return Position(v->right); } // get right child Position parent() const { return Position(v->parent); } // get parent bool isnull() { return (v == NULL); } // check if position is null bool isroot() const { return v->parent == NULL; } // root of the tree? bool isexternal() const { return v->left == NULL && v->right == NULL; } // an external TreeNode? friend class LinkedBinaryTree; // give tree access }; typedef std::list<position> PositionList; // list of positions DS 7-31

32 Linked Binary Tree (3) /** LinkedBinaryTree.h (2) */ public: LinkedBinaryTree(); // constructor int size() const; // number of TreeNodes bool empty() const; // is tree empty? Position root() const; // get the root PositionList positions() const; // list of TreeNodes void addroot(); // add root to empty tree void expandexternal(const Position& p); // expand external TreeNode Position removeaboveexternal(const Position& p); // remove p and parent Position addelementinorder(position& p, Position& paren, const Elem& element); void printtreeinorder(position p); void printtreebylevel(position p, int level); // housekeeping functions omitted... protected: // local utilities void preorder(treenode* v, PositionList& pl) const; // preorder utility private: TreeNode* _root; // pointer to the root int n; // number of TreeNodes }; #endif DS 7-32

33 Linked Binary Tree (4) /** LinkedBinaryTree.cpp (1) */ #include "LinkedBinaryTree.h" LinkedBinaryTree::LinkedBinaryTree() : _root(null), n(0) { } int LinkedBinaryTree::size() const { return n; } bool LinkedBinaryTree::empty() const { return size() == 0; } // constructor // number of nodes // is tree empty? LinkedBinaryTree::Position LinkedBinaryTree::root() const // get the root { return Position(_root); } void LinkedBinaryTree::addRoot() { _root = new TreeNode; n = 1; } // add root to empty tree DS 7-33

34 Linked Binary Tree (5) /** LinkedBinaryTree.cpp (2) */ // expand external node void LinkedBinaryTree::expandExternal(const Position& p) { TreeNode* v = p.v; // p's node v->left = new TreeNode; // add a new left child v->left->parent = v; // v is its parent v->right = new TreeNode; // and a new right child v->right->parent = v; // v is its parent n += 2; // two more nodes } LinkedBinaryTree::Position // remove p and parent LinkedBinaryTree::removeAboveExternal(const Position& p) { TreeNode* w = p.v; TreeNode* v = w->parent; // get p's node and parent TreeNode* sib = (w == v->left? v->right : v->left); if (v == _root) { // child of root? _root = sib; //...make sibling root sib->parent = NULL; } else { TreeNode* gpar = v->parent; // w's grandparent if (v == gpar->left) gpar->left = sib; // replace parent by sib else gpar->right = sib; sib->parent = gpar; } delete w; delete v; // delete removed nodes n -= 2; // two fewer nodes return Position(sib); } DS 7-34

35 Binary Tree Update Functions expandexternal(p) removeaboveexternal(p) DS 7-35

36 Linked Binary Tree (6) /** LinkedBinaryTree.cpp (3) */ // list of all nodes LinkedBinaryTree::PositionList LinkedBinaryTree::positions() const { PositionList pl; preorder(_root, pl); // preorder traversal return PositionList(pl); // return resulting list } // preorder traversal void LinkedBinaryTree::preorder(TreeNode* v, PositionList& pl) const { pl.push_back(position(v)); // add this node if (v->left!= NULL) // traverse left subtree preorder(v->left, pl); if (v->right!= NULL) // traverse right subtree preorder(v->right, pl); } DS 7-36

37 Linked Binary Tree (7) /** LinkedBinaryTree.cpp (4) */ LinkedBinaryTree::Position LinkedBinaryTree::addElementInOrder(Position& p, Position& paren, const Elem& element) { LinkedBinaryTree::Position newpos; if (p.isnull()) { p.v = new TreeNode(element); if (paren.v == NULL) { _root = p.v; } p.v->parent = paren.v; n++; // increment the number of elements return LinkedBinaryTree::Position(p.v); } } else if (element < *p) { newpos = addelementinorder(p.left(), p, element); p.v->left = newpos.v; } else if (element > *p) { newpos = addelementinorder(p.right(), p, element); p.v->right = newpos.v; } else { cout << "Duplicated element in addelementinorder!!" << endl; } DS 7-37

38 Linked Binary Tree (8) /** LinkedBinaryTree.cpp (5) */ void LinkedBinaryTree::printTreeInOrder(Position p) { if (p.isnull()) return; printtreeinorder(p.left()); cout << *p <<" "; printtreeinorder(p.right()); } void LinkedBinaryTree::printTreeByLevel(Position p, int level) { LinkedBinaryTree::TreeNode* pchild = NULL; if (p.v!= NULL) { if (level == 0) cout << "\ nroot (data: "; cout << *p << ")" << endl; pchild = (p.left()).v; for (int i=0; i<level; i++) cout << " "; DS 7-38

39 Linked Binary Tree (9) /** LinkedBinaryTree.cpp (6) */ if (pchild!= NULL) { cout << "L (data: "; printtreebylevel(pchild, level+1); } else { cout << "L (NULL)" << endl; } } } pchild = (p.right()).v; for (int i=0; i<level; i++) cout << " "; if (pchild!= NULL) { cout << "R (data: "; printtreebylevel(pchild, level+1); } else { cout << "R (NULL)" << endl; } DS 7-39

40 Linked Binary Tree (10) /** main.cpp */ #include <iostream> #include "LinkedBinaryTree.h" void main() { LinkedBinaryTree* plbtree; int data; plbtree = new LinkedBinaryTree; cout << endl; for (int i=0; i<10; i++) { data = rand() % 100; cout << "Adding " << data << " into LinkedBinaryTree" << endl; plbtree->addelementinorder(plbtree->root(), LinkedBinaryTree::Position(NULL), data); } cout << "\ nelements in LinkedBinaryTree, in order : " << endl; plbtree->printtreeinorder(plbtree->root()); cout << endl; plbtree->printtreebylevel(plbtree->root(), 0); // start from level 0 cout << endl; } delete plbtree; DS 7-40

41 Execution Results (case 1) (case 2) DS 7-41

42 Tri-node Restructuring height height of leaf node : 1 height of inner node: 1 + MAX (height of left child, height of right child) height difference height difference = height of left child height of right child tri-node restructuring re-arrange three node so that the re-arranged subtree has height difference less than or equal to 1 h 3 diff 1 h 4 diff 3 h 4 diff -3 h 3 diff -1 h 2 diff 1 h 2 diff -1 (Example 1) DS 7-42 (Example 2)

43 Tri-node Restructuring Single rotation LL of subtree h 2 diff 1 A h 3 diff 2 B C rotate_ll() h 2 A B C DS 7-43

44 Example of Tri-node Restructuring Single rotation RR of subtree A h 3 diff 2 h 2 B diff 1 ht 0 C rotate_rr() A B h 2 C DS 7-44

45 Example of Tri-node Restructuring Double rotation LR of subtree h 2 diff -1 A h 3 diff 2 B C rotate_lr() h 2 A B C DS 7-45

46 Example of Tri-node Restructuring Double rotation RL of subtree A h 3 diff -2 B C h 2 diff 1 rotate_rl() h 2 A B C DS 7-46

47 Algorithm getheight() Algorithm getheight(treenode* ptn) height = 0; if (ptn!= NULL) height = 1 + max (getheight(ptn->left()), getheight(ptn->right()); return height; end Algorithm getheightdiff() Algorithm getheightdiff(treenode* ptn) heightdiff = 0; if (ptn == NULL) return 0; heightdiff = getheight(ptn->left() - getheight(ptn->right(); return heightdiff; end DS 7-47

48 Algorithm rebalance() Algorithm rebalance(treenode** pptn) heightdiff = getheightdiff(*pptn); if (heightdiff > 1) // L child is higher than R child if (getheightdiff(*pptn->left() > 0) *pptn = rotate_ll(*pptn); // L.L child is higher than L.R child else *pptn = rotate_lr(*pptn); // L.R child is higher than L.L child else if (heightdiff < -1) // R child is higher than L child if (getheightdiff(*pptn->right() < 0) *pptn = rotate_rr(*pptn); // R.R child is higher than R.L child else *pptn = rotate_rl(*pptn); // R.L child is higher than R.R child return *pptn; end DS 7-48

49 Algorithm rotate_ll() Algorithm rotate_ll(treenode* pparent) TreeNode* pchild; pchild = pparent->left(); pparent->setleft(pchild->right()); pchild->setright(pparent); return pchild; end h 2 A B h 3 diff 2 C D rotate_ll() h 3 diff 1 A B C D h diff 1 DS 7-49

50 Algorithm rotate_rr() Algorithm rotate_rr(treenode* pparent) TreeNode* pchild; pchild = pparent->right(); pparent->setright(pchild->left()); pchild->setleft(pparent); return pchild; end A h 3 diff -2 B C h 2 D rotate_rr() h diff 1 A B C h 3 diff 1 D DS 7-50

51 Algorithm rotate_lr(), rotate_rl() Algorithm rotate_lr(treenode* pparent) TreeNode* pchild; pchild = pparent->left(); pparent->setleft(rotate_rr(pchild)); return rotate_ll(pparent); end h 2 A B h 3 diff 2 C D setleft(rotate_rr()) h 2 diff 1 A B diff 2 C h 3 diff 3 D rotate_lr() h 2 diff 1 A h 3 diff 1 B C D DS 7-51

52 Algorithm rotate_lr(), rotate_rl() Algorithm rotate_rl(treenode* pparent) TreeNode* pchild; pchild = pparent->right(); pparent->setright(rotate_ll(pchild)); return rotate_rr(pparent); end A h 3 diff -2 h 2 C B D setright(rotate_cc( C )) A h 3 diff -3 B diff -2 C h 2 diff -1 D rotate_rr( B ) A B h 3 diff -1 C h 2 diff -1 D DS 7-52

53 Homework DS-7 DS-7.1 Projects P-7.2 (LinedBinaryTree using class template) DS-7.2 Projects P-7.11 (game tree for Tic-Tac-Toe) DS 7-53