Date post: | 19-Jan-2016 |
Category: |
Documents |
Upload: | daniel-sharp |
View: | 232 times |
Download: | 0 times |
Binary Search Trees (BSTs)
18 February 2003
2
Binary Search Tree (BST)
An important special kind of binary tree is the BST Each node stores some information including a unique
key value, and associated data. A binary tree is a BST iff, for every node n in the tree:
– All keys in n’s left subtree are less than the key n – All keys in n’s right subtree are greater than the key n.
Note: if duplicate keys are allowed, then nodes with values that are equal to the key in node n can be either in n’s left subtree or in its right subtree (but not both).
3
BSTs
2
94
6
951 3
72
4
4
Not BSTs
651 3
72
4
2
94
6
5
5
BSTs are Not Unique
1
42
3
1
4
2
3
6
Importance
The reason binary-search trees are important is that the following operations can be implemented efficiently using a BST: – insert a key value – determine whether a key value is in the tree – remove a key value from the tree – print all of the key values in sorted order
7
Lookup
In general, to determine whether a given value is in the BST, we will start at the root of the tree and determine whether the value we are looking for: – is in the root – might be in the root’s left subtree – might be in the root’s right subtree
There are actually two special cases: – The tree is empty; return null.– The value is in the root node; return the value.
8
Lookup
If neither special case holds, a recursive lookup is done on the appropriate subtree.
Since all values less than the root’s value are in the left subtree, and all values greater than the root’s value are in the right subtree, there is no point in looking in both subtrees
9
Pseudo Code
The pseudo code for the lookup method uses a recursive method
lookup(BST, searchkey) if (BST = null) return null; if (BST.key = searchkey) return BST.key; if (BST.key > searchkey) return
lookup(BST.left, searchkey);else return lookup(BST.right, searchkey);
left key right
10
Look for 12
195 12
169
13
11
Searching for 12
195 12
169
13
195 12
169
13
195 12
169
13
12 > 9 so go to the right subtree
Found!
12 < 13 so go to the left subtree
12
Search for 15
195 12
169
13
15 > 13 so go to the right subtree
15 < 16 so go to the left subtree. It does not exist so thesearch fails and it returns null 195 12
169
13
13
Animation
http://www1.mmu.edu.my/~mukund/dsal/BST.html
14
Analysis
How much time does it take to search for a value in a BST?
Note that lookup always follows a path from the root down towards a leaf. In the worst case, it goes all the way to a leaf.
Therefore, the worst-case time is proportional to the length of the longest path from the root to a leaf (the height of the tree).
15
Worst Case
What is the relationship between the number of nodes in a BST and the height of the tree?
This depends on the “shape” of the tree. In the worst case, all nodes have just one child,
and the tree is essentially a linked list.
16
Worst Case
This tree has 5 nodes, and has height = 5.
Searching for values in the range 16-19, and 21-29 will require following the path from the root down to the leaf (the node containing the value 20)
Requires time proportional to the number of nodes in the tree
15
10
50
20
30
17
Best Case
In best case, all nodes have 2 children
All leaves are at the same depth
This tree has 7 nodes, and height = 3751 3
62
4
18
Best Case Tree Height
In general, a “full” tree will have height approximately log2(N), where N is the number of nodes in the tree.
The value log2(N) is (roughly) the number of times you
can divide N by two, before you get to zero. For example:
7/2 = 3 divide by 2 once 3/2 = 1 divide by 2 a second time 1/2 = 0 divide by 2 a third time, the result is zero so quit
So log2(7) is approximately equal to 3.
19
Summary
The worst-case time required to do a lookup in a BST is O(height of tree).
The worst case (a “linear” tree) is O(N), where N is the number of nodes in the tree.
In the best case (a “full” tree) we get O(log N).
20
Inserting 15
195 12
169
13
19155 12
169
13195 12
169
13
(2) 15 < 16 and no left subtree
(1) 15 > 13 so go to right subtree
(3) So insert 15 as left child
21
Complexity
The complexity for insert is the same as for lookup
In the worst case, a path is followed all the way to a leaf.
22
Delete
If the search for the node containing the value to be deleted succeeds, there are several cases to deal with:
1. The node to delete is a leaf (has no children).
2. The node to delete has one child.
3. The node to delete has two children
23
Deletion
If KeyToDelete in not in the tree, the tree is simply unchanged.
We have to be careful that we do not “orphan” any nodes when we remove one.
When the node to delete is a leaf, we want to remove it from the BST by setting the appropriate child pointer of its parent to null (or by setting root to null if the node to be deleted is the root, and it has no children).
24
Delete a leaf (15)
195 12
169
13
195 12
169
13
15
25
Delete a node with one child (16)
195 12
169
13
25
21 35
5 12
199
13
25
21 35
26
Messy Case
The hard case is when the node to delete has two children.
To delete n, we can't replace node n with one of its children, because what would we do with the other child?
We replace node n with another node, x, lower down in the tree, then (recursively) delete node x.
27
Deletion
What node can we use to replace node n? The tree must remain a BST (all of the values in n’s left
subtree are less than n, and all of the values in n’s right subtree are greater than n)
There are two possibilities that work: the node in the left subtree with the largest value, or the node in the right subtree with the smallest value.
To find that node, we just follow a path in the right subtree, always going to the left child, since smaller values are in left subtrees. Once the node is found, we copy its fields into node n, then we recursively delete the copied node.
28
Deletion (8)
1292 6
114
8
31 75 10
29
Delete (8) Replace with (7)
1292 6
114
7
31 75 10
30
Delete (8) Replace with (9)
12102 6
114
9
31 75
31
Keeping BSTs Efficient
In best of all worlds, BST is fully balanced at all times.
In practical world, need BSTs to be “almost” balanced.
A lot of CS research and energy has gone into the problem of how to keep binary trees balanced.
32
Height Balanced: AVL Trees
An AVL tree is a binary tree in which the heights of the left and right subtrees of the root differ by at most 1 and in which the left and right subtrees are AVL.
33
Splay Trees
Self-adjusting data structure Splay trees are BSTs that move to the root the
most recently accessed node. Nodes that are frequently accessed tend to
cluster at the top of the tree driving those rarely accessed toward the leaves.
Splay trees can become highly unbalanced, but over the long term do perform well.