Search Trees - 2. Venkatanatha Sarma Y. Lecture delivered by: Assistant Professor MSRSAS-Bangalore. M.S Ramaiah School of Advanced Studies - Bangalore

Transcription

1 Search Trees - 2 Lecture delivered by: Venkatanatha Sarma Y Assistant Professor MSRSAS-Bangalore 11

2 Objectives To introduce, discuss and analyse the different ways to realise balanced Binary Search Trees To discuss in detail the properties and performance of Red- Black Trees and Splay Trees To illustrate the use of balanced trees for Searching To highlight the relative advantages of different balanced trees for Sorting 2

3 Red-Black Trees 3

4 From (2,4) to Red-Black Trees A red-black tree is a representation of a (2,4) tree by means of a binary tree whose nodes are colored red or black In comparison with its associated (2,4) tree, a red-black tree has same logarithmic time performance simpler implementation with a single node type 4

5 Red-Black Trees A red-black tree can also be defined as a binary search tree that satisfies the following properties: Root Property: the root is black External Property: every leaf is black Internal Property: the children of a red node are black Depth Property: all the leaves have the same black depth 5

6 Height of a Red-Black Tree Theorem: A red- black tree storing n entries has height O(log n) Proof: The height of a Red-Black tree is at most twice the height of its associated (2,4) tree, which is O(log n) The search algorithm for a binary search tree is the same as that for a binary search tree By the above theorem, searching in a Red-Black tree takes O(log n) time 6

7 Insertion To perform operation insert(k, o), we execute the insertion algorithm for binary search trees and color red the newly inserted node z unless it is the root We preserve the root, external, and depth properties If the parent v of z is black, we also preserve the internal property and We are done Else (v is red ) we have a double red (i.e., a violation of the internal property), which requires a reorganization of the tree Example where the insertion of 4 causes a double red: 7

8 Remedying a Double Red Consider a double red with child z and parent v, and let w be the sibling of v Case 1: w is black The double red is an incorrect replacement of a 4-node Restructuring: we change the 4- node replacement Case 2: w is red The double red corresponds to an overflow Recoloring: we perform the equivalent of a split 8

9 Restructuring A restructuring remedies a child-parent double red when the parent red node has a black sibling It is equivalent to restoring the correct replacement of a 4-node The internal property is restored and the other properties are preserved 9

10 Restructuring There are four restructuring configurations depending on whether the double red nodes are left or right children 10

11 Re-colouring A recoloring remedies a child-parent double red when the parent red node has a red sibling The parent v and its sibling w become black and the grandparent u becomes red, unless it is the root It is equivalent to performing a split on a 5-node The double red violation may propagate to the grandparent u 11

12 Re-colouring Example 12

13 Algorithm insert(k, o) 1. We search for key k to locate the insertion node z 2. We add the new entry (k, o) at node z and color z red 3. while doublered(z) if isblack(sibling(parent(z) )) z restructure(z) return else { sibling(parent(z) is red } z recolor(z) Analysis of Insertion Recall that a red-black tree has O(log n) height Step 1 takes O(log n) time because we visit O(log n) nodes Step 2 takes O(1) time Step 3 takes O(log n) time because we perform O(log n) recolorings, each taking O(1) time, and at most one restructuring taking O(1) time Thus, an insertion in a redblack tree takes O(log n) time 13

14 Deletion To perform operation remove(k), we first execute the deletion algorithm for binary search trees Let v be the internal node removed, w the external node removed, and r the sibling of w If either v of r was red, we color r black and we are done Else (v and r were both black) we color r double black, which is a violation of the internal property requiring a reorganization of the tree 14

15 Deletion Example Example: deletion of 8 causes a double black: 15

16 Remedying a Double Black The algorithm for remedying a double black node w with sibling y considers three cases Case 1: y is black and has a red child We perform a restructuring, equivalent to a transfer, and we are done Case 2: y is black and its children are both black We perform a recoloring, equivalent to a fusion, which may propagate up the double black violation Case 3: y is red We perform an adjustment, equivalent to choosing a different representation of a 3-node, after which either Case 1 or Case 2 applies Deletion in a red-black tree takes O(log n) time 16

17 Red-Black Tree Reorganization 17

18 Splay Trees 18

19 Splay Trees are Binary Search Trees BST Rules: entries stored only at internal nodes keys stored at nodes in the left subtree of v are less than or equal to the key stored at v keys stored at nodes in the right subtree of v are greater than or equal to the key stored at v An inorder traversal will return the keys in order Splay Trees 19

20 Starts the Same as in a BST Search proceeds down the tree to found item or an external node Example: Search for item with key 11 Searching in a Splay Tree 20

21 Searching in a Splay Tree Search for key 8, ends at an internal node. 21

22 Splay Trees Rotations New operation: splay splaying moves a node to the root using rotations right rotation makes the left child x of a node y into y s parent; y becomes the right child of x left rotation makes the right child y of a node x into x s parent; x becomes the left child of y 22

23 Splaying x is a left-left grandchild means x is a left child of its parent, which is itself a left child of its parent p is x s parent; g is p s parent 23

24 Visualizing Splaying 24

25 Let x = (8,N) x is the right child of its parent, which is the left child of the grandparent left-rotate around p, then rightrotate around g Splaying Example 25

26 Splaying Example Now x is the left child of the root. Right-rotate around root 26

27 Tree might not be more balanced e.g. splay (40,X) Before, the depth of the shallowest leaf is 3 and the deepest is 7 After, the depth of shallowest leaf is 1 and deepest is 8 Result of Splaying 27

28 Splay Tree Re-Definition We now define a Splay Tree in terms of Splaying A Splay Tree is a binary search tree where a node is splayed after it is accessed (for a search or update) deepest internal node accessed is splayed splaying costs O(h), where h is height of the tree which is still O(n) worst-case O(h) rotations, each of which is O(1) 28

29 Splay Trees and Ordered Dictionaries Which nodes are splayed after each operation? method splay node find(k) if key found, use that node if key not found, use parent of ending external node insert(k,v) use the new node containing the entry inserted remove(k ) use the parent of the internal node that was actually removed from the tree (the parent of the node that the removed item was swapped with) 29

30 Amortized Analysis of Splay Trees Running time of each operation is proportional to time for splaying. Define rank(v) as the logarithm (base 2) of the number of nodes in subtree rooted at v. Costs: zig = 1, zig-zig = 2, zig-zag = 2. Thus, cost for playing a node at depth d = d. Imagine that we store rank(v) cost at each node v of the splay tree (just for the sake of analysis). 30

31 Cost Per zig Doing a zig at x costs at most rank (x) - rank(x): cost = rank (x) + rank (y) - rank(y) - rank(x) < rank (x) - rank(x). 31

32 Cost Per zig-zig and zig-zag Doing a zig- zig or zig- zag at x costs at most 3(rank (x) - rank(x))

33 Cost of Splaying Cost of splaying a node x at depth d of a tree rooted at r: at most 3(rank(r) - rank(x)) - d + 2 Proof: Splaying x takes d/2 splaying substeps 33

34 Performance of Splay Trees Recall: rank of a node is logarithm of its size. Thus, amortized cost of any splay operation is O(log n). In fact, the analysis goes through for any reasonable definition of rank(x). This implies that splay trees can actually adapt to perform searches on frequently requested items much faster than O(log n) in some cases. 34

35 Summary Red-Black Trees is (2,4) tree implemented as a binary tree Red-Black Trees are easy to implement and give the same O (log n) performance Splay Trees are special binary search trees where the key at a node dominates keys of all the left descendents and is dominated by the keys of all the right descendents This imposed order can be used by an inorder traversal to search keys in order To maintain this order, splaying is performed after each access operation The amortised cost of any Splay Trees operation is O (log n) 35