1 / 45

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

pules
Download Presentation

CS235102 Data Structures

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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 = 3 13 grandparent = 0 3 #define MAX_SIZE 100#define FALSE 0#define TRUE 1#define SWAP(x,y,t) ((t)=(x), (x)=(y), (y)=(t))typedef struct { int key;/* other fields */}element;element heap[MAX_SIZE]; [1] 80 [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] 40

  7. MIN-MAX Heaps (5/10) item.key = 80 5 • min_max_insert: Insert item into the min-max heap *n = 14 13 12 complexity: O(log n) parent = 6 7 [1] min 5 7 [2] [3] max 70 40 80 [4] [5] [6] [7] 30 9 10 7 15 min 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 heap[k].key • No element in heap with key smaller than item.key • Item may be inserted into the root. • 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 iteminserted into node k.

  10. MIN-MAX Heaps (8/10) • 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.

  11. complexity: O(log n) *n = 12 11 i = 5 1 • delete_min: • Delete the minimum element from the min-max heap last = 5 k = 11 5 parent = 2 temp.key = x.key = 12 [1] [0] 7 9 7 [2] [3] 70 40 [4] [5] [6] [7] 30 9 12 10 15 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 <= j.key

  14. Deaps(2/8) • i = min_partner(n) = • j = max_partner(n) = • if j > heapsize j /= 2

  15. 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 Insert(3/8)

  16. Deaps(4/8) • Insertion Into A Deap

  17. Deaps(5/8)

  18. Deaps(6/8)

  19. 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 delete min(7/8)

  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 • 1+min(shortest(left(x)),shortest(right(x))}

  23. Leftist Trees(3/7) • Definition: shortest(left(x)) >= shortest(right(x))

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

  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(i+c+dmlogi)

  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 > 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 x’s 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 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 (2 comes from 1st child and root)

  44. Fibonacci Heaps(7/8) • That’s why the data structure is called Fibonacci Heap

  45. Fibonacci Heaps(8/8) • Application Of F-heaps

More Related