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 n
ot 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 (ma
x) 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 i
nto its proper
place

item = 80
i=313
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 {
int key; [4 [5 [6 [7
/* other fields */ [8] [9 [10] [11 [12] [13 ]
}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 complexity: O(log n)
parent = 7
6

[1 7
5 min
]
[2 70 [3 40
80 max
] ]
[4 [5 [6 [7
] 30 ] 9 ] 10 ]
7 15 min

45 50 30
20 12 10 40 max
[8 [9 [10 [11 [12 [13 [14
 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 descen
dants with key larger than item.key.
 heap[k] may be
moved to the
root and item
inserted into
node k.
 MIN-MAX Heaps
c) item.key  heap[k].key, (8/10)
k is a grandchild of the root
 In this case, heap[k] may be moved to the root, now hea
p[k] is seen as presently empty.
 Let parent be the parent of k.
 If item.key  heap[parent].key, then interchange them. T
his ensures that the max node parent contains the larges
t key in the sub-heap with root parent.
 At this point, we are faced with the problem of inserting it
em 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 [0 7
] ]
[2 70 [3 40
] ]
[4 [5 [6 [7
] 30 ] 912 ] 10 ] 15

45 50 30
20 12
[8 [9 [10 [11 [12
 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
3. There exist a max-min heap
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 correspon
ding node in the right subtree.
 if j not exists, let j corresponds to parent of i
 i.key <= j.key
 Deaps(2/8)

 log 2 n  1
 i = min_partner(n) = n2
 log 2 n  1
 j = max_partner(n) = n2
 if j > heapsize j /= 2
 Deaps Insert(3/8)
public void insert(int x) { } else {
int i; i = maxPartner(n);
if (++n == 2) { if (x > deap[i]) {
deap[2] = x; return; } deap[n] = deap[i];
if (inMaxHeap(n)) { maxInsert(i, x);
i = minPartner(n); } else minInsert(n, x);
if (x < deap[i]) { }
deap[n] = deap[i]; }
minInsert(i, x);
} else maxInsert(n, x);
 Deaps(4/8)
 Insertion Into A Deap
Deaps(5/8)
Deaps(6/8)
 Deaps delete min(7/8)
public int deleteMin() { // try to put x at leaf i
int i, j, key = deap[2], x = j = maxPartner(i);
deap[n--]; if (x > deap[j]) {
// move smaller child to i deap[i] = deap[j];
for (i = 2; 2*i <= n; deap[i] maxInsert(j, x);
= deap[j], i = j) { } else {
j = i * 2; minInsert(i, x);
if (j+1 <= n && (deap[j] }
> deap[j+1]) j++;
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 exch
ange
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 operat
ion 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 a
nd 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 mi
n becomes O(n), each node can have only
one child be deleted.
 If two children of x were deleted, then x m
ust be cut and moved to the ring of roots.
 Using a flag (true of false) to indicate whet
her 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 d
egree of at least i – 2, except when i=1 the deg
ree is 0
 Corollary
 Let Sk be the minimum possible number of des
cendants 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 Fibona
cci Heap
 Fibonacci Heaps(8/8)
 Application Of F-heaps