Binary Search Trees vs. Binary Heaps

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 is left children and grand-children

are less than i.value
All of is right children and grand-children
are greater than i.value
Binary Search Trees

Binary search trees can be easily
implemented using arrays.
0
10
11
12
13
14
15
50
24
78
12
36
64
90
15
29
44
58
67
81
93
50
24
78
12
3
36
15
29
64
44
58
90
67
81
93
Binary Search Trees

Root is at index 1 (i = 1)
Left(i) { return i*2; }
Right(i) { return i*2 + 1; }
10
11
12
13
14
15
50
24
78
12
36
64
90
15
29
44
58
67
81
93
50
24
78
12
3
36
15
29
64
44
58
90
67
81
93
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);
}
10
11
12
13
14
15
-1
50
24
78
12
36
64
90
15
29
44
-1
-1
-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

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

Consider using an Ordered Array
push(x) O(N) to find correct location and
shift array appropriately
min() O(1) return the first value
Recall using an un-order Array
push(x) O(1) just add it to the end of the array.

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)

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

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)
push(x) O(1) just add it to the end of the array.

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 is left children and grand-children

All of is right children and grand-children
Binary Heaps (Min Heap)

Binary heaps can be easily implemented
using arrays.
0
10
11
12
13
14
15
-1
10
16
33
48
49
24
81
63
78
58
67
-1
-1
3
10
16
24
33
81
63
48
78
58
49
67
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.

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
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
Binary Heap Implement.
Push: O(log N)
Find Min: O(log N)
Remove Min: O(log N)
Push: O(1)
Find Min: O(1)
Remove Min: O(log N)
Pushing N = 10,000,000
230 million operations
Removing M minimums
M = 1,000,000
Pushing N = 10,000,000
Removing M minimums
M = 1,000,000

Binary Search Trees vs. Binary Heaps

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Binary Search Trees vs. Binary Heaps

Uploaded by

Copyright:

Available Formats

Binary Search Trees vs.

Binary Search Tree Condition

All of is left children and grand-children

Binary Search Trees

Binary Search Trees

Right(i) { return i*2 + 1; }

Binary Search Trees

Binary Search Tree Features

Return Min O(log N) on average

Return Max O(log N) on average

Print in-order O(N) all the time

Priority Queue (Min)

Priority Queue (Min)

Priority Queue (Min)

Priority Queue (Min)

Priority Queue (Min)

N all the packets 10 million

Priority Queue (Min)

Priority Queue (Min)

Binary Heaps (Min Heap)

All of is left children and grand-children

Binary Heaps (Min Heap)

Binary Heap Features

Return Min O(log N) on average

Print in-order O(N log N) requires

Priority Queue (Min)

N all the packets 10 million

Summary: Priority Queue

Binary Heap Implement.

You might also like