Transcript CS235102 Data Structures

CS235102
Data Structures
Chapter 9 Heap Structures
 Min-Max Heap
 Deaps
 Leftist Trees
 Binomial Heaps
 Fibonacci Heaps
MIN-MAX Heaps (1/10)
 Definition
 A double-ended priority queue is a data structure that
supports the following operations:
 Insert an element with arbitrary key
 Delete an element with the largest key
 Delete an element with the smallest key
 Min heap or Max heap:
 Only insertion and one of the two deletion operations are
supported
 Min-Max heap:
 Supports all of the operations just described.
 Definition:
MIN-MAX Heaps (2/10)
 A mix-max heap is a complete binary tree such that if it is
not empty, each element has a field called key.
 Alternating levels of this tree are min levels and max
levels, respectively.
 Let x be any node in a min-max heap. If x is on a min (max)
level then the element in x has the minimum (maximum)
key from among
all elements in
the subtree with
root x. We call
this node a min
(max) node.
MIN-MAX Heaps (3/10)
 Insertion into a min-max heap (at a “max” level)
 If it is smaller/greater than its father (a “min”), then it must
be smaller/greater than all “max”/“min” above. So simply
check the “min”/“max” ancestors
 There exists a similar approach at a “min” level
 verify_max
MIN-MAX Heaps (4/10)
 Following the nodes the max node i to the root and insert
into its proper
place
item = 80
i=3
13
grandparent = 0
3
#define MAX_SIZE 100
#define FALSE 0
[1]
#define TRUE 1
#define SWAP(x,y,t)
((t)=(x), (x)=(y),
[2]
[3] 80
(y)=(t))
typedef struct {
[4]
[5]
[6]
[7]
int key;
[8]
[9] [10] [11] [12] [13]
/* other fields */
}element;
40
element heap[MAX_SIZE];
MIN-MAX Heaps (5/10)
 min_max_insert: Insert item into the min-max heap
item.key = 80
5
*n = 14
12
13
parent = 7
6
complexity: O(log n)
[1] 57
[2] 70
[4]
[3] 40
80
[5]
30
45
[6]
9
50
min
30
max
[7]
710
15
20 12 10 40
[8] [9] [10][11][12][13][14]
min
max
MIN-MAX Heaps (6/10)
 Deletion of min element


If we wish to delete the element with the smallest key,
then this element is in the root.
In general situation, we are to reinsert an element item
into a min-max-heap, heap, whose root is empty.
 We consider the two cases:
1. The root has no children
 Item is to be inserted into the root.
2. The root has at least one child.
 The smallest key in the min-max-heap is in one of the children
or grandchildren of the root. We determine the node k has the
smallest key.

The following possibilities need to be considered:
MIN-MAX Heaps (7/10)
a) item.key  heap[k].key


No element in heap with key smaller than item.key
Item may be inserted into the root.
b) item.key  heap[k].key, k is a child of the root


Since k is a max node, it has no descendants with key
larger than heap[k].key. Hence, node k has no
descendants with key larger than item.key.
heap[k] may be
moved to the
root and item
inserted into
node k.
MIN-MAX Heaps (8/10)
c) item.key  heap[k].key,
k is a grandchild of the root




In this case, heap[k] may be moved to the root, now
heap[k] is seen as presently empty.
Let parent be the parent of k.
If item.key  heap[parent].key, then interchange them.
This ensures that the max node parent contains the
largest key in the sub-heap with root parent.
At this point, we are faced with the problem of inserting
item into the
sub-heap with
root k.
Therefore, we
repeat the above
process.
 delete_min:
complexity: O(log n)
 Delete the minimum element from the min-max heap
*n = 12
11
i=5
1
last = 5
k = 11
5
parent = 2
temp.key =
x.key = 12
[1] 79
[2] 70
[4]
[3] 40
[5]
30
45
[6]
912
50
[0] 7
30
[7]
10
20 12
[8] [9] [10][11][12]
15
MIN-MAX Heaps (10/10)

Deletion of max element
1. Determine the children of the root which are located on
max-level, and find the larger one (node) which is the
largest one on the min-max heap
2. We would consider the node as the root of a max-min
heap
max-min heap
3. There exist a
similar
approach
(deletion of
max element)
as we
mentioned
above
Deaps(1/8)
 Definition




The root contains no element
The left subtree is a min-heap
The right subtree is a max-heap
Constraint between the two trees:
 let i be any node in left subtree, j be the
corresponding node in the right subtree.
 if j not exists, let j corresponds to parent of i
 i.key <= j.key
Deaps(2/8)
 i = min_partner(n) =
 j = max_partner(n) =
 if j > heapsize j /= 2
n2
log2 n 1
n2
log2 n 1
Deaps Insert(3/8)
public void insert(int x) {
int i;
if (++n == 2) {
deap[2] = x; return; }
if (inMaxHeap(n)) {
i = minPartner(n);
if (x < deap[i]) {
deap[n] = deap[i];
minInsert(i, x);
} else maxInsert(n, x);
} else {
i = maxPartner(n);
if (x > deap[i]) {
deap[n] = deap[i];
maxInsert(i, x);
} else minInsert(n, x);
}
}
Deaps(4/8)
 Insertion Into A Deap
Deaps(5/8)
Deaps(6/8)
Deaps delete min(7/8)
public int deleteMin() {
int i, j, key = deap[2], x =
deap[n--];
// move smaller child to i
for (i = 2; 2*i <= n; deap[i]
= deap[j], i = j) {
j = i * 2;
if (j+1 <= n && (deap[j]
> deap[j+1]) j++;
}
// try to put x at leaf i
j = maxPartner(i);
if (x > deap[j]) {
deap[i] = deap[j];
maxInsert(j, x);
} else {
minInsert(i, x);
}
return key;
}
Deaps(8/8)
Leftist Trees(1/7)
 Support combine (two trees to one)
Leftist Trees(2/7)
 shortest(x) = 0 if x is an external node, otherwise
 1+min(shortest(left(x)),shortest(right(x))}
Leftist Trees(3/7)
 Definition: shortest(left(x)) >= shortest(right(x))
Leftist Trees(4/7)
 Algorithm for combine(a, b)
 assume a.data <= b.data
 if (a.right is null) then make b be right child of
a
 else combine (a.right, b)
 if shortest (a.right) > shortest (a.left) then
exchange
Leftist Trees(5/7)
Leftist Trees(6/7)
Leftist Trees(7/7)
Binomial Heaps(1/10)
 Cost Amortization(分期還款)
 every operation in leftist trees costs O(logn)
 actual cost of delete in Binomial Heap could be O(n),
but insert and combine are O(1)
 cost amortization charge some cost of a heavy
operation to lightweight operations
 amortized Binomial Heap delete is O(log2n)
 A tighter bound could be achieved for a sequence of
operations
 actual cost of any sequence of i inserts, c combines,
and dm delete in Binomial Heaps is O(i+c+dmlogi)
Binomial Heaps(2/10)
 Definition of Binomial Heap
 Node: degree, child ,left_link, right_link, data, parent
 roots are doubly linked
 a points to smallest root
Binomial Heaps(3/10)
Binomial Heaps(4/10)
 Insertion Into A Binomial Heaps
 make a new node into doubly linked circular
list pointed at by a
 set a to the root with smallest key
 Combine two B-heaps a and b
 combine two doubly linked circular lists to one
 set a to the root with smallest key
Binomial Heaps(5/10)
 Deletion Of Min Element
Binomial Heaps(6/10)
Binomial Heaps(7/10)
Binomial Heaps(8/10)
Binomial Heaps(9/10)
Binomial Heaps(10/10)
 Trees in B-Heaps is Binomial tree
 B0 has exactly one node
 Bk, k > 0, consists of a root with degree k
and whose subtrees are B0, B1, …, Bk-1
 Bk has exactly 2k nodes
 actual cost of a delete is O(logn + s)
 s = number of min-trees in a (original roots - 1)
and y (children of the removed node)
Fibonacci Heaps(1/8)
 Definition
 delete, delete the element in a specified node
 decrease key
 This two operations are followed by cascading
cut
Fibonacci Heaps(2/8)
 Deletion From An F-heap
 min or not min
Fibonacci Heaps(3/8)
 Decrease Key
 if not min, and smaller than parent, then delete
Fibonacci Heap(4/8)
 To prevent the amortized cost of delete
min becomes O(n), each node can have
only one child be deleted.
 If two children of x were deleted, then x
must be cut and moved to the ring of roots.
 Using a flag (true of false) to indicate
whether one of x’s child has been cut
Fibonacci Heaps(5/8)
 Cascading Cut
Fibonacci Heaps(6/8)
 Lemma
 the ith child of any node x in a F-Heap has a
degree of at least i – 2, except when i=1 the
degree is 0
 Corollary
 Let Sk be the minimum possible number of
descendants of a node of degree k, then S0=1,
S1=2. From the lemma above, we got
k 2
(2 comes from 1st child
Sk  Si  2 and root)

i 0
Fibonacci Heaps(7/8)
k
Fk  2   Fi  2
i2
S k  Fk  2
 That’s why the data structure is called
Fibonacci Heap
Fibonacci Heaps(8/8)
 Application Of F-heaps