Different binary search trees can represent the same set of values (Fig.2). Vladimir Shelomovskii, Unitech, Papua New Guinea. Binary search tree.

Transcription

1 1 Vladimir Shelomovskii, Unitech, Papua New Guinea, CS411 Binary search tree We can represent a binary search tree by a linked data structure in which each node is an object. Each node contains (Fig.1): key (an integer value for searching the object), satellite data (any data need for using, connected with the key) left a pointer to the left child, right a pointer to the right child, p a pointer to the parent. If the child or the parent is missing, the appropriate attribute contains the value NIL. The root node is the only node in the tree whose parent is NIL. NIL's shown by yellow in Fig.1. The keys in a binary search tree are always stored in such a way as to satisfy the binary-search-tree property: Let x be a node in a binary search tree. If y is a node in the left subtree of x, then x.key y.key. If y is a node in the right subtree of x, then x.key y.key. For any node x, the keys in the left subtree of x are at most x.key, and the keys in the right subtree of x are at least x.key. Fig.1. Each node has attributes: key, p, left, and right. The sketch (in the upper right corner) has not NIL details. In the next figures the pairs of the arrows changed to segments. The key of the root object is 6, the keys 2, 5, and 5 are in its left subtree, they are no larger than 6, and the keys 7 and 8 in its right subtree are no smaller than 6. The same property holds for every node in the tree. The key 5 in the root s left child is no smaller than the key 2 in the node s left subtree and no larger than the key 5 in the right subtree. Different binary search trees can represent the same set of values (Fig.2).

2 2 Fig.2. The tree has the same set of values, the same nodes as tree in Fig. 1, but the connection of the nodes is different Keys printing The binary-search-tree property allows us to print out all keys in a binary search tree (or all keys in x-subtree) in sorted order by a recursive algorithm, called an inorder tree walk. This algorithm prints the key of the root of a subtree between printing the values in its left subtree and printing those in its right subtree. It uses the pointer to the element x for working. To print all the elements in a binary search tree T, we call INORDER-TREE-WALK(T.root) = ITW(T.root). ITW(x) 1 if x NIL then 2 ITW(x.left) 3 print x.key 4 ITW(x.right) end if We use colors and show the in-order tree walk in the case, shown of figure: ITW(pointer to 6) 6 NIL ITW(5 = 6.left) 5 NIL ITW(2 = 5.left) 2 NIL ITW(NIL = 2.left) print(2) ITW(NIL = 2.right) print(5) ITW(5 = 5.right) 5 NIL ITW(NIL = 5.left) print(5) ITW(6 = 5.right) 6 NIL ITW(NIL= 6.left) print(6) ITW(NIL=6.right) print(6) ITW(7 = 6.right) 7 NIL ITW(6 = 7.left) 6 NIL ITW(NIL = 6.left) print(6) ITW(NIL = 6.right)

3 3 print(7) ITW(8 = 7.right) 8 NIL ITW(NIL = 8.left) print(8) ITW(NIL = 8.right) Hence the procedure prints keys in the following order: 2, 5 (green), 5 (indigo), 6 (broun), 6 (root), 6 (pink), 7, 8.

4 4 Searching in a binary search tree We use the following procedure to search for a node with a given key k in a binary search tree. Given a pointer x to the root of the tree and a key k, TREE-SEARCH returns a pointer to a node with the key k if one exists; otherwise, it returns NIL. TREE-SEARCH(x, k) 1 if x = NIL or k = x.key (We do this if we get at most one YES) 2 return x 3 if k < x.key (We do this if we get NO and NO in line 1) 4 TREE-SEARCH(x.left, k) 5 else TREE-SEARCH(x.right, k) The procedure begins its search at the root and traces a simple path downward in the tree. For each node x it encounters, it compares the key k with x.key. If two keys are equal, the search terminates. If k is smaller than x.key, the search continues in the left subtree of x. Symmetrically, if k is larger than x.key, the search continues in the right subtree. We use the notation TREE-SEARCH = TS. To search for the object with the key = 13 in the tree with the root 15, use TS(pointer to 15, 13) and follow the path: x = NIL or k = x.key (NO or NO) k < x.key 13 < 15 TS(15.left = pointer to 6, 13) k > x.key 13 > 6 TS(6.right = pointer to 7, 13) k > x.key 13 > 7 TS(7.right = pointer to 13, 13) x = NIL or k = x.key (NO or YES) 13 = 13 return 7.right = pointer to 13. We get the pointer to 13. To search for the object with the key = 14 in the tree with the root 15, use TS (pointer to 15, 14) and follow the path: x = NIL or k = x.key (NO or NO) k < x.key 14 < 15 TS(15.left = pointer to 6, 14) k > x.key 14 > 6 TS(6.right = pointer to 7, 14) k > x.key 14 > 7 TS(7.right = pointer to 13, 14) k < x.key 14 >13 TS(13.right = NIL, 14) x = NIL or k = x.key (YES or NO) return 13.right = NIL. We can rewrite this procedure in an iterative fashion by unrolling the recursion into a while loop. On most computers, the iterative version is more efficient. ITERATIVE-TREE-SEARCH(x, k) 1 while x NIL and k x.key (We do this if we get YES and YES) 2 if k < x.key 3 then x = x.left 4 else x = x.right

5 5 5 return x (We do this if we get at most one NO)

6 6 Minimum and maximum We can always find an element in a binary search tree whose key is a minimum by following left child pointers from the root until we encounter a NIL. The following procedure returns a pointer to the minimum element in the subtree rooted at a given node x, which we assume to be non-nil: TREE-MINIMUM(x) 1 while x.left NIL 2 x = x.left (We do this if we get YES in line 1) 3 return x (We do this if we get NO in line 1) The pseudo-code for TREE-MAXIMUM is symmetric: TREE-MAXIMUM(x) 1 while x.right NIL 2 x = x.right 3 return x To search for the object with the minimum key in the tree with the root 6, use TREE-MINIMUM (pointer to 6) and follow the path: TREE-MINIMUM (pointer to root 6) 6.left NIL YES x = pointer to 5 5.left NIL YES x = pointer to 2 2.left NIL NO return x = pointer to 2

7 7 Successor and predecessor Given a node in a binary search tree, we need to find its successor in the sorted order determined by an inorder tree walk. If all keys are distinct, the successor of a node x is the node with the smallest key greater than x.key. The structure of a binary search tree allows us to determine the successor of a node without ever comparing keys. The following procedure returns the successor of a node x in a binary search tree if it exists, and NIL if x has the largest key in the tree: TREE-SUCCESSOR(x) 1 if x.right NIL 2 return TREE-MINIMUM(x.right) (We do this if we get YES in line 1) 3 y = x.p 4 while y NIL and x = y.right 5 x = y (We do this if we get YES and YES in line 4) 6 y = y.p 7 return y (We do this if we get at most one NO in line 4) We break the code for TREE-SUCCESSOR into two cases. Case 1. The right subtree of the node x is nonempty, x.right NIL. The successor of x is just the leftmost node in x s right subtree, which we find in line 2 by calling TREE-MINIMUM(x.right). We can find the successor of the node with the key 7 using TREE-SUCCESSOR(7) TREE-SUCCESSOR(7) 1 if x.right NIL YES (7.right = 13) 2 return TREE-MINIMUM(7) = pointer to 9. Case 2. The right subtree of the node x is empty, x.right = NIL. If x has a successor y, then y is the lowest ancestor of x whose left child is also an ancestor of x. We can find the successor of the node with the key 13: To find y, we simply go up the tree from x until we encounter a node that is the left child of its parent; lines 3 7 of TREE-SUCCESSOR handle this case. TREE-SUCCESSOR(13) 1 if x.right NIL NO (13.right = NIL) 3 y = x.p y = 13.p = pointer to 7 4 while y NIL and x = y.right (YES and YES: 13 = 7.right) 5 x = y x = 7 6 y = y.p y = 7.p = pointer to 6 4 y NIL and x = y.right (YES and YES: 7 = 6.right) 5 x = y x = 6 6 y = y.p y = 6.p = pointer to 15 4 y NIL and x = y.right (YES and NO: 6 = 15.right) 7 return y = pointer to 15

8 8 The procedure TREE-PREDECESSOR is symmetric to TREE-SUCCESSOR. Even if keys are not distinct, we define the successor and predecessor of any node x as the node returned by calls TREE-SUCCESSOR(x) and TREE-PREDECESSOR(x), respectively.

9 9 Insertion The operations of insertion and deletion cause the dynamic set represented by a binary search tree to change. The data structure must be modified to reflect this change, but in such a way that the binary-search-tree property continues to hold. To insert a new value into a binary search tree, we use the procedure TREE-INSERT. The procedure takes a node z for which z.key = z 0, z.left = NIL, and z.right = NIL. It modifies T and some of the attributes of z in such a way that it inserts z into an appropriate position in the tree. TREE-INSERT(T, z) 1 y = NIL 2 x = T.root 3 while x NIL 4 y = x 5 if z.key < x.key 6 x = x.left 7 else x = x.right 8 z.p = y 9 if y = NIL 10 T.root = z // tree T was empty 11 else if z.key < y.key 12 y.left = z 13 else y.right = z Figure shows how TREE-INSERT works. Just like the procedure TREE-SEARCH it begins at the root of the tree and the pointer x traces a simple path downward looking for a NIL to replace with the input item z. The procedure maintains the trailing pointer y as the parent of x. After initialization, the while loop in lines 3 7 causes these two pointers to move down the tree, going left or right depending on the comparison of z.key with x.key, until x becomes NIL. This NIL occupies the position where we wish to place the input item z. We need the trailing pointer y, because by the time we find the NIL, the search has proceeded one step beyond the node that needs to be changed. Lines 8 13 set the pointers that cause z to be inserted. Let z be: z = (z.key = 13, z.left = NIL, z.right = NIL, z.p) TREE-INSERT(T, z): 1 y = NIL, 2 x = T.root = pointer to 12 Step 1, x = pointer to 12 3 while x NIL YES 4 y = pointer to 12, 5 z.key =13 > x.key = 12 7 x = x.right = pointer to 18 8 z.p = y = pointer to z.key =13 > y.key = y.right = pointer to 13

10 10 Step 2, x = pointer to 18 3 while x NIL, YES: x = pointer to 18 4 y = x = pointer to 18 5 z.key =13 < x.key = 18 6 x = x.left = pointer to 15 8 z.p = y = pointer to z.key =13 < y.key = y.left = pointer to 13 Step 3, x = pointer to 15 3 while x NIL, YES: x = pointer to 15 4 y = x = pointer to 15 5 z.key =13 < x.key = 15 6 x = x.left = 15.left = NIL 8 z.p = y = pointer to z.key =13 < y.key = y.left = 15.left = pointer to 13 Finish 3 while x = NIL NO: x = NIL Exit The result: z = (z.key = 13, z.left = NIL, z.right = NIL, z.p = pointer to 15) y = (y.key = 15, y.left = pointer to 13, y.right = pointer to 17, y.p = pointer to 18) We need to change the object in table with the key = 15 by the object y.

11 11 Transplantation A subroutine TRANSPLANT replaces one subtree as a child of its parent with another subtree. TRANSPLANT replaces the subtree rooted at the node u with the subtree rooted at the node v: the node u s parent becomes the node v s parent, the node u s parent ends up having v as its appropriate child. If v = NIL, the procedure deletes the subtree rooted at the node u. TRANSPLANT(T, u, v) 1 if u.p = NIL 2 T.root = v else 3 if u = u.p.left 4 u.p.left = v 5 else u.p.right = v 6 if v NIL 7 v.p = u.p Case 1: u is the root of T: u.p = NIL. Lines 1 2 handle this case by changing T.root = v. Line 7 updates v.p = u.p if v is non-nil. Case 2: u is a left child of its parent,v is non-nil: 3 u = u.p.left 4 Line 4 takes care of updating u.p.left = v. 7 Line 7 updates v.p = u.p. Case 3: u is a right child of its parent, v is non-nil: 3 u u.p.left, hence u = u.p.right. 5 Line 5 updates u.p.right = v. 7 Line 7 updates v.p = u.p. Case 3, before TRANSPLANT Case 3, after TRANSPLANT Case 4: v = NIL. If u is a right child of its parent, line 5 updates u.p.right = NIL. If u is a left child of its parent, line 4 updates u.p.left = NIL.

12 Case 4, before TRANSPLANT Case 4, after TRANSPLANT Note that TRANSPLANT does not update v.left and v.right. 12

13 13 Deletion The procedure for deleting a given node z from a binary search tree T takes as arguments pointers to T and z. The procedure is: TREE-DELETE(T, z) if 1 z.left = NIL 2 TRANSPLANT(T, z, z.right) else if 3 z.right = NIL 4 TRANSPLANT(T, z, z.left) else 5 y = TREE-MINIMUM(z.right) 6 if y.p z 7 TRANSPLANT(T, y, y.right) 8 y.right = z.right 9 y.right.p = y 10 TRANSPLANT(T, z, y) 11 y.left = z.left 12 y.left.p = y The overall strategy for deleting a node z from a binary search tree T has four basic cases. Case 1: z has no children. z.left = NIL and z.right = NIL. We remove it by modifying its parent to replace z with NIL as its child. TREE-DELETE(T, z) call 2 TRANSPLANT(T, z, z.right = NIL). The procedure deletes the subtree rooted at the node z, hence deletes z. Case 1, before DELETE Case 1, after DELETE Case 2: z has just one child. z.left = NIL or z.right = NIL. We elevate that child to take z s position in the tree by modifying z s parent to replace z by z s child. Case 2a 1 If z.left = NIL 2 TRANSPLANT(T, z, z.right). Case 2b 3 If z.right = NIL 4 TRANSPLANT(T, z, z.left).

14 14 Case 2b, before DELETE Case 2b, after DELETE Case 3,4: z has two children. We find z s successor y. Successor y is in z s right subtree. Case 3: z has two children. Successor y is z s right child. TREE-DELETE(T, 18) successor y = 19 y.right = TRANSPLANT(T, z, y) 11 y.left = z.left 12 y.left.p = y Case 3, before DELETE Case 3, after TRANSPLANT Case 3, after DELETE Case 4: z has two children. Successor y is not z s right child. We splice y out of its current location and have it replace z in the tree. The rest of z s original right subtree becomes y s new right subtree, and z s left subtree becomes y s new left subtree. TREE-DELETE(T, 12) successor y = 13 y.right = 14 7 TRANSPLANT(T, y, y.right) 10 TRANSPLANT(T, z, y) 8 y.right = z.right 11 y.left = z.left 9 y.right.p = y 12 y.left.p = y Case 4, before DELETE Case 4, after 7, 8, 9 Case 4, after DELETE

15 15 Red-black trees A red-black tree is a binary search tree with one extra bit of storage per node: its color, which can be either RED or BLACK. By constraining the node colors on any simple path from the root to a leaf, red-black trees ensure that no such path is more than twice as long as any other, so that the tree is approximately balanced. Each node of the tree now contains the attributes color, key, left, right, and p. If a child or the parent of a node does not exist, the corresponding pointer attribute of the node contains the value NIL. We shall regard these NILs as being pointers to leaves (external nodes) of the binary search tree and the normal, key-bearing nodes as being internal nodes of the tree. A red-black tree is a binary tree that satisfies the following red-black properties: 1. Every node is either red or black. 2. The root is black. 3. Every leaf (NIL) is black. 4. If a node is red, then both its children are black. 5. For each node, all simple paths from the node to descendant leaves contain the same number of black nodes. The Lecture Hash tables is the part of the undergraduate course CS411 Introduction to Algorithms by Ass. Prof. V. Shelomovskii for University of Technology, Lae, Papua New Guinea. The base of the Lecture course is: Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein. Introduction to Algorithms. Third Edition. The MIT Press, Cambridge, Massachusetts London, England, 2009.