Binary Trees. CSE 326: Data Structures Lecture #7 Binary Search Trees. Naïve Implementations. Dictionary & Search ADTs

Transcription

1 Binary Trees CSE 36: Data Structures Lecture # Binary Search Trees Henry Kautz Winter Quarter 00 Properties Notation: depth(tree) = MAX {depth(leaf) = height(root) max # of leaves = depth(tree) max # of nodes = depth(tree)+1 1 B max depth = n-1 average depth for n nodes = n D (over all possible binary trees) Representation: Data E A G C F H left right pointer pointer I J Dictionary & Search ADTs Operations create destroy kohlrabi - upscale tuber (kreplach) kreplach - tasty stuffed dough kim chi spicy cabbage kreplach tasty stuffed dough kiwi Australian fruit (w/o duplicates) Naïve Implementations (if no stretch) Dictionary: Stores values associated with user-specified keys keys may be any (homogenous) comparable type values may be any (homogenous) type implementation: data field is a struct with two parts Search ADT: keys = values (if no shrink) Goal: fast like, dynamic s/s like (w/o duplicates) Naïve Implementations (if no stretch) (if no shrink) O(log n) Goal: fast like, dynamic s/s like Binary Search Tree Dictionary Data Structure Search tree property all keys in left subtree smaller than root s key all keys in right subtree larger than root s key result: easy to any given key s/s by changing links

2 In Order Listing In Order Listing 1 visit left subtree visit node visit right subtree 1 visit left subtree visit node visit right subtree 0 0 In order ing: In order ing: runtime: Finding a Node 1 0 Node *& (Comparable x, Node * root) { if (root == NULL) if (x < root->key) return (x,root->left); if (x > root->key) return (x, root->right); Insert Concept: proceed down tree as in Find; if new key not found, then a new node at last spot traversed void (Comparable x, Node * root) { assert ( root!= NULL ); if (x < root->key){ root->left = new Node(x); ( x, root->left ); if (x > root->key){ if (root->right == NULL) root->right = new Node(x); ( x, root->right ); C++ trick: use reference parameters Tricky Insert void (Comparable x, Node * & root) { if ( root == NULL ) root = new Node(x); if (x < root->key) runtime: ( x, root->left ); ( x, root->right ); Works even when called with empty tree node * mytree = NULL; ( something, mytree ); sets the variable mytree to point to the newly created node Digression: Value vs. Reference Parameters Value parameters (Object foo) copies parameter no side effects Reference parameters (Object & foo) shares parameter can affect actual value use when the value needs to be changed Const reference parameters (const Object & foo) shares parameter cannot affect actual value use when the value is too intricate for pass-by-value

3 Really Tricky Insert void (Comparable x, Node * & root){ Node * & target = (x, root); if ( target == NULL ) target = new Node(x); BuildTree for BSTs Suppose a 1, a,, a n are ed into an initially empty BST: 1. a 1, a,, a n are in increasing order. a 1, a,, a n are in decreasing order 3. a 1 is the median of all, a is the median of elements less than a 1, a 3 is the median of elements greater than a 1, etc. 4. data is randomly ordered Analysis of BuildTree Worst case is O(n ) n = O(n ) Average case assuming all input sequences are equally likely is O(n log n) equivalently: average depth of a node is log n proof: see Introduction to Algorithms, Cormen, Leiserson, & Rivest Proof that Average Depth of a Node in a BST constructed from random data is O(log n) Calculate sum of all depths, divide by number of nodes D(n) = sum of depths of all nodes in a random BST containing n nodes D(n) = D(left subtree)+d(right subtree) +1*(number of nodes in left and right subtrees) D(n) = D(L)+D(n-L-1)+(n-1) For random data, all subtree sizes equally likely n 1 1 D( n) = ( D( L) + D( n L 1)) ( n 1) n + L= 0 n 1 D( n) = D( L) + ( n 1) n L= 0 D( n) = O( nlog n) Deletion 1 0 Why might deletion be harder than ion? FindMin/FindMax Node * min(node * root) { return min(root->left); How many children can the min of a node have? 1 0 3

4 Successor Predecessor Find the next larger node in this node s subtree. not next larger in entire tree Node * succ(node * root) { if (root->right == NULL) return NULL; return min(root->right); 1 0 Find the next smaller node in this node s subtree. Node * pred(node * root) { return NULL; return max(root->left); 1 0 How many children can the successor of a node have? Deletion - Leaf Case Deletion - One Child Case Delete(1) Delete(1) Deletion - Two Child Case Deletion - Two Child Case Delete() Delete() 0 0 replace node with value guaranteed to be between the left and right subtrees: the successor Could we have used the predecessor instead? always easy to the successor always has either 0 or 1 children! 4

5 Deletion - Two Child Case Lazy Deletion Delete() Finally copy data value from d successor into original node 0 Instead of physically deleting nodes, just mark them as d + simpler + physical deletions done in batches + some adds just flip d flag extra memory for d flag many lazy deletions slow s some operations may have to be modified (e.g., min and max) 1 0 Dictionary Implementations BST O(log n) BST s looking good for shallow trees, i.e. the depth D is small (log n), otherwise as bad as a!