Download presentation

1
**BST Data Structure A BST node contains: A BST contains**

A key (used to search) The data associated with that key Pointers to children, parent Leaf nodes have NULL pointers for children A BST contains A pointer to the root of the tree.

2
**BST Operations: Insert**

BST property must be maintained Algorithm sketch: To insert data with key k Compare k to root.key If k < root.key, go left If k > root.key, go right Repeat until you reach a leaf. That's where the new node should be inserted. Note: keep track of prospective parent along the way.

3
**BST Operations: Insert**

Running time: The new node is inserted at a leaf position, so this depends on the height of the tree. Worst case: Inserting keys 1,2,3,... in this order will result in a tree that looks like a chain: Tree has degenerated to list Height : linear Note also that such a tree is worse than a linked list since it takes up more space (more pointers) 1 2 3

4
**BST Operations: Insert**

Running time: The new node is inserted at a leaf position, so this depends on the height of the tree. Best case The top levels of the tree are filled up completely The height is then logn where n is the number of nodes in the tree. 12 4 14 2 8 16

5
**BST Operations: Insert**

The height of a complete (i.e. all levels filled up) BST with n nodes is logarithmic. Why? Level i has 2i nodes, for i=0 (top level) through h (=height) The total number of nodes, n, is then: n = h = (2h+1-1)/(2-1) = 2h+1-1 Solving for h gives us h logn

6
**BST Operations: Insert**

Analysis conclusion An insert operation consists of two parts: Search for the position best case logarithmic worst case linear Physically insert the node constant

7
**BST Operations: Insert**

What if we allow duplicate keys? Idea #1 : Always insert in the right subtree Results in very unbalanced tree Idea #2 : Insert in alternate subtrees Makes it difficult to search for all occurrences Idea #3 : All elements with the same key are inserted in a single node Good idea! Easy to search, does not affect balance any more than non-duplicate insertion.

8
**BST Operations: Insert**

What if we allow variable number of children? (n-ary tree) Idea : Use a vector/list of pointers to children.

9
**BST Operations: Search**

Take advantage of the BST property. Algorithm sketch: Compare target to root If equal, return success If target < root, search left If target > root, search right Running time: Similar to insert

10
**BST Operations: Delete**

The Delete operation consists of two parts: Search for the node to be deleted best case constant (deleting the root) worst case linear Delete the node best case? worst case?

11
**BST Operations: Delete**

CASE #1 The node to be deleted is a leaf node. Easy! Physically remove the node. Constant time We are just resetting its parent's child pointer and deallocating memory

12
**BST Operations: Delete**

CASE #2 The node to be deleted has exactly one child Easy! Physically remove the node. Constant time We are just resetting its parent's child pointer, its child's parent pointer and deallocating memory

13
**BST Operations: Delete**

CASE #3 The node to be deleted has two children Not so easy If we physically delete the node, we'll have to place its two children somewhere. This seems to require too much tree restructuring. But we know it's easy to delete a node that has at most one child. What if we find such a node whose contents can be copied over without violating the BST property and then physically delete that node?

14
**BST Operations: Delete**

CASE #3, continued The node to be deleted, x, has two children Idea: Find the x's immediate successor, y. It is guaranteed to have at most one child Copy the y's contents over to x Physically delete y.

15
**BST Operations: Delete**

Finding the immediate successor: We know that the node has two children. Due to the BST property, the immediate successor will be in the right subtree. In particular, the immediate successor will be the smallest element in the right subtree. The smallest element in a BST is always the leftmost leaf.

16
**BST Operations: Delete**

Finding the immediate successor: Since it requires traveling down the tree from the current node to a leaf, it may take up to linear time in the worst case. In the best case it will take logarithmic time. The time to perform the copy and delete the successor is constant.

17
**Binary Search Trees Traversing a tree = visiting its nodes**

Three major ways to traverse a binary tree: preorder visit root visit left subtree visit right subtree postorder visit left subtree visit right subtree visit root When applied on a BST, it visits the nodes in order from smaller to larger inorder visit left subtree visit root visit right subtree

18
**Binary Search Trees How long does this take?**

void print_inorder(Node *subroot ) { if (subroot != NULL) { print_inorder(subroot left); cout << subrootdata; print_inorder(subroot right); } How long does this take? There is exactly one call to print_inorder() for each node of the tree. There are n nodes, so the running time of this operation is (n)

19
Binary Search Trees A tree may also be traversed one "level" at a time (top to bottom, left to right). This is usually called a level-order traversal. It requires the use of a temporary queue: enqueue root while (queue is not empty) { get the front element, f print f enqueue f's children dequeue }

20
Binary Search Trees 12 4 14 2 8 16 6 10 in-order : pre-order: post-order: level-order:

21
**Binary Search Trees Idea for sorting algorithm: Running time:**

Given a sequence of integers, insert each one in a BST Perform an inorder traversal. The elements will be accessed in sorted order. Running time: In the worst case, the tree will degenerate to a list. Creation will take quadratic time and traversal will be linear. Total: O(n2) On average, the tree will be mostly balanced. Creation will take O(nlogn) and traversal will again be linear. Total: O(nlogn)

22
**BSTs vs. Lists Time Space**

In the worst case, all dictionary operations are linear. On average, BSTs are expected to do better. Space BSTs store an additional pointer per node. The BST seemed like a good idea, but in the end it doesn't offer much improvement. We must find a way to keep the tree balanced and guarantee logarithmic height.

23
**Balanced Trees There are several ways to define balance Examples:**

Force the subtrees of each node to have almost equal heights Place upper and lower bounds on the heights of the subtrees of each node. Force the subtrees of each node to have similar sizes (=number of nodes)

Similar presentations

© 2020 SlidePlayer.com Inc.

All rights reserved.

To make this website work, we log user data and share it with processors. To use this website, you must agree to our Privacy Policy, including cookie policy.

Ads by Google