Fibonacci Heaps Priority Queues. John Ross Wallrabenstein

Size: px

Start display at page:

Download "Fibonacci Heaps Priority Queues. John Ross Wallrabenstein"

Ferdinand Dean
5 years ago
Views:

1 Fibonacci Heaps Priority Queues John Ross Wallrabenstein

2 Updates Project 4 Grades Released Project 5 Questions?

3 Review *This usually refers to the size of the structure

4 Review What is a static data structure? *This usually refers to the size of the structure

5 Review What is a static data structure? Data Structures that do not change* over the lifetime of their use *This usually refers to the size of the structure

6 Review

7 Review What is a dynamic data structure?

8 Review What is a dynamic data structure? Data Structures that change over their lifetime, allowing for efficient updates

9 Review Can you describe the Union/Find algorithm and its applications? Can you describe the Union By Rank heuristic? Can you describe Path Compression?

10 Union By Rank /** * Combines the set that contains a with the set that contains b. */ public void union(int a, int b) { Node na = findnode(a); Node nb = findnode(b); if (na == nb) { return; } // Link the smaller tree under the larger. if (na.rank > nb.rank) { // Delete nb. nb.child.parent = na.child; na.value = b; } else { // Delete na. na.child.parent = nb.child; nb.value = b; } } if (na.rank == nb.rank) { nb.rank++; }

11 Path Compression /** * Finds the set containing a given Node. */ private Node findnode(node node) { int top = 0; // Find the child of the root element. while (node.parent.child == null) { stack[top++] = node; node = node.parent; } // Do path compression on the way back down. Node rootchild = node; while (top > 0) { node = stack[--top]; node.parent = rootchild; } } return rootchild.parent;

12 Today s Goal What is a Queue? What is a Priority Queue? We will implement a Priority Queue efficiently using a Fibonacci Heap

13 Overview Tree Theory Heaps Fibonacci Heaps Priority Queues

14 Tree Theory A free tree is a connected, acyclic undirected graph A graph is connected if every pair of vertices is connected by some path A graph is acyclic if it contains no cycles

15 Free Tree

16 Rooted Trees A rooted tree is a free tree where one vertex is distinguished from the others as the root

17 Rooted Tree Root

18 Terminology An ancestor of node x is any node on the path from x to the root Similarly, if node y is an ancestor of x, then x is a descendent of y A leaf node has no descendants

19 Binary Tree A binary tree satisfies the property that every node has at most two children

20 Overview Tree Theory Heaps Fibonacci Heaps Priority Queues

21 Heaps A heap is a complete binary tree satisfying one of the following heap properties: Max-Heap: the parent of every node has a rank greater than or equal to all of its children Min-Heap: the parent of every node has a rank less than or equal to all of its children

22 Aside Which data structure do you use to organize your priorities? e.g. If you use a max-heap, you visit cracked.com before doing CS 180 work Assumption: Your last priority has a higher rank than your #1 priority

23 Max-Heap

24 Maintaining the Heap Property We will assume for now that the tree is self-balancing e.g. The height is kept at a minimum of log n When a node is inserted, the heap may no longer satisfy the {min,max} property

25 Maintaining the Heap Property To fix the heap, we recursively heapify so that the {min,max}-property is maintained Yes, heapify is the actual term!

26 Maintaining the Heap Property Max-Heapify Invariant: We will assume the binary trees rooted at Left(i) and Right(i) are max-heaps We will assume the inserted node x may be smaller than its children This violates the property

27 Maintaining the Heap Property Basic Idea: Let node i float down to its proper position so that the max-heap property is satisfied

28 Max-Heapify

29 Max-Heapify

30 Overview Tree Theory Heaps Fibonacci Heaps Priority Queues

31 Fibonacci Heaps A Fibonacci Heap is a forest of min-heap trees Their name is derived from the Fibonacci Numbers, which are used in their asymptotic analysis

32 Operations We will only concern ourselves with the following operations: Insert Extract-Min There are others, but the additional complexity is not necessary for queues* *You should thank me for not covering this

33 Motivation Fibonacci Heaps have fast amortized cost relative to other data structures Heaps in general support priority queues

34 Motivation While Fibonacci Heaps are min-heaps, we can easily use them as priority queues How? Define lesser values to have higher priority (this is somewhat natural)

35 Underlying Structure Fibonacci Heaps are commonly implemented using a circular doubly-linked list Brief review of standard operations over a doubly-linked list See board

36 WARNING The following image has been found to induce disgust, confusion and seizures I promise things won t seem as bad as they look*! *By not covering your eyes, you absolve me of all legal liability with respect to your mental/emotional well-being

37 C-DLL Structure *Ignore the dark, or marked nodes

38 Fibonacci Heaps Lecture slides adapted from: Chapter 19 Kevin Wayne s slides from the 2007 Princeton University Algorithms y y g class

39 Priority Queues Performance Operation Linked List Binary Heap Fibonacci Heap make-heap is-empty insert 1 log n 1 delete-min n log n log n decrease-key n log n 1 delete n log n log n union 1 n 1 find-min n 1 1 n =numberofelementsinpriorityqueue elements amortized Hopeless challenge. O(1) insert, delete- min and decrease- key. Why? 2

40 Fibonacci Heaps: Structure Fibonacci heap. Set of heap- ordered trees. Maintain pointer to minimum element. Set of marked nodes. find- min takes O(1) time min Heap H 4

41 Fibonacci Heaps: Structure Fibonacci heap. Set of heap- ordered trees. Maintain pointer to minimum element. Set of marked nodes. roots heap-ordered tree Heap H 5

42 Fibonacci Heaps: Notation Notation n = number of nodes in heap. rank(x) = number of children of node x. rank(h) = max rank of any node in heap H. trees(h) = number of trees in heap H. marks(h) = number of marked nodes in heap H. (Note: terms different in text) trees(h) = 5 marks(h) k(h) = 3 n = 14 rank = 3 min Heap H 35 marked

43 Insert 9

44 Fibonacci Heaps: Insert Insert. Create a new singleton tree. Add to root list; update min pointer (if necessary). insert min Heap H

45 Fibonacci Heaps: Insert Insert. Create a new singleton tree. Add to root list; update min pointer (if necessary). insert 21 min Heap H

46 Fibonacci Heaps: Insert Analysis Actual cost. O(1) Change in potential. +1 (H) = trees(h) + 2 marks(h) potential of heap H Amortized cost. O(1) min Heap H

47 Delete Min 13

48 Linking Operation Linking operation. Make larger root a child of smaller root. larger root smaller root still heap-ordered tree T 1 tree T 2 77 tree T' 14

49 Delete min. Delete min Fibonacci Heaps: Delete Min Meld its children into the root list and update min. Consolidate trees so that no two roots have same rank. min

50 Fibonacci Heaps: Delete Min Delete min. Delete min Meld its children into the root list and update min. Consolidate trees so that no two roots have same rank. min

51 Fibonacci Heaps: Delete Min Delete min. Delete min Meld its children into the root list and update min. Consolidate trees so that no two roots have same rank: Repeatedly link two trees of the same rank until no pair of roots has the same rank (= degree) min current

52 Fibonacci Heaps: Delete Min Delete min. Delete min. Meld its children into the root list and update min. Consolidate trees so that no two roots have same rank. rank min current

53 Fibonacci Heaps: Delete Min Delete min. Delete min. Meld its children into the root list and update min. Consolidate trees so that no two roots have same rank. rank min current

54 Fibonacci Heaps: Delete Min Delete min. Delete min. Meld its children into the root list and update min. Consolidate trees so that no two roots have same rank. rank min current

55 Fibonacci Heaps: Delete Min Delete min. Delete min Meld its children into the root list and update min. Consolidate trees so that no two roots have same rank. rank min current link 23 into 17 21

56 Fibonacci Heaps: Delete Min Delete min. Delete min. Meld its children into the root list and update min. Consolidate trees so that no two roots have same rank. rank min current link 17 into 7 22

57 Fibonacci Heaps: Delete Min Delete min. Delete min. Meld its children into the root list and update min. Consolidate trees so that no two roots have same rank. rank current 24 min link 24 into 7 23

58 Fibonacci Heaps: Delete Min Delete min. Delete min. Meld its children into root list; update min. Consolidate trees so that no two roots have same rank. rank current min

59 Fibonacci Heaps: Delete Min Delete min. Delete min; meld its children into root list; update min. Consolidate trees so that no two roots have same rank. rank current min

60 Fibonacci Heaps: Delete Min Delete min. Delete min. Meld its children into root list; update min. Consolidate trees so that no two roots have same rank. rank min current

61 Fibonacci Heaps: Delete Min Delete min. Delete min. Meld its children into root list; update min. Consolidate trees so that no two roots have same rank. rank min current link 41 into 18 27

62 Fibonacci Heaps: Delete Min Delete min. Delete min; meld its children into root list; update min. Consolidate trees so that no two roots have same rank. rank current min

63 Fibonacci Heaps: Delete Min Delete min. Delete min; meld its children into root list; update min. Consolidate trees so that no two roots have same rank. rank min 7 52 current

64 Fibonacci Heaps: Delete Min Delete min. Delete min. Meld its children into root list; update min. Consolidate trees so that no two roots have same rank. min

65 Before delete - min After consolidation, no two roots have the same degree and the largest degree in O(log n) min After delete - min 31

Chapter 5 Data Structures Algorithm Theory WS 2016/17 Fabian Kuhn

Chapter 5 Data Structures Algorithm Theory WS 06/ Fabian Kuhn Examples Dictionary: Operations: insert(key,value), delete(key), find(key) Implementations: Linked list: all operations take O(n) time (n: