1. Binary Search Trees vs. Binary Heaps

2. 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

3. Binary Search Trees • Binary search trees can be easily implemented using arrays. 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 X 50 24 78 12 36 64 90 3 15 29 44 58 67 81 93 50 24 78 12 36 64 90 3 15 29 44 58 67 81 93

4. Root is at index 1 (i = 1) Left(i) { return i*2; } Right(i) { return i*2 + 1; } Binary Search Trees 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 X 50 24 78 12 36 64 90 3 15 29 44 58 67 81 93 50 24 78 12 36 64 90 3 15 29 44 58 67 81 93

5. 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 Trees 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 -1 50 24 78 12 36 64 90 3 15 29 44 -1 -1 -1 …

6. 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

7. 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

8. 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

9. 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

10. 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)

11. 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

12. 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.

13. 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

14. 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)

15. 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

16. Binary Heaps (Min Heap) • Binary heaps can be easily implemented using arrays. 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 -1 3 10 5 16 33 48 49 24 81 63 78 58 67 -1 -1 3 10 5 16 33 48 49 24 81 63 78 58 67

17. 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.

18. 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

19. 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?

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