Download presentation

Presentation is loading. Please wait.

Published byPierre Coaker Modified over 2 years ago

1
David Luebke 1 5/4/2015 Binary Search Trees

2
David Luebke 2 5/4/2015 Dynamic Sets ● Want a data structure for dynamic sets ■ Elements have a key and satellite data ■ Dynamic sets support queries such as: ○ Search(S, k), Minimum(S), Maximum(S), Successor(S, x), Predecessor(S, x) ■ They may also support modifying operations like: ○ Insert(S, x), Delete(S, x)

3
David Luebke 3 5/4/2015 Binary Search Trees ● Binary Search Trees (BSTs) are an important data structure for dynamic sets ● In addition to satellite data, elements have: ■ key: an identifying field inducing a total ordering ■ left: pointer to a left child (may be NULL) ■ right: pointer to a right child (may be NULL) ■ p: pointer to a parent node (NULL for root)

4
David Luebke 4 5/4/2015 Review: Binary Search Trees ● BST property: Any element in the left subtree is less than or equal to its root, and any element in the right subtree is greater than or equal to the root. ● Example: F BH KDA

5
David Luebke 5 5/4/2015 Inorder Tree Walk ● What does the following code do? TreeWalk(x): if x != NULL: TreeWalk(left[x]); print(x); TreeWalk(right[x]); ● A: prints elements in sorted (increasing) order ● This is called an inorder tree walk ■ Preorder tree walk: print root, then left, then right ■ Postorder tree walk: print left, then right, then root

6
David Luebke 6 5/4/2015 Inorder Tree Walk ● Example: ● How long will a tree walk take? ● Prove that inorder walk prints in monotonically increasing order (sorts!) F BH KDA

7
David Luebke 7 5/4/2015 Operations on BSTs: Search ● Given a key and a pointer to a node, returns an element with that key or NULL: TreeSearch(x, k) if (x = NULL or k = key[x]) return x; if (k < key[x]) return TreeSearch(left[x], k); else return TreeSearch(right[x], k);

8
David Luebke 8 5/4/2015 BST Search: Example ● Search for D: F BH KDA

9
David Luebke 9 5/4/2015 BST Search: Example ● Search for D: F BH KDA D Before or After F?

10
David Luebke 10 5/4/2015 BST Search: Example ● Search for D: F BH KDA D Before or After B?

11
David Luebke 11 5/4/2015 BST Search: Example ● Search for D: F BH KDA Found!

12
David Luebke 12 5/4/2015 BST Search: Example ● Search for C: F BH KDA

13
David Luebke 13 5/4/2015 Operations on BSTs: Search ● Here’s another function that does the same: TreeSearch(x, k) while (x != NULL and k != key[x]) if (k < key[x]) x = left[x] else x = right[x] return x ● Which of these two functions is more efficient?

14
David Luebke 14 5/4/2015 Operations of BSTs: Insert ● Adds an element x to the tree so that the binary search tree property continues to hold ● The basic algorithm ■ Like the search procedure above ■ Insert x in place of NULL ■ Use a “trailing pointer” to keep track of where you came from (like inserting into singly linked list)

15
David Luebke 15 5/4/2015 BST Insert: Example ● Example: Insert C F BH KDA C

16
David Luebke 16 5/4/2015 Insert TreeInsert(T,z) y <- NULL x <- root(T) while x != NULL: y <- x if key[z] < key[x]: x <- left[x] else: x <- right[x] parent[z] <- y if y = NULL: root(T) <- z else if key[z] < key[y]: left[y]<-z else: right[y]<- z

17
David Luebke 17 5/4/2015 BST Search/Insert: Running Time ● What is the running time of TreeSearch() or TreeInsert()? ● A: O(h), where h = height of tree ● What is the height of a binary search tree? ● A: worst case: h = O(n) when tree is just a linear string of left or right children

18
David Luebke 18 5/4/2015 BST Operations: Minimum ● How can we implement a Minimum() query? ● What is the running time?

19
David Luebke 19 5/4/2015 BST Operations: Successor ● For deletion, we will need a Successor() operation ● Successor of a node is the node that comes next in order. ● What are the general rules for finding the successor of node x? (hint: two cases)

20
David Luebke 20 5/4/2015 BST Operations: Successor ● Two cases: ■ x has a right subtree: successor is minimum node in right subtree ■ x has no right subtree: successor is first ancestor of x whose left child is also ancestor of x ○ Intuition: As long as you move to the left up the tree, you’re visiting smaller nodes. ● Predecessor: similar algorithm

21
David Luebke 21 5/4/2015 Successor Example 15 618 207 3 13 2 4 9 17 What’s the successor of 15?

22
David Luebke 22 5/4/2015 Successor Example 15 618 207 3 13 2 4 9 17 What’s the successor of 15? The minimum of the right subtree.

23
David Luebke 23 5/4/2015 Successor Example 15 618 207 3 13 2 4 9 17 What’s the successor of 13? It has no right subtree…

24
David Luebke 24 5/4/2015 Successor Example 15 618 207 3 13 2 4 9 17 What’s the successor of 13? Lowest ancestor that has a left node that’s an ancestor.

25
David Luebke 25 5/4/2015 Successor TreeSuccessor(x) if right[x] != NULL return TreeMinimum(right[x]) y <- parent[x] while y != NULL and x = right[y] x <- y y <- parent[y] return y

26
David Luebke 26 5/4/2015 BST Operations: Delete ● Deletion is a bit tricky ● 3 cases: ■ x has no children: ○ Remove x F BH KDA C Example: delete K F BH DA C

27
David Luebke 27 5/4/2015 BST Operations: Delete ● Deletion is a bit tricky ● 3 cases: ■ x has one child: ○ Splice out x F BH KDA C Example: delete H F BK DA C

28
David Luebke 28 5/4/2015 BST Operations: Delete ● Deletion is a bit tricky ● 3 cases: ● x has two children: ● Replace with successor F BK DA C Example: delete B

29
David Luebke 29 5/4/2015 BST Operations: Delete F BH DA C Example: delete B F C K DA B’s successor is C Delete C Replace B with C

30
David Luebke 30 5/4/2015 BST Operations: Delete ● Why will case 2 always go to case 0 or case 1? ● A: because when x has 2 children, its successor is the minimum in its right subtree ● Could we swap x with predecessor instead of successor? ● A: yes. Would it be a good idea? ● A: might be good to alternate

31
David Luebke 31 5/4/2015 Delete TreeDelete(T,z) if left[z] = NULL or right[z] = NULL y <- z else y <- TreeSuccessor(z) if left[y] != NULL: x <- left[y] else: x <- right[y] if x != NULL: parent[x] <- parent[y] if parent[y] = NULL: root(T) = x else if y = left[parent[y]]: left[parent[y]] <- x else: right[parent[y]] <- x if y != z: key[z] <- key[y] // copy the node’s data return y

Similar presentations

OK

Lecture 19. Binary Search Tree 1. Recap Tree is a non linear data structure to present data in hierarchical form. It is also called acyclic data structure.

Lecture 19. Binary Search Tree 1. Recap Tree is a non linear data structure to present data in hierarchical form. It is also called acyclic data structure.

© 2018 SlidePlayer.com Inc.

All rights reserved.

Ads by Google

Ppt on brand equity management Ppt on asp dot net project Ppt on types of angles formed when two parallel lines are intersected by a transversal Ppt on waves tides and ocean currents animation Ppt on 3d figures Ppt on carry select adder Ppt on global marketing strategies Ppt on water conservation techniques Ppt on pricing policy to maximize Ppt on soft skills free download