CS235102 Data Structures

1
CS235102 Data Structures

• Chapter 9 Heap Structures

2

• Min-Max Heap
• Deaps
• Leftist Trees
• Binomial Heaps
• Fibonacci Heaps

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

4
MIN-MAX Heaps (2/10)

• Definition
• 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 amongall elements in
  the subtree with root x. We call this node a
  min (max) node.

5
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

6
MIN-MAX Heaps (4/10)

• verify_max
• Following the nodes the max node i to the root
  and insert into its proper place

item 80
i
13
3
grandparent
3
0
define MAX_SIZE 100define FALSE 0define TRUE
1define SWAP(x,y,t) ((t)(x), (x)(y),
(y)(t))typedef struct int key/ other
fields /elementelement heapMAX_SIZE
1
80
2
3
4
5
6
7
8
9
10
11
12
13
40
7
MIN-MAX Heaps (5/10)

• min_max_insert Insert item into the min-max heap

item.key
5
80
n
12
13
14
complexity O(log n)
parent
6
7
1
min
7
5
2
3
max
70
40
80
4
5
6
7
30
9
10
15
min
7
max
45
50
30
20
12
10
40
11
12
13
14
8
9
10
8
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
• The root has no children
• Item is to be inserted into the root.
• 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

9
MIN-MAX Heaps (7/10)

• item.key ? heapk.key
• No element in heap with key smaller than item.key
• Item may be inserted into the root.
• item.key ? heapk.key, k is a child of the root
• Since k is a max node, it has no descendants with
  key larger than heapk.key. Hence, node k has no
  descendants with key larger than item.key.
• heapk may be moved to the root and item
  inserted into node k.

10
MIN-MAX Heaps (8/10)

• item.key ? heapk.key, k is a grandchild of
  the root
• In this case, heapk may be moved to the root,
  now heapk is seen as presently empty.
• Let parent be the parent of k.
• If item.key ? heapparent.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.

11

• delete_min
• Delete the minimum element from the min-max heap

complexity O(log n)
n
12
11
i
1
5
last
5
k
5
11
parent
2
temp.key
x.key
12
1
0
7
7
9
2
3
70
40
4
5
6
7
30
9
10
15
12
45
50
30
20
12
8
9
10
11
12
12
MIN-MAX Heaps (10/10)

• Deletion of max element
• 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
• We would consider the node as the root of a
  max-min heap
• There exist a similar approach (deletion of
  max element) as we mentioned above

max-min heap
13
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 lt j.key

14
Deaps(2/8)

• i min_partner(n)
• j max_partner(n)
• if j gt heapsize j / 2

15
Deaps Insert(3/8)

• else
• i maxPartner(n)
• if (x gt deapi)
• deapn deapi
• maxInsert(i, x)
• else minInsert(n, x)

• public void insert(int x)
• int i
• if (n 2)
• deap2 x return
• if (inMaxHeap(n))
• i minPartner(n)
• if (x lt deapi)
• deapn deapi
• minInsert(i, x)
• else maxInsert(n, x)

16
Deaps(4/8)

• Insertion Into A Deap

17
Deaps(5/8)
18
Deaps(6/8)
19
Deaps delete min(7/8)

• public int deleteMin()
• int i, j, key deap2, x deapn--
• // move smaller child to i
• for (i 2 2i lt n deapi deapj, i
  j)
• j i 2
• if (j1 lt n (deapj gt deapj1)
  j

• // try to put x at leaf i
• j maxPartner(i)
• if (x gt deapj)
• deapi deapj
• maxInsert(j, x)
• else
• minInsert(i, x)
• return key

20
Deaps(8/8)
21
Leftist Trees(1/7)

• Support combine (two trees to one)

22
Leftist Trees(2/7)

• shortest(x) 0 if x is an external node,
  otherwise
• 1min(shortest(left(x)),shortest(right(x))

23
Leftist Trees(3/7)

• Definition shortest(left(x)) gt
  shortest(right(x))

24
Leftist Trees(4/7)

• Algorithm for combine(a, b)
• assume a.data lt b.data
• if (a.right is null) then make b be right child
  of a
• else combine (a.right, b)
• if shortest (a.right) gt shortest (a.left) then
  exchange

25
Leftist Trees(5/7)
26
Leftist Trees(6/7)
27
Leftist Trees(7/7)
28
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(icdmlogi)

29
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

30
Binomial Heaps(3/10)
31
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

32
Binomial Heaps(5/10)

• Deletion Of Min Element

33
Binomial Heaps(6/10)
34
Binomial Heaps(7/10)
35
Binomial Heaps(8/10)
36
Binomial Heaps(9/10)
37
Binomial Heaps(10/10)

• Trees in B-Heaps is Binomial tree
• B0 has exactly one node
• Bk, k gt 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)

38
Fibonacci Heaps(1/8)

• Definition
• delete, delete the element in a specified node
• decrease key
• This two operations are followed by cascading cut

39
Fibonacci Heaps(2/8)

• Deletion From An F-heap
• min or not min

40
Fibonacci Heaps(3/8)

• Decrease Key
• if not min, and smaller than parent, then delete

41
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 xs child has been cut

42
Fibonacci Heaps(5/8)

• Cascading Cut

43
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 i1 the
  degree is 0
• Corollary
• Let Sk be the minimum possible number of
  descendants of a node of degree k, then S01,
  S12. From the lemma above, we got
• (2 comes from 1st
  child
• and root)

44
Fibonacci Heaps(7/8)

• Thats why the data structure is called Fibonacci
  Heap

45
Fibonacci Heaps(8/8)

• Application Of F-heaps