Data Structures And Algorithms

Transcription

1 Data Structures And Algorithms Binary Trees Eng. Anis Nazer First Semester

2 Definitions Linked lists, arrays, queues, stacks are linear structures not suitable to represent hierarchical data, for example folders in an operating system So... Trees

3 Example Departments in a university Philadelphia Engineering Science Business administration Computer Electrical Mechanical Mathematics Chemistry Accounting Marketing

4 Definitions like an upside down actual tree A tree has nodes and arcs root node is at the top leaves at the bottom root node has no parent, leaf nodes have no childern

5 Single node Examples

6 Examples

7 Definitions Every node must be reachable from the root node the sequence of arcs to reaching a node is called a path the path to a node is unique the number of arcs in a path is called the length of the path the level of a node is the number of arcs between the root and the node plus one a node can have any number of children including 0 (leaves)

8 Trees Why use trees? represent hierarchical data store data in a tree to speedup search and sort operations think of other applications where tree structures are useful

9 Binary Trees Binary tree: each node can have zero, one, or two children left child, right child Examples:

10 Example Root: A Leaves: level of D: nodes at level 4: B C non-terminal nodes: D E F G

11 Example Root: A A Leaves: E,F, G level of D: 3 nodes at level 4: F, G B C non-terminal nodes: A, B, C, D D E F G

12 Complete Binary tree Complete binary tree: all nodes have two children except leaf nodes number of nodes at level i: 2 i 1 number of non-terminal nodes: m number of leaves: k relation: k = m + 1

13 Binary search tree Binary search tree is a binary tree where for a node n: all values of nodes in the left subtree are less than the value of node n all values of nodes in the right subtree are greater than the value of node n node values are unique, no repetition

14 Example Binary Search tree:

15 Binary search tree Binary search tree simplifies the search: Algorithm: visit node: if value = key stop if key < value, visit left node if key > value, visit right node can be implemented using a recursive function or a non recursive function Complexity?

16 Example Search for < 13, visit left 9 < 10, visit left 9 > 7, visit right = 9, key found

17 Inserting a Node Insert a node in a BST search for the correct location add a new node Example: 15, 4, 20, 17, 19, 25

18 Inserting a Node Example: 15, 4, 20, 17, 19, 25 15

19 Inserting a Node Example: 15, 4, 20, 17, 19,

20 Inserting a Node Example: 15, 4, 20, 17, 19,

21 Inserting a Node Example: 15, 4, 20, 17, 19,

22 Inserting a Node Example: 15, 4, 20, 17, 19,

23 Inserting a Node Example: 15, 4, 20, 17, 19,

24 Class BSTNode Implementation BSTNode + data : int + left : BSTNode * + right : BSTNode * + BSTNode() + BSTNode(int d, BSTNode * L = NULL, BSTNode * R = NULL)

25 Class BSTNode Implementation class BSTNode { public: int data; BSTNode *left, *right; BSTNode() { left = right = NULL; }; BSTNode(int d, BSTNode *L = NULL, BSTNode *R = NULL) { data = d; left = L; right = R; } };

26 Class BST Implementation BST root : BSTNode * + BST() + ~BST() + clear() : void clear(bstnode *) : void + search( int key ) : int * + recursivesearch( int key ) : int * recursivesearch( BSTNode * p, int key ) : int * + insert(int d) : void

27 Class BST Implementation class BST { public: BST() { root = NULL; }; ~BST() { clear(root); }; void clear( ); int * search( int key ); int * recursivesearch( int key ); void insert(int d); private: void clear(bstnode *p ); int * recursivesearch( BSTNode *p, int key ); BSTNode * root; };

28 Implementation clear() void BST::clear( ) { clear( root ); root = NULL; } void BST::clear(BSTNode *p ) { if (p!= NULL) { clear(p >left); clear(p >right); delete p; } }

29 Implementation search() int * BST::search( int key ) { BSTNode *p = root; while ( p!= NULL ) { if ( p >data == key ) return & p >data; else if ( key < p >data ) p = p >left; else p = p >right; } return NULL; }

30 recursivesearch() Implementation int * BST::recursiveSearch( int key ) { return recursivesearch(root, key); } int * BST::recursiveSearch( BSTNode *p, int key ) { if ( p!= NULL ) { if ( p >data == key ) return & p >data; else if ( key < p >data ) return recursivesearch( p >left, key ); else return recursivesearch( p >right, key ); } return NULL; }

31 Implementation insert() void BST::insert( int d ) { // get the correct location BSTNode *p, *q; p = q = root; while ( p!= NULL ) { q = p; if ( d < p >data ) p = p >left; else p = p >right; } // place node in the correct position if ( root == NULL ) root = new BSTNode(d); else if ( d < q >data ) q >left = new BSTNode(d); else q >right = new BSTNode(d); }

32 Implementation main() int main() { BST x; x.insert(15); x.insert(4); x.insert(20); x.insert(17); x.insert(19); x.insert(25); int n; cout << "Enter a number: "; cin >> n; int *ptr; ptr = x.recursivesearch(n); if ( ptr!= NULL ) cout << *ptr << " is found in the tree" << endl; else cout << n << " is not found in the tree" << endl; } return 0;

33 Tree traversal Traversing a tree: visit each node only once lot of combinations to do this ex: take a tree of 4 nodes

34 Definitions ex: take a tree of 4 nodes 15, 4, 20, 17 15, 17, 20, , 20, 17, how many combinations? n!

35 Definitions Not all traversals are useful Two traversals are of interest: Breadth first traversal Depth first traversal

36 Breadth first Breadth first: start with n = 1 visit nodes at level n (left to right, or right to left) visit nodes at level n+1 repeat until you visit all nodes

37 Example What is the sequence of nodes using breadth first traversal? 15, 4,20, 1, 17,

38 Implementation To implement the breadth first traversal, you can use a queue Algorithm: enqueue root while ( queue not empty ) 15 dequeue node if there is a left child enqueue left child if there is a right child enqueue right child

39 Depth first Depth first: go as far as possible to the left (or right) backup to the first crossroad go to the right (or left) go as far as possible to the left (or right) repeat until all nodes are visited

40 Depth first Assume: V: visit, R: right, L: left six options: VLR VRL LVR RVL LRV RLV Assuming left before right three options

41 Depth first Assuming always left then right, only three traversals: VLR: preorder traversal LVR: inorder traversal LRV: postorder traversal

42 Preorder What is the sequence of nodes using preorder traversal? VLR 15 15, 4, 1, 20, 17,

43 Inorder What is the sequence of nodes using inorder traversal? LVR 15 1, 4, 15, 17, 20,

44 Postorder What is the sequence of nodes using postorder traversal? LRV 15 1, 4, 17, 25, 20,

45 Example What is the sequence of nodes using preorder, inorder, postorder traversal?

46 Implementation Depth first traversal can be implemented easily using recursive functions preorder() void BST::preorder(BSTNode *p) { if ( p!= NULL ) { visit(p); preorder(p >left); preorder(p >right); } }

47 Implementation Depth first traversal can be implemented easily using recursive functions inorder() void BST::inorder(BSTNode *p) { if ( p!= NULL ) { inorder(p >left); visit(p); inorder(p >right); } }

48 Implementation Depth first traversal can be implemented easily using recursive functions postorder() void BST::postorder(BSTNode *p) { if ( p!= NULL ) { postorder(p >left); postorder(p >right); visit(p); } }

49 Implementation Easily using recursion Any doubts? try the non recursive implementation...good luck

50 How to delete a node three cases: if the node is a leaf if the node has one child if the node has two children merge or copy

51 Case 1: leaf If the node is a leaf, delete it directly Ex. delete

52 Case 1: leaf

53 Case 2: single child if the node has a single child make the parent point to the child 37 delete the node Ex. delete make 21 point to 7 delete

54 Case 2: single child Ex. delete 15 make 21 point to 7 37 delete

55 Case 2: single child Ex. delete 15 make 21 point to 7 37 delete

56 Case 3: 2 children if the node has 2 children two methods: merge copy

57 Case 3: 2 children Merge: 1) find the rightmost node in the left subtree 2) attach the right subtree to the right of the node in step 1 3) delete the node ( similar to the case of a single child)

58 Case 3: 2 children Ex. delete

59 Case 3: 2 children 1) find the rightmost node in the left subtree

60 Case 3: 2 children 1) find the rightmost node in the left subtree

61 Case 3: 2 children 2) attach right subtree to the right of node in step

62 Case 3: 2 children 2) attach right subtree to the right of node in step 1 37 Right subtree

63 Case 3: 2 children 2) attach right subtree to the right of node in step

64 Case 3: 2 children 3) delete the node as the case of a single child

65 Case 3: 2 children 3) delete the node as the case of a single child

66 Case 3: 2 children Other method Copy: 1) find the rightmost node in the left subtree 2) replace value of node with node in step 1 3) delete the node of step 1 (the node is either a leaf or has a single child)

67 Case 3: 2 children Ex. delete

68 Case 3: 2 children 1) find the rightmost node in the left subtree

69 Case 3: 2 children 1) find the rightmost node in the left subtree

70 Case 3: 2 children 2) swap 33 with

71 Case 3: 2 children 2) swap 33 with

72 Case 3: 2 children 3) delete

73 Case 3: 2 children 3) delete