Data Structures Week #8. Heaps (Priority Queues)
|
|
|
- Eric Horton
- 5 years ago
- Views:
Transcription
1 Data Structures Week #8 Heaps (Priority Queues)
2 Outline Motivation for Heaps Implementation Alternatives of PQs Binary Heaps Basic Heap Operations (Insert, DeleteMin) Other Heap Operation BuildHeap, DecreaseKey, IncreaseKey, Delete d-heaps Leftist Heaps Binomial Heaps October 5, 2015 Borahan Tümer, Ph.D. 2
3 Motivation for Heaps Priority queues are queues in which jobs with different priorities are enqueued and handled accordingly. Heaps are data structures that are used to implement priority queues. Heaps can be represented in an array since a complete binary tree is very regular. Two basic operations Insert (average O(1), worst case O(log n)), and DeleteMin (O(log n)). October 5, 2015 Borahan Tümer, Ph.D. 3
4 Implementation Issues Implementation Insertion DeleteMin Array (Cmplt BT) O(1) O(log(n)) Linked List O(1) O(n) Linked List (sorted) O(n) O(1) BST O(log(n)) O(log(n)) October 5, 2015 Borahan Tümer, Ph.D. 4
5 Keys in Heaps In the scope of this class (CSE 225), a key in a heap is the priority value of the corresponding node which determines the position of its node in the heap; i.e., in a min-heap the node with the minimum key is the node with the highest priority, hence it is the root. October 5, 2015 Borahan Tümer, Ph.D. 5
6 Binary Heaps A binary heap is a completely filled binary tree with the possible exception of the bottom level, (known as a complete binary tree) filled from left to right with two properties: Structure property Heap order property October 5, 2015 Borahan Tümer, Ph.D. 6
7 Structure Property If a complete binary tree is represented in an array, then for any element in array position i, the left child is in position 2i and the right child in 2i+1 iff they exist (i.e., 2i < n and 2i+1 < n, respectively). October 5, 2015 Borahan Tümer, Ph.D. 7
8 (Min)Heap Order Property In a heap, for every node X, the key in the parent of X is smaller than (or equal to) the key in X, with the exception of the root since it has no parent. (Depending on the application, the opposite of this may be considered as the heap order property, too!!!) October 5, 2015 Borahan Tümer, Ph.D. 8
9 Insertion Steps of Insertion operation Create a hole in the next available location; If heap order property is not violated Then we are done; Else loop» exchange the hole with the parent node until the heap property is restored (i.e., percolate the hole up) Worst time best upper bound: O(log(n)) October 5, 2015 Borahan Tümer, Ph.D. 9
10 Insert Function void insert(elmnttype x, PrQ h) { // array starts at cell #1 not #0 int i; if (isfull(h)){ display( queue full: unsuccessful insertion ); return; } for (i = ++h->size; h->elements[i/2] > x; i/=2 ) h->elements[i] = h->elements[i/2]; h->elements[i] = x; } October 5, 2015 Borahan Tümer, Ph.D. 10
11 Animated Insertion Example Current Heap October 5, 2015 Borahan Tümer, Ph.D. 11
12 Inserting < 20 October 5, 2015 Borahan Tümer, Ph.D. 12
13 Inserting < 20 October 5, 2015 Borahan Tümer, Ph.D. 13
14 Inserting < 16 October 5, 2015 Borahan Tümer, Ph.D. 14
15 Inserting < 16 October 5, 2015 Borahan Tümer, Ph.D. 15
16 Inserting < 8 October 5, 2015 Borahan Tümer, Ph.D. 16
17 Inserting < 8 October 5, 2015 Borahan Tümer, Ph.D. 17
18 Inserting October 5, 2015 Borahan Tümer, Ph.D. 18
19 DeleteMin Operation Steps of DeleteMin operation Remove the minimum element (at the root) from the heap; If the last element can be placed in the hole Then we are done; Else Loop» exchange the hole with the smaller child node until the last element moves in the heap (i.e., percolate the hole down). October 5, 2015 Borahan Tümer, Ph.D. 19
20 DeleteMin Operation ElmntType DeleteMin(PrQ h) { int i, chld; ElmntType minelm, lastelm; if isempty(h){ display( queue empty ) return (h->elements[0]); } minelm=h->elements[1]; lastelm=h->elements[h->size--];... Cont d at the next page! October 5, 2015 Borahan Tümer, Ph.D. 20
21 DeleteMin Operation... (cont d) for (i=1; i * 2 <= h->size; i=chld) { // find smaller child chld=i*2; if (chld!= h->size && h->elements[chld+1] < h->elements[chld]) chld++; // percolate one level if ( lastelm > h->elements[chld] ) h->elements[i] = h->elements[chld]; else break; } h->elements[i] =lastelm; //restore min-heap property in case it is violated by placing lastelm to heap s i th node for (j = i; h->elements[j/2] > lastelm; j/=2 ) h->elements[j] = h->elements[j/2]; h->elements[j] = lastelm; return minelm; } October 5, 2015 Borahan Tümer, Ph.D. 21
22 DeleteMin Operation Empty October 5, 2015 Borahan Tümer, Ph.D. 22
23 Removing 8... i child 8 minelm i hsize Empty minelm Child (index pointing to child with smaller key) October 5, 2015 Borahan Tümer, Ph.D. 23 lastelm
24 Removing 8... child 15 minelm i i hsize Empty minelm Child (index pointing to child with smaller key) October 5, 2015 Borahan Tümer, Ph.D. 24 lastelm
25 Removing 8... child 15 minelm i i hsize Empty minelm Child (index pointing to child with smaller key) October 5, 2015 Borahan Tümer, Ph.D. 25 lastelm
26 Removing 8... child 15 minelm i i No children for node i!!! hsize Empty minelm Child (index pointing to child with smaller key) October 5, 2015 Borahan Tümer, Ph.D. 26 lastelm
27 Removing 8... child 15 minelm i 98 i No children for node i!!! hsize Empty minelm October 5, 2015 Borahan Tümer, Ph.D. 27 null lastelm
28 8 Removed! Empty October 5, 2015 Borahan Tümer, Ph.D. 28
29 Other Heap Operations Other Heap Operations DecreaseKey(I,D,HeapHeader); IncreaseKey(I,D,HeapHeader); Delete(I,HeapHeader); BuildHeap(HeapHeader); October 5, 2015 Borahan Tümer, Ph.D. 29
30 DecreaseKey and IncreaseKey DecreaseKey (I,D,HeapHeader) & IncreaseKey (I,D,HeapHeader) These two operations decrease or increase the key at position i of the heap the root of which is pointed to by the HeapHeader by the amount D, respectively. Any of these two operations may violate the heap order. By percolating the modified key up or down after the DecreaseKey operation or IncreaseKey operation, respectively, the heap order property may be restored. October 5, 2015 Borahan Tümer, Ph.D. 30
31 Removal of any Key Delete (I,HeapHeader) This operation removes any key in the heap structure. Again, after the removal of the element from the heap, the heap order property may be violated. In this case, we may consider the node of the key removed as the root, and the corresponding subtree as the tree we perform a DeleteMin on. Then using the DeleteMin operation, the heap order property is restored. October 5, 2015 Borahan Tümer, Ph.D. 31
32 BuildHeap BuildHeap(HeapHeader) This operation is used to build a heap from a set of input data (e.g., numbers). Assuming that a set of numbers are arbitrarily (i.e., with no consideration of the heap order property) placed in a complete binary tree, we build a binary heap in For n numbers, this operation can be performed in n successive inserts. Since an insert takes O(1) in average and O(log(n)) worst case, Buildheap takes an average time of n*o(1)=o(n) and n*o(log(n)) = O(n*log(n)) in the worst case. October 5, 2015 Borahan Tümer, Ph.D. 32
33 BuildHeap Algorithm Starting from the rightmost subtree with a height of 1, Loop compare the children and find the smaller child compare the smaller child with the parent exchange the smaller child with the parent. until all nodes in the tree are processed. Subtrees with roots of height greater than 1, the parent must be percolated down until the heap order property is restored. An example follows. October 5, 2015 Borahan Tümer, Ph.D. 33
34 Constructing a MinHeap Animation October 5, 2015 Borahan Tümer, Ph.D. 34
35 Constructing a MinHeap Animation > 16 October 5, 2015 Borahan Tümer, Ph.D. 35
36 Constructing a MinHeap Animation > 16 October 5, 2015 Borahan Tümer, Ph.D. 36
37 Constructing a MinHeap Animation OK! October 5, 2015 Borahan Tümer, Ph.D. 37
38 Constructing a MinHeap Animation > 20 October 5, 2015 Borahan Tümer, Ph.D. 38
39 Constructing a MinHeap Animation > 20 October 5, 2015 Borahan Tümer, Ph.D. 39
40 Constructing a MinHeap Animation October 5, 2015 Borahan Tümer, Ph.D. 40
41 Constructing a MinHeap Animation > 8 October 5, 2015 Borahan Tümer, Ph.D. 41
42 Constructing a MinHeap Animation > 8 October 5, 2015 Borahan Tümer, Ph.D. 42
43 Constructing a MinHeap Animation > 8 October 5, 2015 Borahan Tümer, Ph.D. 43
44 Constructing a MinHeap Animation > 8 October 5, 2015 Borahan Tümer, Ph.D. 44
45 Constructing a MinHeap Animation > 12 October 5, 2015 Borahan Tümer, Ph.D. 45
46 Constructing a MinHeap Animation > 12 October 5, 2015 Borahan Tümer, Ph.D. 46
47 Constructing a MinHeap Animation OK! October 5, 2015 Borahan Tümer, Ph.D. 47
48 Constructing a MinHeap Animation OK! October 5, 2015 Borahan Tümer, Ph.D.
49 Constructing a MinHeap Animation OK! October 5, 2015 Borahan Tümer, Ph.D. 49
50 Constructing a MinHeap Animation < 20 October 5, 2015 Borahan Tümer, Ph.D. 50
51 Constructing a MinHeap Animation < 20 October 5, 2015 Borahan Tümer, Ph.D. 51
52 Constructing a MinHeap Animation < 16 October 5, 2015 Borahan Tümer, Ph.D. 52
53 Constructing a MinHeap Animation < 16 October 5, 2015 Borahan Tümer, Ph.D. 53
54 Constructing a MinHeap Animation < 8 October 5, 2015 Borahan Tümer, Ph.D. 54
55 Constructing a MinHeap Animation < 8 October 5, 2015 Borahan Tümer, Ph.D. 55
56 Constructing a MinHeap Animation October 5, 2015 Borahan Tümer, Ph.D. 56
57 Constructing a MinHeap Classwork October 5, 2015 Borahan Tümer, Ph.D. 57
58 Constructing a MinHeap October 5, 2015 Borahan Tümer, Ph.D. 58
59 Constructing a MinHeap October 5, 2015 Borahan Tümer, Ph.D. 59
60 Constructing a MinHeap October 5, 2015 Borahan Tümer, Ph.D. 60
61 Constructing a MinHeap OK October 5, 2015 Borahan Tümer, Ph.D. 61
62 Constructing a MinHeap OK October 5, 2015 Borahan Tümer, Ph.D. 62
63 Constructing a MinHeap OK October 5, 2015 Borahan Tümer, Ph.D. 63
64 Constructing a MinHeap October 5, 2015 Borahan Tümer, Ph.D. 64
65 Constructing a MinHeap October 5, 2015 Borahan Tümer, Ph.D. 65
66 Constructing a MinHeap OK October 5, 2015 Borahan Tümer, Ph.D. 66
67 Constructing a MinHeap October 5, 2015 Borahan Tümer, Ph.D. 67
68 Constructing a MinHeap October 5, 2015 Borahan Tümer, Ph.D. 68
69 Constructing a MinHeap October 5, 2015 Borahan Tümer, Ph.D. 69
70 Constructing a MinHeap October 5, 2015 Borahan Tümer, Ph.D. 70
71 Constructing a MinHeap October 5, 2015 Borahan Tümer, Ph.D. 71
72 Constructing a MinHeap October 5, 2015 Borahan Tümer, Ph.D. 72
73 Constructing a MinHeap October 5, 2015 Borahan Tümer, Ph.D. 73
74 Constructing a MinHeap October 5, 2015 Borahan Tümer, Ph.D. 74
75 Constructing a MinHeap October 5, 2015 Borahan Tümer, Ph.D. 75
76 Constructing a MinHeap October 5, 2015 Borahan Tümer, Ph.D. 76
77 d-heaps d-heaps A simple generalization to binary heaps is a d-heap, which is exactly like a binary heap except that all nodes have d children (i.e., a binary heap is a 2-heap). October 5, 2015 Borahan Tümer, Ph.D. 77
78 Leftist Heaps October 5, 2015 Borahan Tümer, Ph.D. 78
79 Motivation for Leftist Heaps Leftist heaps make merging possible in O(log n) time (log n insertions each with O(1) average time) using only an array as in binary heaps. LHs have both a structural property, and an ordering property. A LH has the same heap order property. A LH is a binary tree. Difference between a LH and a binary heap is a LH is not perfectly balanced. October 5, 2015 Borahan Tümer, Ph.D. 79
80 Leftist Heap Property Definition: Null path length of a node X, Npl(X), is defined as the length of the shortest path from X to a node without two children. By definition, Npl(NULL)=-1. Npl(leaf)=0. LH property is that for every node X in the heap, Npl(LCX) Npl(RCX) where LCX and RCX denote the left child and the right child of node X, respectively. October 5, 2015 Borahan Tümer, Ph.D. 80
81 Both are leftist heaps? Two binary trees October 5, 2015 Borahan Tümer, Ph.D. 81
82 Leftist Heap Operations (Merging) The fundamental operation is merging. Two solutions recursive version non-recursive version Check and make sure that both binary trees are actually LHs! October 5, 2015 Borahan Tümer, Ph.D. 82
83 Recursive Merging Algorithm 1. Input: two LHs. 2. First check that both binary trees are LHs. 3. If either heap is empty, then the result of the merge is the other heap. 4. If not, then compare the roots 5. Recursively merge the heap with the larger root with right subheap of the heap with the smaller root. October 5, 2015 Borahan Tümer, Ph.D. 83
84 Recursive Merging Algorithm 6. The recursive function at Step 5 will invoke itself until the base condition at Step 3 (i.e., that one LH is empty) will be attained. At this point the execution will start returning step by step to the original function call while building up the merged heap starting from the bottom level. 7. At each step, check if the LH property is violated. If so, swap the right child and the left child. 8. After each swap, compute the new Npl(LH) by adding 1 to the Npl(new RC) 9. End of the recursive algorithm October 5, 2015 Borahan Tümer, Ph.D. 84
85 Merging Example H1 H2 October 5, 2015 Borahan Tümer, Ph.D. 85
86 Recursive Merging Algorithm 1. Input: two LHs H1 and H2 ( on slide 65 ). 2. Both binary trees are LHs. 3. No heap is empty < Recursively merge the heap with 15 with right subheap of the heap with 12. October 5, 2015 Borahan Tümer, Ph.D. 86
87 Merging Example H1 H2 October 5, 2015 Borahan Tümer, Ph.D. 87
88 Recursive Merging Algorithm 1. Input: two LHs H1 (within the red ellipse) and H2 (see slide 67). 2. Both binary trees are LHs. 3. No heap is empty < Recursively merge the heap with 18 with right subheap of the heap with 15. October 5, 2015 Borahan Tümer, Ph.D. 88
89 Merging Example H1 H2 October 5, 2015 Borahan Tümer, Ph.D. 89
90 Recursive Merging Algorithm 1. Input: two LHs H1 and H2 ( both within the red ellipses) (see slide 69). 2. Both binary trees are LHs. 3. No heap is empty < Recursively merge the heap with 21 with right subheap of the heap with 18. October 5, 2015 Borahan Tümer, Ph.D. 90
91 Merging Example H1 H2 October 5, 2015 Borahan Tümer, Ph.D. 91
92 Recursive Merging Algorithm 1. Input: two LHs H1 and H2 ( both within the red ellipses) (see slide 71). 2. Both binary trees are LHs. 3. No heap is empty < Recursively merge the heap with 56 with right subheap of the heap with 21. October 5, 2015 Borahan Tümer, Ph.D. 92
93 Merging Example H1 H2 October 5, 2015 Borahan Tümer, Ph.D. 93
94 Recursive Merging Algorithm 1. Input: two LHs H1 and H2 ( both within the red ellipses) (see slide 73). 2. Both binary trees are LHs. 3. The right child of 21 is null. Hence, the resulting heap of merging the heap with root 56 (H1) and the right subheap of heap with root 21 (i.e., an empty heap) is H1 (the heap with root 56). 7. H1 is still a LH. No swaps necessary! 8. Skip; 9. The execution returns with H1 (see slide 75). October 5, 2015 Borahan Tümer, Ph.D. 94
95 Merging Example H1 H2 October 5, 2015 Borahan Tümer, Ph.D. 95
96 Recursive Merging Algorithm 6. The return address of execution is step 6 of the instance of merge algorithm at which H1 was the heap with root 56 and H2 was the heap with 21 (see slide 71!). Now, the new H1 (H1 ) is the same heap; but it is the result of the last recursive merge. At this step, H1 is merged with the current H2 (see slide 75!) 7. H2 is still a LH. No swaps necessary! 8. Skip; 9. The execution returns with H2 (see slide 77). October 5, 2015 Borahan Tümer, Ph.D. 96
97 Merging Example H1 H2 October 5, 2015 Borahan Tümer, Ph.D. 97
98 Recursive Merging Algorithm 6. The return address of execution is step 6 of the instance of merge algorithm at which H1 was the heap with root 18 and H2 was the heap with 21 (see slide 69!). Now, H2 is merged with the current H1 (see slide 77!) 7. H1 is still a LH. No swaps necessary! 8. Skip; 9. The execution returns with H1 (see slide 79). October 5, 2015 Borahan Tümer, Ph.D. 98
99 Merging Example H1 H2 October 5, 2015 Borahan Tümer, Ph.D. 99
100 Recursive Merging Algorithm 6. The return address of execution is step 6 of the instance of merge algorithm at which H1 was the heap with root 18 and H2 was the heap with 15 (see slide 67!). Now, H1 is merged with the current H2 (see slide 79!) 7. H2 is not a LH (Npl(LC)<Npl(RC)). (see slide 81!) 8. We swap LC and RC of 15! 9. Execution returns with H2 (see slide 82). October 5, 2015 Borahan Tümer, Ph.D. 100
101 Merging Example H1 H October 5, 2015 Borahan Tümer, Ph.D. 101
102 Merging Example H1 H2 October 5, 2015 Borahan Tümer, Ph.D. 102
103 Recursive Merging Algorithm 6. The return address of execution is step 6 of the instance of merge algorithm at which H1 was the heap with root 12 and H2 was the heap with 15 (see slide 65!). Now, H2 is merged with the current H1 (see slide 84!) 7. H1 is not a LH (Npl(LC)<Npl(RC)). 8. We swap LC and RC of 12! 9. Execution returns with H1 (see slide 85). October 5, 2015 Borahan Tümer, Ph.D. 103
104 Merging Example H October 5, 2015 Borahan Tümer, Ph.D. 104
105 Merging Example H1 October 5, 2015 Borahan Tümer, Ph.D. 105
106 Non-Recursive Merging Algorithm: Two passes First pass: First Pass arrange the nodes on the right-most path of both LHs in sorted order, keeping their respective left children; create a new tree from the two LHs; sort and arrange the nodes above, make them the right path of the new tree. October 5, 2015 Borahan Tümer, Ph.D. 106
107 Non-Recursive Merging Algorithm: Second Pass Start a bottom-up analysis to check and determine the nodes at which the leftist heap property is violated, and perform a swap at these nodes. October 5, 2015 Borahan Tümer, Ph.D. 107
108 Merging Example H1 H2 October 5, 2015 Borahan Tümer, Ph.D. 108
109 Merging Example: First Pass Nodes on the right-most path of both heaps arranged! A new tree made with the above as its right-most path! 56 October 5, 2015 Borahan Tümer, Ph.D. 109
110 Merging Example: First Pass Left children maintained! 12 LH property violated at these nodes! October 5, 2015 Borahan Tümer, Ph.D. 110
111 Merging Example: Second Pass October 5, 2015 Borahan Tümer, Ph.D. 111
112 Time Analysis of Merging using LHs Performing the recursive solution is proportional to the sum of the length of the right paths. The work done at each node visited on the right path is constant. We have O(log(n)) nodes on the right path in a LH with n nodes. October 5, 2015 Borahan Tümer, Ph.D. 112
113 Binomial Heaps October 5, 2015 Borahan Tümer, Ph.D. 113
114 Motivation for Binomial Heaps Leftist Heaps support merging, insertion, removal, and deletemin in O(log(n)) time per operation. We know binary heaps have a constant (i.e., O(1)) insertion time. Question: May there be a data structure providing O(1) time for insertion, and O(log(n)) time for each other operation. This data structure is the so-called binomial heaps (BHs) or binomial queues. To study BHs we first need to discuss binomial trees. October 5, 2015 Borahan Tümer, Ph.D. 114
115 Binomial Trees A binomial tree B k is an ordered tree (i.e., a rooted tree in which the children of each node are ordered; the order of the children matters) defined recursively. The binomial tree B 0 consists of a single node. A binomial tree B k of height k is formed by attaching a B k-1 to the root of another B k-1. In the next slide, we see two B 3 s combined to form a B 4. October 5, 2015 Borahan Tümer, Ph.D. 115
116 Binomial Trees Depth 0 Depth 1 Depth 2 Depth 3 Two binomial trees of height 3, B 3 B 3 B 3 B 0 B 1 B 2 B 3 A binomial tree of height 4, B 4 October 5, 2015 Borahan Tümer, Ph.D. 116
117 Binomial Trees A binomial tree B k has a height of k; n = 2 k nodes (!!!); k+1 depth levels ranging within 0,...,k. k k! ( k d)! nodes at depth level d. d d! a root and a B 0, B 1, B 2, B 3,..., B k-1 connected to it in respective order (see slide 96!). October 5, 2015 Borahan Tümer, Ph.D. 117
118 Binomial Heaps BHs differ from other heap structures in that a BH is not a heap-ordered tree but rather a collection of heap ordered trees, a forest. each heap-ordered tree is of a constrained form known as a binomial tree. Each binomial tree in a BH obeys min-heap or heap order property. There is at most one B k of each height k in a BH. In the next slide, we see an 11-node BH. October 5, 2015 Borahan Tümer, Ph.D. 118
119 An 11-element Binomial Heap B 0 B 1 B 3 October 5, 2015 Borahan Tümer, Ph.D. 119
120 Operations on Binomial Heaps BH_Create() Creates the special header node for the BH. BH_Find_Min() Finds the minimum key in the BH. BH_Merge(H 1,H 2 ) Merges two BHs H 1 and H 2. BH_Insert(H 1,x) Inserts x into H. BH_Delete-Min(H) Deletes the minimum key in H. In preparing algorithms/pseudocode for these operations, [1] has been the main reference. October 5, 2015 Borahan Tümer, Ph.D. 120
121 Operations on Binomial Heaps Assumptions Each node x in a BH contains a key field key[x], a parent pointer, p[x], a child pointer to its left-most child, child[x], a pointer to its immediate right sibling, sibling[x], a field holding the number of children, degree[x]. x parent[x] key[x] degree[x] child[x] sibling[x] October 5, 2015 Borahan Tümer, Ph.D. 121
122 Creating an Empty Tree BH_Header * BH_Create() { // creates a special header node for a BH. } BH_Header *BH_hdr; BH_hdr=(BH_Header *) malloc(sizeof(bh_header));... // here, proper values are assigned to special header fields. BH_hdr->first=NULL; return BH_hdr; Running time: Θ(1) October 5, 2015 Borahan Tümer, Ph.D. 122
123 Finding Minimum Key in a BH BH_Find_Min(BH_hdr) { // finds minimum key in the BH. y=null; x=bh_hdr->first; min= ; while (x!= NULL) if (key[x]<min) { min=key[x]; y=x; } x = sibling[x]; return y; } Running time: O(lg(n)) Why? October 5, 2015 Borahan Tümer, Ph.D. 123
124 Obtaining a B k from two B k-1 s Get_a_BT_k(y,z) { // obtains a B k from two B k-1 s. Root of new B is z. p[y]=z; sibling[y]=child[z]; child[z]=y; degree[z]++; } Running time: Θ(1) October 5, 2015 Borahan Tümer, Ph.D. 124
125 Get_a_BT_k(y,z) illustrated... Before Get_a_BT_k(y,z) After Get_a_BT_k(y,z) y z z k-1 sibling[y] k-1 sibling[z] k child[y] child[z] y Get_a_BT_k(y,z) { p[y]=z; sibling[y]=child[z]; child[z]=y; degree[z]++; } k-1 k-2 October 5, 2015 Borahan Tümer, Ph.D. 125
126 Merging two BHs BH_Merge(BH1_hdr,BH2_hdr) { // merges two BH 1 and BH 2. BH_hdr= BH_Create(); BH_hdr->first=Merge_Root_Lists(); // Merges root lists of BH 1 and BH 2 into one sorted by // ascending degree. if (BH_hdr->first == NULL) return BH_hdr->first; q=null; x=bh_hdr->first; r=sibling[x]; while (r!=null) if (degree[r]!=degree[x] sibling[r]!=null && degree[sibling[r]]==degree[x]) {q=x; x=r;} else if (key[x]<=key[r]){sibling[x]=sibling[r];get_a_bt_k(r,x);} else { if (q == NULL) BH_hdr->first=r; else sibling[q]=r; Get_a_BT_k(x,r); x=r; } r=sibling[x]; return BH_hdr; } Running time: O(lg(n)) October 5, 2015 Borahan Tümer, Ph.D. 126
127 Illustration of Various Cases in Merging degree[r] degree[x] q x r sibling[r] a b c d q x r a b c d B k B k+c B k B k+c sibling[r] NULL && degree[sibling[r]]=degree[x]) q x r sibling[r] a b c d q x r a b c d B k B k B k B k B k B k October 5, 2015 Borahan Tümer, Ph.D. 127
128 Illustration of Various Cases in Merging q x r sibling[r] a b c d key[x] key[r]) 1 B k q x r a b d B k B k B k+c B k B k+c c q x r sibling[r] a b c d key[x]>key[r]) 1 B k B k q x r a c d B k B k B k+c B k B k+c B October 5, 2015 Borahan Tümer, Ph.D. k 128 b
129 An 11-element BH B 0 B 1 B 3 October 5, 2015 Borahan Tümer, Ph.D. 129
130 Another 11-element BH B 0 B 1 B 3 October 5, 2015 Borahan Tümer, Ph.D. 130
131 Two BHs merged October 5, 2015 Borahan Tümer, Ph.D. 131
132 12 Two BHs merged... into a 22-element BH October 5, 2015 Borahan Tümer, Ph.D. 132
133 Inserting a node into a BH Insertion of a node into a BH is the same as merging a singlenode BH with another BH. BH_Insert(BH_hdr,x) { //inserts x into BH. BH1_hdr=BH_Create(); // makes a single-node (degree-0) BH out of x. p[x]=child[x]=sibling[x]=null; degree[x]=0; BH1_hdr->first=x; BH_hdr=BH_Merge(BH1_hdr,BH_hdr); } Running time: worst case: O(lg(n)) October 5, 2015 Borahan Tümer, Ph.D. 133
134 Delete-Min in a BH BH_Delete-Min(BH_hdr) { //deletes the minimum key in the BH. Find the root x with minimum key //(wc: O(lg(n)) ) Remove x BH1_hdr=BH_Create(); Establish a LL of x s children //(wc: O(lg(n)) BH1_hdr->first=pointer to node with degree=0 BH_hdr=BH_Merge(BH1_hdr,BH_hdr); //(wc: O(lg(n)) } Running time: O(lg(n)) October 5, 2015 Borahan Tümer, Ph.D. 134
135 12 13 A 22-element BH... Delete-min October 5, 2015 Borahan Tümer, Ph.D. 135
136 4 removed BH BH October 5, 2015 Borahan Tümer, Ph.D. 136
137 BH... BH merged with BH B 1 s, 2B 2 s B 1 s to merge to a B 2 2 B 2 s to merge to a B 3 October 5, 2015 Borahan Tümer, Ph.D. 137
138 BH... BH merged with BH1... 3B 2 s B 2 s... Last two to merge to a B 3 October 5, 2015 Borahan Tümer, Ph.D. 138
139 BH merged with BH B 3 s BH B 3 s to merge to a B 4 October 5, 2015 Borahan Tümer, Ph.D. 139
140 BH... BH merged with BH1... Final appearance October 5, 2015 Borahan Tümer, Ph.D. 140
141 Reference... [1] T.H. Cormen, C.E. Leiserson, R.L. Rivest, C. Stein, Introduction to Algorithms, 2nd edition, MIT Press, 2003 October 5, 2015 Borahan Tümer, Ph.D. 141
Chapter 6 Heaps. Introduction. Heap Model. Heap Implementation
Introduction Chapter 6 Heaps some systems applications require that items be processed in specialized ways printing may not be best to place on a queue some jobs may be more small 1-page jobs should be
Heap Model. specialized queue required heap (priority queue) provides at least
Chapter 6 Heaps 2 Introduction some systems applications require that items be processed in specialized ways printing may not be best to place on a queue some jobs may be more small 1-page jobs should
Data Structures and Algorithms
Data Structures and Algorithms Spring 2017-2018 Outline 1 Priority Queues Outline Priority Queues 1 Priority Queues Jumping the Queue Priority Queues In normal queue, the mode of selection is first in,
CS350: Data Structures Heaps and Priority Queues
Heaps and Priority Queues James Moscola Department of Engineering & Computer Science York College of Pennsylvania James Moscola Priority Queue An abstract data type of a queue that associates a priority
The priority is indicated by a number, the lower the number - the higher the priority.
CmSc 250 Intro to Algorithms Priority Queues 1. Introduction Usage of queues: in resource management: several users waiting for one and the same resource. Priority queues: some users have priority over
CSCI2100B Data Structures Heaps
CSCI2100B Data Structures Heaps Irwin King king@cse.cuhk.edu.hk http://www.cse.cuhk.edu.hk/~king Department of Computer Science & Engineering The Chinese University of Hong Kong Introduction In some applications,
CMSC 341 Lecture 15 Leftist Heaps
Based on slides from previous iterations of this course CMSC 341 Lecture 15 Leftist Heaps Prof. John Park Review of Heaps Min Binary Heap A min binary heap is a Complete binary tree Neither child is smaller
CMSC 341 Lecture 15 Leftist Heaps
Based on slides from previous iterations of this course CMSC 341 Lecture 15 Leftist Heaps Prof. John Park Review of Heaps Min Binary Heap A min binary heap is a Complete binary tree Neither child is smaller
Priority Queues (Heaps)
Priority Queues (Heaps) October 11, 2016 CMPE 250 Priority Queues October 11, 2016 1 / 29 Priority Queues Many applications require that we process records with keys in order, but not necessarily in full
CE 221 Data Structures and Algorithms
CE 2 Data Structures and Algorithms Chapter 6: Priority Queues (Binary Heaps) Text: Read Weiss, 6.1 6.3 Izmir University of Economics 1 A kind of queue Priority Queue (Heap) Dequeue gets element with the
Leftist Heaps and Skew Heaps. (Leftist Heaps and Skew Heaps) Data Structures and Programming Spring / 41
Leftist Heaps and Skew Heaps (Leftist Heaps and Skew Heaps) Data Structures and Programming Spring 2018 1 / 41 Leftist Heaps A binary heap provides O(log n) inserts and O(log n) deletes but suffers from
3. Priority Queues. ADT Stack : LIFO. ADT Queue : FIFO. ADT Priority Queue : pick the element with the lowest (or highest) priority.
3. Priority Queues 3. Priority Queues ADT Stack : LIFO. ADT Queue : FIFO. ADT Priority Queue : pick the element with the lowest (or highest) priority. Malek Mouhoub, CS340 Winter 2007 1 3. Priority Queues
Readings. Priority Queue ADT. FindMin Problem. Priority Queues & Binary Heaps. List implementation of a Priority Queue
Readings Priority Queues & Binary Heaps Chapter Section.-. CSE Data Structures Winter 00 Binary Heaps FindMin Problem Quickly find the smallest (or highest priority) item in a set Applications: Operating
Priority Queues (Heaps)
Priority Queues (Heaps) 1 Priority Queues Many applications require that we process records with keys in order, but not necessarily in full sorted order. Often we collect a set of items and process the
CMSC 341 Leftist Heaps
CMSC 341 Leftist Heaps Based on slides from previous iterations of this course Today s Topics Review of Min Heaps Introduction of Left-ist Heaps Merge Operation Heap Operations Review of Heaps Min Binary
CMSC 341. Binary Heaps. Priority Queues
CMSC 341 Binary Heaps Priority Queues Priority Queues Priority: some property of an object that allows it to be prioritized with respect to other objects of the same type Min Priority Queue: homogeneous
CSE 5311 Notes 4a: Priority Queues
Chart on p., CLRS (binary, Fibonacci heaps) CSE Notes a: Priority Queues (Last updated 9// : AM) MAKE-HEAP INSERT MINIMUM EXTRACT-MIN UNION (MELD/MERGE) DECREASE-KEY DELETE Applications - sorting (?),
CS 315 April 1. Goals: Heap (Chapter 6) continued review of Algorithms for Insert DeleteMin. algoritms for decrasekey increasekey Build-heap
CS 315 April 1 Goals: Heap (Chapter 6) continued review of Algorithms for Insert DeleteMin percolate-down algoritms for decrasekey increasekey Build-heap heap-sorting, machine scheduling application Binary
Sorting and Searching
Sorting and Searching Lecture 2: Priority Queues, Heaps, and Heapsort Lecture 2: Priority Queues, Heaps, and Heapsort Sorting and Searching 1 / 24 Priority Queue: Motivating Example 3 jobs have been submitted
Binary Heaps. CSE 373 Data Structures Lecture 11
Binary Heaps CSE Data Structures Lecture Readings and References Reading Sections.1-. //0 Binary Heaps - Lecture A New Problem Application: Find the smallest ( or highest priority) item quickly Operating
9. Heap : Priority Queue
9. Heap : Priority Queue Where We Are? Array Linked list Stack Queue Tree Binary Tree Heap Binary Search Tree Priority Queue Queue Queue operation is based on the order of arrivals of elements FIFO(First-In
Lecture 6: Analysis of Algorithms (CS )
Lecture 6: Analysis of Algorithms (CS583-002) Amarda Shehu October 08, 2014 1 Outline of Today s Class 2 Traversals Querying Insertion and Deletion Sorting with BSTs 3 Red-black Trees Height of a Red-black
Advanced algorithms. binary heap, d-ary heap, binomial heap, amortized analysis, Fibonacci heap. Jiří Vyskočil, Radek Mařík 2013
binary heap, d-ary heap, binomial heap, amortized analysis, Fibonacci heap Jiří Vyskočil, Radek Mařík 2013 heap Heaps [haldy] a heap is a specialized data structure (usually tree-based) that satisfies
Sorting and Searching
Sorting and Searching Lecture 2: Priority Queues, Heaps, and Heapsort Lecture 2: Priority Queues, Heaps, and Heapsort Sorting and Searching 1 / 24 Priority Queue: Motivating Example 3 jobs have been submitted
CMSC 341 Lecture 14: Priority Queues, Heaps
CMSC 341 Lecture 14: Priority Queues, Heaps Prof. John Park Based on slides from previous iterations of this course Today s Topics Priority Queues Abstract Data Type Implementations of Priority Queues:
l Heaps very popular abstract data structure, where each object has a key value (the priority), and the operations are:
DDS-Heaps 1 Heaps - basics l Heaps very popular abstract data structure, where each object has a key value (the priority), and the operations are: l insert an object, find the object of minimum key (find
Algorithms and Data Structures
Algorithms and Data Structures Dr. Malek Mouhoub Department of Computer Science University of Regina Fall 2002 Malek Mouhoub, CS3620 Fall 2002 1 6. Priority Queues 6. Priority Queues ffl ADT Stack : LIFO.
l So unlike the search trees, there are neither arbitrary find operations nor arbitrary delete operations possible.
DDS-Heaps 1 Heaps - basics l Heaps an abstract structure where each object has a key value (the priority), and the operations are: insert an object, find the object of minimum key (find min), and delete
Priority Queues and Binary Heaps
Yufei Tao ITEE University of Queensland In this lecture, we will learn our first tree data structure called the binary heap which serves as an implementation of the priority queue. Priority Queue A priority
Data Structures Week #6. Special Trees
Data Structures Week #6 Special Trees Outline Adelson-Velskii-Landis (AVL) Trees Splay Trees B-Trees October 5, 2015 Borahan Tümer, Ph.D. 2 AVL Trees October 5, 2015 Borahan Tümer, Ph.D. 3 Motivation for
Heaps, Heap Sort, and Priority Queues.
Heaps, Heap Sort, and Priority Queues Sorting III / Slide 2 Background: Binary Trees Has a root at the topmost level Each node has zero, one or two children A node that has no child is called a leaf For
Heaps Outline and Required Reading: Heaps ( 7.3) COSC 2011, Fall 2003, Section A Instructor: N. Vlajic
1 Heaps Outline and Required Reading: Heaps (.3) COSC 2011, Fall 2003, Section A Instructor: N. Vlajic Heap ADT 2 Heap binary tree (T) that stores a collection of keys at its internal nodes and satisfies
Priority Queues. e.g. jobs sent to a printer, Operating system job scheduler in a multi-user environment. Simulation environments
Heaps 1 Priority Queues Many applications require that we process records with keys in order, but not necessarily in full sorted order. Often we collect a set of items and process the one with the current
Data Structures Lesson 9
Data Structures Lesson 9 BSc in Computer Science University of New York, Tirana Assoc. Prof. Marenglen Biba 1-1 Chapter 21 A Priority Queue: The Binary Heap Priority Queue The priority queue is a fundamental
! Tree: set of nodes and directed edges. ! Parent: source node of directed edge. ! Child: terminal node of directed edge
Trees (& Heaps) Week 12 Gaddis: 20 Weiss: 21.1-3 CS 5301 Spring 2015 Jill Seaman 1 Tree: non-recursive definition! Tree: set of nodes and directed edges - root: one node is distinguished as the root -
CMSC 341 Priority Queues & Heaps. Based on slides from previous iterations of this course
CMSC 341 Priority Queues & Heaps Based on slides from previous iterations of this course Today s Topics Priority Queues Abstract Data Type Implementations of Priority Queues: Lists BSTs Heaps Heaps Properties
Binary Heaps. COL 106 Shweta Agrawal and Amit Kumar
Binary Heaps COL Shweta Agrawal and Amit Kumar Revisiting FindMin Application: Find the smallest ( or highest priority) item quickly Operating system needs to schedule jobs according to priority instead
Data Structures Week #6. Special Trees
Data Structures Week #6 Special Trees Outline Adelson-Velskii-Landis (AVL) Trees Splay Trees B-Trees October 5, 2018 Borahan Tümer, Ph.D. 2 AVL Trees October 5, 2018 Borahan Tümer, Ph.D. 3 Motivation for
Chapter 6 Heapsort 1
Chapter 6 Heapsort 1 Introduce Heap About this lecture Shape Property and Heap Property Heap Operations Heapsort: Use Heap to Sort Fixing heap property for all nodes Use Array to represent Heap Introduce
Topic: Heaps and priority queues
David Keil Data Structures 8/05 1 Topic: Heaps and priority queues The priority-queue problem The heap solution Binary trees and complete binary trees Running time of heap operations Array implementation
Recall: Properties of B-Trees
CSE 326 Lecture 10: B-Trees and Heaps It s lunch time what s cookin? B-Trees Insert/Delete Examples and Run Time Analysis Summary of Search Trees Introduction to Heaps and Priority Queues Covered in Chapters
CSE 214 Computer Science II Heaps and Priority Queues
CSE 214 Computer Science II Heaps and Priority Queues Spring 2018 Stony Brook University Instructor: Shebuti Rayana shebuti.rayana@stonybrook.edu http://www3.cs.stonybrook.edu/~cse214/sec02/ Introduction
UNIT III BALANCED SEARCH TREES AND INDEXING
UNIT III BALANCED SEARCH TREES AND INDEXING OBJECTIVE The implementation of hash tables is frequently called hashing. Hashing is a technique used for performing insertions, deletions and finds in constant
Binary heaps (chapters ) Leftist heaps
Binary heaps (chapters 20.3 20.5) Leftist heaps Binary heaps are arrays! A binary heap is really implemented using an array! 8 18 29 20 28 39 66 Possible because of completeness property 37 26 76 32 74
Tree: non-recursive definition. Trees, Binary Search Trees, and Heaps. Tree: recursive definition. Tree: example.
Trees, Binary Search Trees, and Heaps CS 5301 Fall 2013 Jill Seaman Tree: non-recursive definition Tree: set of nodes and directed edges - root: one node is distinguished as the root - Every node (except
Priority Queues. Lecture15: Heaps. Priority Queue ADT. Sequence based Priority Queue
Priority Queues (0F) Lecture: Heaps Bohyung Han CSE, POSTECH bhhan@postech.ac.kr Queues Stores items (keys) in a linear list or array FIFO (First In First Out) Stored items do not have priorities. Priority
Priority Queues Heaps Heapsort
Priority Queues Heaps Heapsort After this lesson, you should be able to apply the binary heap insertion and deletion algorithms by hand implement the binary heap insertion and deletion algorithms explain
Data Structures Week #6. Special Trees
Data Structures Week #6 Special Trees Outline Adelson-Velskii-Landis (AVL) Trees Splay Trees B-Trees 21.Aralık.2010 Borahan Tümer, Ph.D. 2 AVL Trees 21.Aralık.2010 Borahan Tümer, Ph.D. 3 Motivation for
! Tree: set of nodes and directed edges. ! Parent: source node of directed edge. ! Child: terminal node of directed edge
Trees & Heaps Week 12 Gaddis: 20 Weiss: 21.1-3 CS 5301 Fall 2018 Jill Seaman!1 Tree: non-recursive definition! Tree: set of nodes and directed edges - root: one node is distinguished as the root - Every
INF2220: algorithms and data structures Series 4
Universitetet i Oslo Institutt for Informatikk A. Maus, R.K. Runde, I. Yu INF2220: algorithms and data structures Series 4 Topic Priority Queues and Heaps (Exercises with hints for solution) Issued: 4.
CSE 326: Data Structures Lecture #4 Heaps more Priority Qs. Today s Outline
CSE : Data Structures Lecture # Heaps more Priority Qs Bart Niswonger Summer Quarter Today s Outline Return quizzes Things Bart Didn t Finish on Friday (insert & d-heaps) Leftist Heaps Skew Heaps Comparing
Priority Queues. 1 Introduction. 2 Naïve Implementations. CSci 335 Software Design and Analysis III Chapter 6 Priority Queues. Prof.
Priority Queues 1 Introduction Many applications require a special type of queuing in which items are pushed onto the queue by order of arrival, but removed from the queue based on some other priority
Programming II (CS300)
1 Programming II (CS300) Chapter 10: Search and Heaps MOUNA KACEM mouna@cs.wisc.edu Spring 2018 Search and Heaps 2 Linear Search Binary Search Introduction to trees Priority Queues Heaps Linear Search
Lecture Notes for Advanced Algorithms
Lecture Notes for Advanced Algorithms Prof. Bernard Moret September 29, 2011 Notes prepared by Blanc, Eberle, and Jonnalagedda. 1 Average Case Analysis 1.1 Reminders on quicksort and tree sort We start
Priority Queues Heaps Heapsort
Priority Queues Heaps Heapsort Complete the Doublets partner(s) evaluation by tonight. Use your individual log to give them useful feedback! Like 230 and have workstudy funding? We are looking for CSSE230
CS2223: Algorithms Sorting Algorithms, Heap Sort, Linear-time sort, Median and Order Statistics
CS2223: Algorithms Sorting Algorithms, Heap Sort, Linear-time sort, Median and Order Statistics 1 Sorting 1.1 Problem Statement You are given a sequence of n numbers < a 1, a 2,..., a n >. You need to
CSE 373 Autumn 2010: Midterm #2 (closed book, closed notes, NO calculators allowed)
Name: Email address: CSE 373 Autumn 2010: Midterm #2 (closed book, closed notes, NO calculators allowed) Instructions: Read the directions for each question carefully before answering. We may give partial
CSE373: Data Structures & Algorithms Lecture 9: Priority Queues and Binary Heaps. Linda Shapiro Spring 2016
CSE373: Data Structures & Algorithms Lecture : Priority Queues and Binary Heaps Linda Shapiro Spring 2016 A new ADT: Priority Queue A priority queue holds compare-able data Like dictionaries, we need to
CSCI-1200 Data Structures Fall 2018 Lecture 23 Priority Queues II
Review from Lecture 22 CSCI-1200 Data Structures Fall 2018 Lecture 23 Priority Queues II Using STL s for_each, Function Objects, a.k.a., Functors STL s unordered_set (and unordered_map) Hash functions
COMP : Trees. COMP20012 Trees 219
COMP20012 3: Trees COMP20012 Trees 219 Trees Seen lots of examples. Parse Trees Decision Trees Search Trees Family Trees Hierarchical Structures Management Directories COMP20012 Trees 220 Trees have natural
Trees. A tree is a directed graph with the property
2: Trees Trees A tree is a directed graph with the property There is one node (the root) from which all other nodes can be reached by exactly one path. Seen lots of examples. Parse Trees Decision Trees
Heaps. 2/13/2006 Heaps 1
Heaps /13/00 Heaps 1 Outline and Reading What is a heap ( 8.3.1) Height of a heap ( 8.3.) Insertion ( 8.3.3) Removal ( 8.3.3) Heap-sort ( 8.3.) Arraylist-based implementation ( 8.3.) Bottom-up construction
CSE373: Data Structures & Algorithms Lecture 9: Priority Queues and Binary Heaps. Nicki Dell Spring 2014
CSE: Data Structures & Algorithms Lecture : Priority Queues and Binary Heaps Nicki Dell Spring 01 Priority Queue ADT A priority queue holds compare-able items Each item in the priority queue has a priority
CSE373: Data Structures & Algorithms Lecture 9: Priority Queues. Aaron Bauer Winter 2014
CSE373: Data Structures & Algorithms Lecture 9: Priority Queues Aaron Bauer Winter 2014 Midterm On Wednesday, in class Closed book Closed note Closed electronic devices Closed classmate Covers everything
CS165: Priority Queues, Heaps
CS1: Priority Queues, Heaps Prichard Ch. 12 Priority Queues Characteristics Items are associated with a Comparable value: priority Provide access to one element at a time - the one with the highest priority
CSE 332: Data Structures & Parallelism Lecture 3: Priority Queues. Ruth Anderson Winter 2019
CSE 332: Data Structures & Parallelism Lecture 3: Priority Queues Ruth Anderson Winter 201 Today Finish up Intro to Asymptotic Analysis New ADT! Priority Queues 1/11/201 2 Scenario What is the difference
CS 234. Module 8. November 15, CS 234 Module 8 ADT Priority Queue 1 / 22
CS 234 Module 8 November 15, 2018 CS 234 Module 8 ADT Priority Queue 1 / 22 ADT Priority Queue Data: (key, element pairs) where keys are orderable but not necessarily distinct, and elements are any data.
Multi-Way Search Trees
Multi-Way Search Trees Manolis Koubarakis 1 Multi-Way Search Trees Multi-way trees are trees such that each internal node can have many children. Let us assume that the entries we store in a search tree
Administration CSE 326: Data Structures
Administration SE : Data Structures Priority Queues and inary Heaps Due tonight: Project Released today: Project, phase A Due Wednesday: Homework Released Wednesday: Homework ary has office hours tomorrow
Multi-Way Search Trees
Multi-Way Search Trees Manolis Koubarakis 1 Multi-Way Search Trees Multi-way trees are trees such that each internal node can have many children. Let us assume that the entries we store in a search tree
Lecture: Analysis of Algorithms (CS )
Lecture: Analysis of Algorithms (CS583-002) Amarda Shehu Fall 2017 1 Binary Search Trees Traversals, Querying, Insertion, and Deletion Sorting with BSTs 2 Example: Red-black Trees Height of a Red-black
University of Illinois at Urbana-Champaign Department of Computer Science. Second Examination
University of Illinois at Urbana-Champaign Department of Computer Science Second Examination CS 225 Data Structures and Software Principles Sample Exam 1 75 minutes permitted Print your name, netid, and
Advanced Algorithms. Class Notes for Thursday, September 18, 2014 Bernard Moret
Advanced Algorithms Class Notes for Thursday, September 18, 2014 Bernard Moret 1 Amortized Analysis (cont d) 1.1 Side note: regarding meldable heaps When we saw how to meld two leftist trees, we did not
Priority Queues. 04/10/03 Lecture 22 1
Priority Queues It is a variant of queues Each item has an associated priority value. When inserting an item in the queue, the priority value is also provided for it. The data structure provides a method
COSC160: Data Structures Heaps. Jeremy Bolton, PhD Assistant Teaching Professor
COSC160: Data Structures Heaps Jeremy Bolton, PhD Assistant Teaching Professor Outline I. Priority Queue II. Heaps I. Binary Heaps II. Skew Heaps Balancing a Tree Binary trees lack a depth constraint.
Data Structures. Giri Narasimhan Office: ECS 254A Phone: x-3748
Data Structures Giri Narasimhan Office: ECS 254A Phone: x-3748 giri@cs.fiu.edu Motivation u Many applications where Items have associated priorities Job scheduling Long print jobs vs short ones; OS jobs
CS711008Z Algorithm Design and Analysis
CS711008Z Algorithm Design and Analysis Lecture 7. Binary heap, binomial heap, and Fibonacci heap Dongbo Bu Institute of Computing Technology Chinese Academy of Sciences, Beijing, China 1 / 108 Outline
Data Structures and Algorithms
Data Structures and Algorithms CS245-2015S-08 Priority Queues Heaps David Galles Department of Computer Science University of San Francisco 08-0: Priority Queue ADT Operations Add an element / key pair
Section 4 SOLUTION: AVL Trees & B-Trees
Section 4 SOLUTION: AVL Trees & B-Trees 1. What 3 properties must an AVL tree have? a. Be a binary tree b. Have Binary Search Tree ordering property (left children < parent, right children > parent) c.
Design and Analysis of Algorithms
CSE 1, Winter 201 Design and Analysis of Algorithms Lecture 7: Bellman-Ford, SPs in DAGs, PQs Class URL: http://vlsicad.ucsd.edu/courses/cse1-w1/ Lec. Added after class Figure.: Single-Edge Extensions
Data Structures Question Bank Multiple Choice
Section 1. Fundamentals: Complexity, Algorthm Analysis 1. An algorithm solves A single problem or function Multiple problems or functions Has a single programming language implementation 2. A solution
Figure 1: A complete binary tree.
The Binary Heap A binary heap is a data structure that implements the abstract data type priority queue. That is, a binary heap stores a set of elements with a total order (that means that every two elements
Priority Queues. Meld(Q 1,Q 2 ) merge two sets
Priority Queues MakeQueue Insert(Q,k,p) Delete(Q,k) DeleteMin(Q) Meld(Q 1,Q 2 ) Empty(Q) Size(Q) FindMin(Q) create new empty queue insert key k with priority p delete key k (given a pointer) delete key
/633 Introduction to Algorithms Lecturer: Michael Dinitz Topic: Priority Queues / Heaps Date: 9/27/17
01.433/33 Introduction to Algorithms Lecturer: Michael Dinitz Topic: Priority Queues / Heaps Date: 9/2/1.1 Introduction In this lecture we ll talk about a useful abstraction, priority queues, which are
Programming II (CS300)
1 Programming II (CS300) Chapter 12: Heaps and Priority Queues MOUNA KACEM mouna@cs.wisc.edu Fall 2018 Heaps and Priority Queues 2 Priority Queues Heaps Priority Queue 3 QueueADT Objects are added and
Arrays aren t going to work. What can we do? Use pointers Copy a large section of a heap, with a single pointer assignment
CS5-008S-0 Leftist Heaps 0-0: Leftist Heaps Operations: Add an element Remove smallest element Merge two heaps together 0-: Leftist Heaps Operations: Add an element Remove smallest element Merge two heaps
Binary Trees. Directed, Rooted Tree. Terminology. Trees. Binary Trees. Possible Implementation 4/18/2013
Directed, Rooted Tree Binary Trees Chapter 5 CPTR 318 Every non-empty directed, rooted tree has A unique element called root One or more elements called leaves Every element except root has a unique parent
Week 10. Sorting. 1 Binary heaps. 2 Heapification. 3 Building a heap 4 HEAP-SORT. 5 Priority queues 6 QUICK-SORT. 7 Analysing QUICK-SORT.
Week 10 1 Binary s 2 3 4 5 6 Sorting Binary s 7 8 General remarks Binary s We return to sorting, considering and. Reading from CLRS for week 7 1 Chapter 6, Sections 6.1-6.5. 2 Chapter 7, Sections 7.1,
CSE 373 Sample Midterm #2 (closed book, closed notes, calculators o.k.)
Name: Email address: CSE 373 Sample Midterm #2 (closed book, closed notes, calculators o.k.) Instructions Read the directions for each question carefully before answering. We will give partial credit based
Algorithms. AVL Tree
Algorithms AVL Tree Balanced binary tree The disadvantage of a binary search tree is that its height can be as large as N-1 This means that the time needed to perform insertion and deletion and many other
CS S-08 Priority Queues Heaps 1
CS245-2015S-08 Priority Queues Heaps 1 08-0: Priority Queue ADT Keys are priorities, with smaller keys having a better priority 08-1: Priority Queue ADT Sorted Array Add Element Remove Smallest Key 08-2:
Figure 1: A complete binary tree.
The Binary Heap A binary heap is a data structure that implements the abstract data type priority queue. That is, a binary heap stores a set of elements with a total order (that means that every two elements
CS711008Z Algorithm Design and Analysis
CS700Z Algorithm Design and Analysis Lecture 7 Binary heap, binomial heap, and Fibonacci heap Dongbo Bu Institute of Computing Technology Chinese Academy of Sciences, Beijing, China 1 / Outline Introduction
HEAPS: IMPLEMENTING EFFICIENT PRIORITY QUEUES
HEAPS: IMPLEMENTING EFFICIENT PRIORITY QUEUES 2 5 6 9 7 Presentation for use with the textbook Data Structures and Algorithms in Java, 6 th edition, by M. T. Goodrich, R. Tamassia, and M. H., Wiley, 2014
Today s Outline. The One Page Cheat Sheet. Simplifying Recurrences. Set Notation. Set Notation. Priority Queues. O( 2 n ) O( n 3 )
Priority Queues (Today: inary Min Heaps) hapter in Weiss SE Data Structures Ruth Anderson Winter 0 //0 Today s Outline Announcements Project #, due pm Wed Jan. Written Assignment # posted, due at the beginning
Heaps in C. CHAN Hou Pong, Ken CSCI2100 Data Structures Tutorial 7
Heaps in C CHAN Hou Pong, Ken CSCI2100 Data Structures Tutorial 7 Review on Heaps A heap is implemented as a binary tree It satisfies two properties: MinHeap: parent = child]
Priority Queues and Binary Heaps. See Chapter 21 of the text, pages
Priority Queues and Binary Heaps See Chapter 21 of the text, pages 807-839. A priority queue is a queue-like data structure that assumes data is comparable in some way (or at least has some field on which
CS102 Binary Search Trees
CS102 Binary Search Trees Prof Tejada 1 To speed up insertion, removal and search, modify the idea of a Binary Tree to create a Binary Search Tree (BST) Binary Search Trees Binary Search Trees have one
Adam Blank Lecture 3 Winter 2017 CSE 332. Data Structures and Parallelism
Adam Blank Lecture Winter 2017 CSE 2 Data Structures and Parallelism CSE 2: Data Structures and Parallelism Heaps Outline 1 Reviewing Heap Representation 2 Heap Operations, Again buildheap A New Data Structure:
Priority queues. Priority queues. Priority queue operations
Priority queues March 30, 018 1 Priority queues The ADT priority queue stores arbitrary objects with priorities. An object with the highest priority gets served first. Objects with priorities are defined