Design and Analysis of Algorithms 演算法設計與分析. Lecture 8 November 16, 2016 洪國寶

Transcription

1 Design and Analysis of Algorithms 演算法設計與分析 Lecture 8 November 6, 206 洪國寶

2 Outline Review Amortized analysis Advanced data structures Binary heaps Binomial heaps Fibonacci heaps Data structures for disjoint sets 2

3 Huffman code (Implementation) Time complexity and data structure: Let S be the set of n weights (nodes). Constructing a Huffamn code based on greedy strategy can be described as following Repeat until S = Find two min nodes x and y from S and remove them from S Construct a new node z with weight w(z)=w(x)+w(y) and insert z into S 3

4 Huffman code (Implementation) Why data structures are important? An algorithm for constructing Huffman code (Tree): Repeat until S = Find two min nodes x and y from S and remove them from S Construct a new node z with weight w(z)=w(x)+w(y) and insert z into S The time complexity of the algorithm depends on how S is implemented. Data structure for S each iteration total linked list O(n) O() O(n 2 ) Sorted array O() O(n) O(n 2 )? O(log n) O(log n) O(n log n) 4

5 Priority Queues A priority queue is an abstract data type which is like a regular queue or stack data structure, but where additionally each element has a "priority" associated with it. In a priority queue, an element with high priority is served before an element with low priority. Priority queues are often implemented with heaps. Applications. Dijkstra's shortest path algorithm. Prim's MST algorithm. Event-driven simulation. Huffman encoding. (Lecture 6) Heapsort.... 5

6 Mergeable Heaps Support the following operations. MAKE-HEAP() creates and returns a new heap containing no elements. INSERT(H, x) inserts node x, whose key field has already been filled in, into heap H. MINIMUM(H) returns a pointer to the node in heap H whose key is minimum. EXTRACT-MIN(H) deletes the node from heap H whose key is minimum, returning a pointer to the node. UNION(Hl, H2) creates and returns a new heap that contains all the nodes of heaps H and H2. Heaps H and H2 are "destroyed" by this operation. DECREASE-KEY(H, x, k) assigns to node x within heap H the new key value k, which is assumed to be no greater than its current key value. DELETE(H, x) deletes node x from heap H. 6

7 Priority Queues Operation Linked List Mergeable Heaps Binary Binomial Fibonacci * make-heap insert log N log N minimum N log N extract-min N log N log N log N union N log N decrease-key log N log N delete N log N log N log N Dijkstra/Prim make-heap V insert V extract-min E decrease-key O( V 2 ) O( E log V ) O( E + V log V ) 7

8 Binary Heap: Definition Binary heap. Almost complete binary tree. filled on all levels, except last, where filled from left to right Min-heap ordered. every child greater than (or equal to) parent

9 Properties. Binary Heap: Properties Min element is in root. Heap with N elements has height = log 2 N N = 4 Height =

10 Binary Heaps: Array Implementation Implementing binary heaps. Use an array: no need for explicit parent or child pointers. Parent(i) = i/2 Left(i) = 2i Right(i) = 2i

11 Binary heap operations Make-heap make-heap( ) allocate an array H on size N heap-size[h] 0 Minimum minimum(h) return H[]

12 Inserting into a binary heap There are two constraints that must be met an almost complete tree the heap-order property We increase the size of the heap to make a hole in the next spot It the item can be legally inserted in the hole, then do so, otherwise move the parent value down and try again 2

13 Binary Heap: Insertion example Insert element x (key = 42) into heap. Insert into next available slot. Bubble up until it's heap ordered next free slot 3

14 Binary Heap: Insertion example Insert element x (key = 42) into heap. Insert into next available slot. Bubble up until it's heap ordered. 06 swap with parent

15 Binary Heap: Insertion example Insert element x (key = 42) into heap. Insert into next available slot. Bubble up until it's heap ordered. 06 swap with parent

16 Binary Heap: Insertion example Insert element x (key = 42) into heap. Insert into next available slot. Bubble up until it's heap ordered. 06 stop: heap ordered

17 Binary Heap: Insertion algorithm insert(h,k) heap-size[h] heap-size[h]+ i heap-size[h] while i > and H[parent(i)] > k do H[i] H[parent(i)] i parent(i) H[i] k Time complexity = O(tree height) = O(log n) 7

18 Binary Heap: Decrease Key Decrease key of element x to k. Bubble up until it's heap ordered

19 Binary Heap: Decrease Key decrease-key(h,i,k) while i > and H[parent(i)] > k do H[i] H[parent(i)] i parent(i) H[i] k Time complexity = O(tree height) = O(log n) 9

20 Binary Heap: Extract-Min Delete minimum element from heap. Exchange root with rightmost leaf. Bubble root down until it's heap ordered. power struggle principle: better subordinate is promoted

21 Binary Heap: Extract-Min Delete minimum element from heap. Exchange root with rightmost leaf. Bubble root down until it's heap ordered. power struggle principle: better subordinate is promoted

22 Binary Heap: Extract-Min Delete minimum element from heap. Exchange root with rightmost leaf. Bubble root down until it's heap ordered. power struggle principle: better subordinate is promoted 53 exchange with left child

23 Binary Heap: Extract-Min Delete minimum element from heap. Exchange root with rightmost leaf. Bubble root down until it's heap ordered. power struggle principle: better subordinate is promoted 4 exchange with right child

24 Binary Heap: Extract-Min Delete minimum element from heap. Exchange root with rightmost leaf. Bubble root down until it's heap ordered. power struggle principle: better subordinate is promoted Time complexity = O(tree height) = O(log n) 4 stop: heap ordered

25 Binary Heap: Extract-Min extract-min(h) if heap-size[h] < then error heap underflow min H[] H[] H[heap-size(H)] heap-size[h] heap-size[h] - heapify(h, ) return min Bubble root down until it's heap ordered. 25

26 Binary Heap: Heapify When heapify(h,i) is called, it is assumed that the binary trees rooted at left(i) and right(i) are heaps, but that A[i] may be larger than its children, thus violating the heap property. The function of heapify is to let the value at A[i] float down in the heap so that the subtree rooted at index i becomes a heap. The running time is O(h) if the height of node i is h. 26

27 Binary Heap: Heapify heapify(h,i) l left(i) r right(i) if l heap-size[h] and H[l] < H[i] then smallest l else smallest i if r heap-size[h] and H[r] < H[smallest] then smallest r if smallest i then H[i] H[smallest] heapify(h,smallest) 27

28 Binary Heap: Delete delete(h,i) H[i] H[heap-size[H]] heap-size[h] heap-size[h] heapify(h,i) 28

29 Union. Binary Heap: Union Combine two binary heaps H and H 2 into a single heap. No easy solution. (N) operations apparently required Can support fast union with fancier heaps. H H

30 Binary Heap: Union Union(H,H2) H make-heap() heap-size[h] heap-size[h] + heapsize[h2] for i to heap-size[h] do H[i] H[i] for i to heap-size[h2] do H[heap-size[H]+i] H2[i] for i heap-size[h]/2 down to do heapify(h,i) 30

31 Binary Heap: Union H H

32 Binary Heap: Union Proof of correctness by loop invariant At the start of each iteration, each node i+, i+2,,n is the root of a heap Time complexity Simple upper bound: each call to HEAPIFY: O(lg n) O(n) such calls running time at most O(n lg n) A tighter bound is O(n). 32

33 Binary Heap: Union Time complexity A tighter bound is O(n). (Use blackboard) 33

34 Binary Heap: Heapsort To sort N items: Insert N items into a binary max-heap. Perform N extract-max operations. O(N log N) sort. No extra storage (in-place sort). Which one is better? Merge sort or heap sort? 34

35 Build-Max-Heap Operation We start by recognizing that if each subtree of a node is a heap, then when we connect the two subtrees, we can obtain a new heap by finding where the root value should go All leaf nodes are, by definition, heaps 35

36 36

37 37

38 Example: The action of max-heapify(a,2) 38

39 39

40 Example: The operation of build-max-heap 40

41 Running Time of BUILD-MAX-HEAP Simple upper bound: each call to MAX-HEAPIFY: O(lg n) O(n) such calls running time at most O(n lg n) A tighter bound is O(n). 4

42 42

43 43

44 Running Time of HEAPSORT Upper bound: Build max-heap: O(n) each call to MAX-HEAPIFY: O(log n) O(n) such calls running time O(n log n) 44

45 Some sorting algorithms Insertion sort Merge sort Heapsort Quicksort complexity O(n 2 ) O(n log n) O(n log n) O(n log n) In-place sort Data structure Remark yes no yes Linked list On-line sorting Linked list Array 45

46 Sorting algorithms The ideal sorting algorithm would have the following properties: Stable: Equal keys aren't reordered. Operates in place, requiring O() extra space. Worst-case O(n lg(n)) key comparisons. Worst-case O(n) swaps. Adaptive: Speeds up to O(n) when data is nearly sorted or when there are few unique keys. There is no algorithm that has all of these properties, and so the choice of the optimal sorting algorithm depends on the application. 46

47 Animated Sorting Algorithms 47

48 Priority Queues Operation make-heap insert minimum extract-min union decrease-key delete Linked List N N N Mergeable Heaps Binary Binomial Fibonacci * log N log N N log N log N log N log N log N log N log N log N log N log N Coming up next 48

49 Binomial Trees Binomial tree. Recursive definition: B 0 B k B k- B k- B 0 B B 2 B 3 B 4 49

50 Binomial Trees Useful properties of order k binomial tree B k. Number of nodes = 2 k. Height = k. Degree of root = k. Deleting root yields binomial trees B k-,, B 0. B k+ Proof. By induction on k. B k B B 2 B 0 B 0 B B 2 B 3 B 4 50

51 Binomial Trees A property useful for naming the data structure. k B k has i nodes at depth i. depth 0 depth depth 2 depth 3 depth 4 B 4 5

52 Binomial Heap Binomial heap. Vuillemin, 978. Sequence of binomial trees that satisfy binomial heap property. each tree is min-heap ordered 0 or binomial tree of order k B 4 B B 0 52

53 53

54 Binomial Heap: Properties Properties of N-node binomial heap. Min key contained in root of B 0, B,..., B k. (root list) Contains binomial tree B i iff b i = where b n b 2 b b 0 is binary representation of N. At most log 2 N + binomial trees. Height log 2 N N = 9 # trees = 3 height = 4 binary = B 4 B B 0 54

55 Binomial Heap Operation Create a binomial heap make-binomial-heap( ) H allocate-node( ) head[h] nil return H Running time = O() 55

56 Binomial Heap Operation 2 Minimum Running time = O(log n) 56

57 Binomial Heap Operation 3: Union Create heap H that is union of heaps H' and H''. "Mergeable heaps." Easy if H' and H'' are each order k binomial trees. connect roots of H' and H'' choose smaller key to be root of H (Binomial-link) H' H'' 57

58 Binomial Heap: Union 58

59 Binomial Heap: Union =

60 Binomial Heap: Union

61 2 Binomial Heap: Union

62

63

64

65

66 66

67 67

68 Binomial Heap Operation 3: Union Create heap H that is union of heaps H' and H''. Analogous to binary addition. Running time = O(log N) Proportional to number of trees in root lists 2( log 2 N + ) =

69 Binomial Heap Operation 3: Union Running time = O(log N) Binomial-heap-merge: merge two sorted linked lists Proportional to number of trees in root lists 2( log 2 N + ). while loop (line 9- line 2) Each iteration executes one binomial-link O() Proportional to number of trees in root lists 2( log 2 N + ) =

70 Binomial Heap Operation 3: Extract-min Delete node with minimum key in binomial heap H. Find root x with min key in root list of H, and delete H' broken binomial trees H Union(H', H) Running time. O(log N) H H' 70

71 7

72 72

73 Binomial Heap: Extract-min Running time. O(log N). Find the root with minimum key from root list: O(# of trees) = O(log n) 2. Make-binomial-heap: O() 3. Reverse the order of the linked list of x s children: O(degree(x)) = O(log n) 4. Binomial-heap-union: O(log n) H H' 73

74 Binomial Heap Operation 5: Insert Insert a new node x into binomial heap H. H' MakeHeap(x) H Union(H', H) Running time. O(log N) x H H'

75 Binomial Heap Operation 5: Insert 75

76 Binomial Heap: Sequence of Inserts Insert a new node x into binomial heap H. If N =...0, then only steps. If N =...0, then only 2 steps. If N =...0, then only 3 steps. If N =...0, then only 4 steps x 37 Inserting item can take (log N) time. If N =..., then log 2 N steps But, inserting sequence of N items takes O(N) time! (N/2)() + (N/4)(2) + (N/8)(3) N Amortized analysis. Basis for getting most operations down to constant time. N n n n N 2 N 2 N 76

77 Binomial Heap Operation 6: Decrease Key Decrease key of node x in binomial heap H. Suppose x is in binomial tree B k. Bubble node x up the tree if x is too small. Running time. O(log N) Proportional to depth of node x log 2 N depth = H x

78 78

79 79

80 Binomial Heap Operation 7: Delete Delete node x in binomial heap H. Decrease key of x to -. Delete min. Running time. O(log N) 80

81 Binomial Heap Operation 7: Delete 8

82 Questions? 82