Binary Search Trees vs. Binary Heaps

Binary Search Tree Condition Given a node i –i.value is the stored object –i.left and i.right point to other nodes All of i’s left children and grand-children are less than i.value All of i’s right children and grand-children are greater than i.value

Binary Search Trees Binary search trees can be easily implemented using arrays X

Binary Search Trees Root is at index 1 (i = 1) Left(i) { return i*2; }Right(i) { return i*2 + 1; } X

Binary Search Trees bool Find_rec(int x, int i) { if (a[i] == -1 ) return false; else if (x == a[i]) return true; else if (x < a[i]) Find_rec(x, i*2); else Find_rec(x, i*2+1); } bool Find(int x) { return Find_rec(x, 1); } …

Binary Search Tree Features Find  O(log N) on average Insert in proper order  O(log N) on average O(log N) to find the correct location + O(1) to perform insertion Return Min  O(log N) on average –Keep moving left until you see a -1 Return Max  O(log N) on average –Keep moving left until you see a -1 Print in-order  O(N) all the time –See in-order traversal in book

Priority Queue (Min) Three functions –push(x) – pushes the value x into the queue –min() – return the minimum value in the queue –delete() – removes the minimum value in the queue Tons of applications: –OS process queues, Transaction Processing, Packet routing in advanced networks, used in various other algoriothms

Priority Queue (Min) Consider using an un-order Array –push(x) – O(1) just add it to the end of the array. –min() – O(N) sequential search for min value –delete() – O(N) might have to shift entire array

Priority Queue (Min) Consider using an Ordered Array –push(x) – O(N) to find correct location and shift array appropriately –min() – O(1) return the first value –delete() – O(N) might have to shift entire array Recall using an un-order Array –push(x) – O(1) just add it to the end of the array. –min() – O(N) sequential search for min value –delete() – O(N) might have to shift entire array

Priority Queue (Min) Why are simple array implementation bad? O(N) is not a problem, right? Consider this application: –A private network router has 10 million packets coming in every minute (mostly junk, spam, etc.) and I only want to let through the top 1 million (#1 is top priority – min)

Priority Queue (Min) N = 10 million in-coming packets M = 1 million out-going packets (top priority – priority #1) Consider using an Ordered Array –push(x) – O(N) Must do this N times  N*N –min() – O(1) –delete() – O(1) Must do this M times  M Recall using an un-order Array –push(x) – O(1) Must do this N time (not a problem) –min() – O(N) Must do this M times  N*M –delete() – O(N) Must do this M times  N*M

N*M N all the packets 10 million M – 1 million top priority packets Must be processed in one minute. Assume your computer can do 10 billion operation per second  600 billion operation in one minute. Unfortunately, N*M is 10 trillion operations.

Priority Queue (Min) Consider using an BST –push(x) – O(log N) add to the correct position –Log(n) * n, n = 10,000,000 –min() – O(log N) return the left-most node –delete() – O(log N) Recall using an un-order Array –push(x) – O(1) just add it to the end of the array. –min() – O(N) sequential search for min value –delete() – O(N) might have to shift entire array

Priority Queue (Min) Is this possible? –push(x) – O(1) to find correct location an shift array appropriately –min() – O(1) return the first value –delete() – O(log N)

Binary Heaps (Min Heap) Given a node i –i.value is the stored object –i.left and i.right point to other nodes All of i’s left children and grand-children are greater than i.value All of i’s right children and grand-children are greater than i.value

Binary Heaps (Min Heap) Binary heaps can be easily implemented using arrays

Binary Heap Features Find  O(N) requires sequential search Insert in proper order  O(1) on average Amazing Heap Property Return Min  O(log N) on average –O(1) to return min –O(log N) to restore the heap property Print in-order  O(N log N) requires progressively deleting the min.

Priority Queue (Min) N = 10 million in-coming packets M = 1 million out-going packets (top priority – priority #1) Consider using an Heap –push(x) – O(1) Must do this N times (not a problem) –min() – O(1) –delete() – O(log N) Must do this M times  log(N)*M Recall using an un-order Array –push(x) – O(1) Must do this N time (not a problem) –min() – O(N) Must do this M times  N*M –delete() – O(N) Must do this M times  N*M

log(N)*M N all the packets 10 million M – 1 million top priority packets Must be processed in one minute. Assume your computer can do 1 billion operation per second  60 billion operation in one minute. What is log(N)*M?

Summary: Priority Queue Implementations BST Implementation Push: O(log N) Find Min: O(log N) Remove Min: O(log N) Pushing N = 10,000, million operations Removing M minimums M = 1,000, million operations Binary Heap Implement. Push: O(1) Find Min: O(1) Remove Min: O(log N) Pushing N = 10,000, million operations Removing M minimums M = 1,000, million operations