Search Trees. Undirected graph Directed graph Tree Binary search tree

Transcription

1 Search Trees Undirected graph Directed graph Tree Binary search tree 1

2 Binary Search Tree Binary search key property: Let x be a node in a binary search tree. If y is a node in the left subtree of x, then y.key x.key. If y is a node in the right subtree of x, then y.key x.key. 2

3 Binary Search Tree Traversals: inorder outputs in non-decreasing order preorder postorder 3

4 Binary Search Tree Performance Theorem 12.1: If x is the root node of an n-node subtree, then the call INORDER-TREE-WALK(x) takes Θ(n) time. Proof: Let T(n) denote the time taken by INORDER-TREE-WALK when it is called on the root of an n- node subtree. Since INORDER-TREE-WALK must visit all n-nodes in the subtree, it follows that T(n) = Ω(n). Now we must show that T(n) = O(n). First note that T(0) = c, for some positive constant c > 0. 4

5 Binary Search Tree Performance Now suppose the left subtree T has k nodes. Then: T n T k + T n k 1 + d for some constant d > 0, where d represents the time for one execution of the procedures body, minus the recursive calls. The substitution method can be used to show that T(n) = O(n) by proving that: T n c + d n + c For n = 0, we have T(0) = c, and (c + d) * 0 + c = c. For n > 0, we have: T n T k + T n k 1 + d = c + d k + c + ( c + d n k 1 + c + d = c + d n + c 5

6 Binary Search Tree Querying a Binary Search Tree search minimum maximum predecessor/successor 6

7 Binary Search Tree if x has a right subtree otherwise it s the lowest ancestor of x that has a left child that is also an ancestor of x 7

8 8 Binary Search Tree

9 Binary Search Tree Performance Theorem 12.2: Search, Minimum, Maximum, Successor, and Predecessor operations can all be implemented to run in O(h) time on a binary search tree of height h. Proof: In all cases, the procedure either traverses a path from root to leaf, or from some node up to the root. Since the tree has height h, the amount of time used is O(h) 9

10 Binary Search Tree search, but with trailing parent pointer y at this point y points to the parent of z s final location 10

11 Binary Search Tree Deleting a node is a bit more complicated because we might have to replace it with some other node. What would you replace 15 with in the following tree? 11

12 Binary Search Tree There are 3 cases: z has no children z has one child z has two children 12

13 Binary Search Tree Case 3 is slightly non-trivial. Suppose we want to delete first, find the smallest value in this subtree 13

14 Binary Search Tree Welcome to pointer-fest 2018! The first procedure adjusts the pointers between the node to be moved and it s new parent. 14

15 Binary Search Trees The second procedure calls TRANSPLANT, and, if necessary, also adjusts the child pointers or the moved node. if z only has one child, simply move it up if z has two children: find the smallest in the right subtree replace z with that node 15

16 Binary Search Tree Performance Theorem 12.3: Insert and deleted operations can all be implemented to run in O(h) time on a binary search tree of height h. So what s missing in our analysis? Theorem 12.4: The expected height of a randomly built binary search tree on n distinct keys is O(lgn). 16

17 Binary Search Tree Performance 17

18 Binary Search Tree Performance 18

19 Binary Search Tree Performance Really? 19

20 Binary Search Tree Performance 20

21 Elementary Data Structures The proof makes use of three random variables X n the height of a randomly built binary search tree on n keys R n the rank of the key that is at the root of such a tree Z n,i = I {R n = i} an indicator random variable that indicates if the i th ranked element is at the root In summary: The proof calculates the expected height E[X n ] of the tree by averaging over all these variables. This equates to averaging over all possible binary search trees for the n keys. Note how this includes both degenerate and well-balanced trees. Note: The proof uses another variable Y n, the exponential height of the tree, as a proxy for X n. This makes the math easier, i.e., it allows Jenson s inequality to be used. 21

22 Red-Black Trees A red-black tree is a binary search tree where each node is either red or black. Node properties: color key left right P Note! NIL pointers are treated as if they point to a special node T.NIL which is a leaf. Each such leaf node has the same node properties, specified above. This helps with boundary conditions in the code. Huh? 22

23 Red-Black Trees NIL pointer nodes will be referred to as external nodes. Other nodes, those containing values, will be referred to as internal. 23

24 24 Red-Black Trees

25 25 Red-Black Trees

26 Red-Black Trees 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 it s children are black. 5. For each node, all simple paths from the node to descendant leaves contain the same number of black nodes. 26

27 Red-Black Trees 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 it s children are black. 5. For each node, all simple paths from the node to descendant leaves contain the same number of black nodes. Given a node x, the black-height of x, denoted bh(x), is equal to the number of black nodes on any simple path from, but not including, x down to a leaf. 27

28 Red-Black Trees Lemma 3.1: A red-black tree with n internal nodes has height at most 2lg(n+1). Proof: First, we show that the subtree rooted at a node x contains at least 2 bh(x) 1 internal nodes; this is done by induction on the height of x, denoted h(x). Basis: h(x)=0 Then x must be a leaf (T.NIL). Of course bh(t.nil) = 0, and hence 2 bh(x) 1 = = 0 Inductive Hypothesis: Suppose there exists a k 1 such that for any subtree rooted at any node x, where h(x) = k-1, the number of internal nodes in that subtree is at least 2 bh(x) 1 internal nodes. 28

29 Red-Black Trees Inductive Step: Now consider an internal node x such that h(x) = k 1. By definition of a red-black tree, x must have two children. The black-heights of these children must be either bh(x) or bh(x) 1, and hence, each must be at least bh(x) 1. Also, since the h(x) = k, the height of these children must be k 1, and by induction it follows that the number of internal nodes in each child is at least 2 bh(x) Thus, the number of nodes in the subtree rooted at x is: (2 bh(x) - 1 1) + (2 bh(x) - 1 1) + 1 = 2*(2 bh(x) - 1 1) + 1 = 2 bh(x) 1 29

30 Red-Black Trees Now let x be the root of a red-black tree. By property #4 of a red-black tree, at least half of the nodes on a simple path from x to leaf must be black (why?). Consequently, the bh(x) h(x)/2, and thus: n 2 h(x)/2 1 Adding 1 to both sides and taking the log of both sides gives: h(x) 2lg(n+1) 30

31 Red-Black Trees Corollary: Search, Minimum, Maximum, Successor, and Predecessor operations can all be implemented in O(lgn) time on a red-black tree (with slight modification to the BST operations to accommodate the T.NIL nodes). 31

32 Red-Black Trees How about Insert and Delete? Can we just use the BST Insert and Delete operations? The resulting trees would be BSTs, but not necessarily maintain the redblack properties. Can we modify them? Yes! Insert and Delete for red-black trees will: use BST Insert and Delete procedures modify the resulting trees pointer structure using a rotation operation recolor nodes to ensure properties 4 & 5 are satisfied 32

33 Red-Black Trees Rotation operations: Notes: (both important) only 6 pointer adjustments (constant time) maintains the BST property 33

34 34 Red-Black Trees

35 35 Red-Black Trees

36 Red-Black Trees normal BST search, but with trailing parent pointer y z is either the root the left child or right child of y set z to red (new nodes are always red) at this point y points to the parent of z s final location z is a leaf so set it s children to T.nil rebalance and recolor the tree 36

37 37 Red-Black Trees

38 Red-Black Trees After the algorithm terminates: the resulting tree is a BST properties 1-5 of a red-black tree are satisfied Red-black Tree 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 it s children are black. 5. for each node, all simple paths from the node to descendant leaves contain the same number of black nodes. 38

39 Red-Black Trees BST => preserved by the rotation operation Proving properties 1 3 is relatively easy (how?) Proving properties 4 & 5 require a bit more work (>5 pages in the book). 39

40 Red-Black Trees Intuitively, the insert creates the following situation: If node 5 were black, the loop would terminate Since it is red, the algorithm will push the problem up the tree using rotation and node recoloring 40

41 Red-Black Trees To determine how to rotate and recolor, it looks at node z s uncle. In this case (#1), the uncle is red, so it recolors it s parent and the uncle black. notice how this pushed the problem up one level. z is now updated to be the lower of the two mis-colored nodes. 41

42 Red-Black Trees As the algorithm pushes the problem up, if it sees that the uncle of z is already black, then: z is a right child left rotation, followed by a right rotation (case #2) z is a left child right rotation (case #3) both sub-cases do recoloring in this case z is a right child so first a left-rotation 42

43 Red-Black Trees and then the right rotation in this case the parent of z is black so the algorithm terminates (the problem is gone) if the problem had propagated to the root then line 16 would simply recolor the root black 43

44 Red-Black Trees Case #1, more abstractly: 44

45 Red-Black Trees Cases #2 and #3, more abstractly: 45

46 Red-Black Trees What is the running time to insert? RB-Insert iterates z from root to leaf (BST search) and so uses O(lgn) time. RB-Insert-Fixup iterates z from leaf to root, skipping every other level, and so also uses O(lgn) time. Collectively, this gives O(lgn) time. 46

47 Red-Black Trees How about delete? 47

48 48 Red-Black Trees

49 Red-Black Trees What is the running time to delete? Transplant takes O(1) time. Minimum takes O(lgn) time. Consequently, RB-Delete takes O(lgn) time. Left and Right Rotate takes O(1) time. RB-Delete-Fixup iterates x from leaf to root, and so also uses O(lgn) time. Collectively, this gives O(lgn) time. 49

50 Red-Black Trees There are many self-balancing versions of binary search trees: Red-black trees AVL tree WAVL tree 2-3 tree B-tree T-tree Scapegoat tree Splay tree Treap Weight-balanced tree All have O(lgn) search, insert, delete, min, max, successor, predecessor, insert and delete operations. Some are more balanced than others (AVL vs. Red-black), some use slightly more time or space (B-trees), others are easier to code (Red-black). Many use the same rotation, or similar, operation during insert. 50