8. Binary Search Tree

Transcription

1 8 Binary Search Tree

2 Searching Basic Search Sequential Search : Unordered Lists Binary Search : Ordered Lists Tree Search Binary Search Tree Balanced Search Trees (Skipped)

3 Sequential Search int Seq-Search (list [], X) { int i; while( i < n ) { /* n: array size */ if (X == list [i]) return (i); else i=i+1; } printf( Search fails!\n ); } [0] [1] [2] [3] [4] [] [6] list X i list[0]==x? No! list X i list[1]==x? No! list X i list[2]==x? No! list X return(3); i list[2]==x? Yes!

4 Binary Search int Bin-Search (list [], X, left, right) { int mid; [0] [1] [2] [3] [4] [] [6] while (left <= right) { list 1 4 X } } mid = (left + right) / 2; if (X < list [mid]) right = mid - 1; else if (X == list [mid]) else return (mid); left = mid + 1; left front part rear part list(mid)=6 > X rear part list 1 4 X left front part list(mid) =4 < X right list 1 4 X right return(2); list(mid) left right =X

5 Binary Search list = (4, 1, 17, 26, 30, 46, 48, 6, 8, 82, 90, 9) : Sorted 46 [] [2] [8] 17 8 < > [0] [3] [6] [10] > > < > [1] [4] [7] [9] [11] Decision Tree for Binary Search The path from root to any node represents a sequence of comparisons

6 Sequential Search Performance A list should be scanned left to right; thus, time complexity is O(n) Binary Search Size of each list is decreased by half down; n, n/2, n/4,, n/2 k Number of search passes (= k) is n/2 k = 1; thus, k = O(log 2 n) Time complexity becomes O(log 2 n) Pros and Cons (of Binary Search) The list must be sorted in advance Searching itself is efficient Insertion and deletion cost overhead is high

7 Binary Search Tree (BST) Definition It is a Binary Tree Every node has a key Every node s key, K is larger than all keys in its left subtree smaller than all keys in its right subtree K All<K left subtree All>K right subtree

8 BST : Examples Valid Binary Search Trees (a) (b) (c) Invalid Binary Search Trees (a) 17 (b)

9 BST : Linked List Implementation Node Definition typedef struct node *BST_ptr; typedef struct node { BST_ptr left_child; int data; BST_ptr right_child; } T left_ child data right_ child all keys < T->data all keys > T->data

10 BST : Linked List Implementation Binary Search Tree 0 Linked List Representation 0 root

11 Searching We wish to Search for a Node in BST, whose key is the target value BST_ptr SEARCH (BST_ptr T, int target) { /* return a pointer to the node with target key if no node exists, return T points to the root */ Search(T->left, 6) } if (T == ), return ; /* Empty or Failure */ if (target == T -> data) return T; /* Success */ if (target < T -> data) return SEARCH (T -> left_child, target); /* T moves to the left child */ if (target > T -> data) return SEARCH (T -> right_child, target) /* T moves to the right child */ Search(T->left->right, 6)

12 Searching : Examples Target Key = 2 Target Key = 3 10>2, left 10<3, right >2, left >3, left 2=2, found <3, 2 right , Not found Number of Comparisons: 3 Number of Comparisons: 4

13 Insertion Insert a new key into BST Use SEARCH algorithm first; Then, If the key is already in a BST, do nothing; Otherwise, add the key into a BST; 7 Insert Insertion position is always at left null or right null link of leaf node After Inserting After Inserting 42

14 Insertion : Example Insert (20) 10 10<20, right 30 30>20, left Insert 20 at left 20 2>20, left 20 The address of node 20 is assigned to the left child of node 2

15 Performance : BST Searching/Insertion time are bounded by O(h) where h is the height of the BST h : height BST Height of BST depends on the Shape of BST Shape of BST depends on the order of Insertions

16 height=3 Performance : BST Order of Insertions vs Shape of BST height= BST for data sequence: {10, 30,, 2, 40, 2} BST for data sequence: {, 40, 2, 30, 10, 2}

17 n log n Performance : BST If BST is evenly Balanced Time complexity: O(log n) How to construct a good shape? If BST is highly Skewed Time Complexity: O(n)

18 Deletion To Delete a Node, Use SEARCH algorithm first; Then, If found, do the delete process; Otherwise, return error 7 Three Cases exist wrt the delete node 1) The Node has No Child : Just delete the node! 9 2) The Node has a Single Child : After deleting the node, its child is pushed upward! ) The Node has two Children : Do Two steps Step 1: Find a node with smallest/largest key from right/left subtree Step 2: Replace the delete node with the found node

19 Case 1 : Leaf node Ex) Delete (2) Deletion : Leaf Node 10 10<2, right 10 20=2, found 30 30>2, left At first, search for the delete node and delete it Set the Link of Parent of the delete node to Null Return the delete node back to the storage pool

20 Deletion : Node with Degree 1 Case 2 : Node with a Single Child Ex) Delete (1) 20>1, left <1, right 10 1=1, found At first, search for the delete node and delete it Set the Link of Parent of the delete node to the address of the child of the delete node (ie, points to the child of the delete node) Return the delete node back to the storage pool

21 Deletion : Node with Degree 2 Case 3 : Node with Two Children Ex) Delete (10) 10=10, found Smallest! Find the delete node and delete it Search for the smallest (or largest) node from right (or left) subtree Replace the delete node with the smallest (or largest) node Return the delete node back to the storage pool

22 Finding Smallest (Largest) Key in BST Is Any Problem Brought about in Case 3? No! because the Node with Smallest (or Largest) key from right (or left) subtree has at most One Child (ie, Its degree is 0 or 1) Left Subtree 46 Right Subtree 17 Move! Smallest! 2 1 Largest! Case 1 Case 2

23 Performance Comparison Worst Case Average Case Search Insert Delete Search Insert Delete Sorted Array log 2 n n n log 2 n n/2 n/2 Unsorted Linked List n 1 n n/2 1 n/2 Binary Search Tree n n n log 2 n log 2 n log 2 n