![Page 1: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/1.jpg)
8 Priority Queues
A Priority Queue S is a dynamic set data structure that supports
the following operations:
ñ S. build(x1, . . . , xn): Creates a data-structure that contains
just the elements x1, . . . , xn.
ñ S. insert(x): Adds element x to the data-structure.
ñ element S.minimum(): Returns an element x ∈ S with
minimum key-value key[x].ñ element S. delete-min(): Deletes the element with
minimum key-value from S and returns it.
ñ boolean S. is-empty(): Returns true if the data-structure is
empty and false otherwise.
Sometimes we also have
ñ S.merge(S′): S := S ∪ S′; S′ := �.
Ernst Mayr, Harald Räcke 305/432
![Page 2: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/2.jpg)
8 Priority Queues
A Priority Queue S is a dynamic set data structure that supports
the following operations:
ñ S. build(x1, . . . , xn): Creates a data-structure that contains
just the elements x1, . . . , xn.
ñ S. insert(x): Adds element x to the data-structure.
ñ element S.minimum(): Returns an element x ∈ S with
minimum key-value key[x].ñ element S. delete-min(): Deletes the element with
minimum key-value from S and returns it.
ñ boolean S. is-empty(): Returns true if the data-structure is
empty and false otherwise.
Sometimes we also have
ñ S.merge(S′): S := S ∪ S′; S′ := �.8 Priority Queues
Ernst Mayr, Harald Räcke 305/432
![Page 3: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/3.jpg)
8 Priority Queues
A Priority Queue S is a dynamic set data structure that supports
the following operations:
ñ S. build(x1, . . . , xn): Creates a data-structure that contains
just the elements x1, . . . , xn.
ñ S. insert(x): Adds element x to the data-structure.
ñ element S.minimum(): Returns an element x ∈ S with
minimum key-value key[x].ñ element S. delete-min(): Deletes the element with
minimum key-value from S and returns it.
ñ boolean S. is-empty(): Returns true if the data-structure is
empty and false otherwise.
Sometimes we also have
ñ S.merge(S′): S := S ∪ S′; S′ := �.8 Priority Queues
Ernst Mayr, Harald Räcke 305/432
![Page 4: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/4.jpg)
8 Priority Queues
A Priority Queue S is a dynamic set data structure that supports
the following operations:
ñ S. build(x1, . . . , xn): Creates a data-structure that contains
just the elements x1, . . . , xn.
ñ S. insert(x): Adds element x to the data-structure.
ñ element S.minimum(): Returns an element x ∈ S with
minimum key-value key[x].ñ element S. delete-min(): Deletes the element with
minimum key-value from S and returns it.
ñ boolean S. is-empty(): Returns true if the data-structure is
empty and false otherwise.
Sometimes we also have
ñ S.merge(S′): S := S ∪ S′; S′ := �.8 Priority Queues
Ernst Mayr, Harald Räcke 305/432
![Page 5: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/5.jpg)
8 Priority Queues
A Priority Queue S is a dynamic set data structure that supports
the following operations:
ñ S. build(x1, . . . , xn): Creates a data-structure that contains
just the elements x1, . . . , xn.
ñ S. insert(x): Adds element x to the data-structure.
ñ element S.minimum(): Returns an element x ∈ S with
minimum key-value key[x].ñ element S. delete-min(): Deletes the element with
minimum key-value from S and returns it.
ñ boolean S. is-empty(): Returns true if the data-structure is
empty and false otherwise.
Sometimes we also have
ñ S.merge(S′): S := S ∪ S′; S′ := �.8 Priority Queues
Ernst Mayr, Harald Räcke 305/432
![Page 6: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/6.jpg)
8 Priority Queues
A Priority Queue S is a dynamic set data structure that supports
the following operations:
ñ S. build(x1, . . . , xn): Creates a data-structure that contains
just the elements x1, . . . , xn.
ñ S. insert(x): Adds element x to the data-structure.
ñ element S.minimum(): Returns an element x ∈ S with
minimum key-value key[x].ñ element S. delete-min(): Deletes the element with
minimum key-value from S and returns it.
ñ boolean S. is-empty(): Returns true if the data-structure is
empty and false otherwise.
Sometimes we also have
ñ S.merge(S′): S := S ∪ S′; S′ := �.8 Priority Queues
Ernst Mayr, Harald Räcke 305/432
![Page 7: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/7.jpg)
8 Priority Queues
A Priority Queue S is a dynamic set data structure that supports
the following operations:
ñ S. build(x1, . . . , xn): Creates a data-structure that contains
just the elements x1, . . . , xn.
ñ S. insert(x): Adds element x to the data-structure.
ñ element S.minimum(): Returns an element x ∈ S with
minimum key-value key[x].ñ element S. delete-min(): Deletes the element with
minimum key-value from S and returns it.
ñ boolean S. is-empty(): Returns true if the data-structure is
empty and false otherwise.
Sometimes we also have
ñ S.merge(S′): S := S ∪ S′; S′ := �.8 Priority Queues
Ernst Mayr, Harald Räcke 305/432
![Page 8: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/8.jpg)
8 Priority Queues
An addressable Priority Queue also supports:
ñ handle S. insert(x): Adds element x to the data-structure,
and returns a handle to the object for future reference.
ñ S. delete(h): Deletes element specified through handle h.
ñ S. decrease-key(h, k): Decreases the key of the element
specified by handle h to k. Assumes that the key is at least
k before the operation.
8 Priority Queues
Ernst Mayr, Harald Räcke 306/432
![Page 9: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/9.jpg)
8 Priority Queues
An addressable Priority Queue also supports:
ñ handle S. insert(x): Adds element x to the data-structure,
and returns a handle to the object for future reference.
ñ S. delete(h): Deletes element specified through handle h.
ñ S. decrease-key(h, k): Decreases the key of the element
specified by handle h to k. Assumes that the key is at least
k before the operation.
8 Priority Queues
Ernst Mayr, Harald Räcke 306/432
![Page 10: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/10.jpg)
8 Priority Queues
An addressable Priority Queue also supports:
ñ handle S. insert(x): Adds element x to the data-structure,
and returns a handle to the object for future reference.
ñ S. delete(h): Deletes element specified through handle h.
ñ S. decrease-key(h, k): Decreases the key of the element
specified by handle h to k. Assumes that the key is at least
k before the operation.
8 Priority Queues
Ernst Mayr, Harald Räcke 306/432
![Page 11: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/11.jpg)
8 Priority Queues
An addressable Priority Queue also supports:
ñ handle S. insert(x): Adds element x to the data-structure,
and returns a handle to the object for future reference.
ñ S. delete(h): Deletes element specified through handle h.
ñ S. decrease-key(h, k): Decreases the key of the element
specified by handle h to k. Assumes that the key is at least
k before the operation.
8 Priority Queues
Ernst Mayr, Harald Räcke 306/432
![Page 12: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/12.jpg)
Dijkstra’s Shortest Path Algorithm
Algorithm 14 Shortest-Path(G = (V , E,d), s ∈ V)1: Input: weighted graph G = (V , E,d); start vertex s;2: Output: key-field of every node contains distance from s;3: S.build(); // build empty priority queue4: for all v ∈ V \ {s} do5: v.key←∞;6: hv ← S.insert(v);7: s.key← 0; S.insert(s);8: while S.is-empty() = false do9: v ← S.delete-min();
10: for all x ∈ V s.t. (v,x) ∈ E do11: if x.key > v.key+d(v,x) then12: S.decrease-key(hx,v.key+d(v,x));13: x.key← v.key+d(v,x);
8 Priority Queues
Ernst Mayr, Harald Räcke 307/432
![Page 13: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/13.jpg)
Prim’s Minimum Spanning Tree Algorithm
Algorithm 15 Prim-MST(G = (V , E,d), s ∈ V)1: Input: weighted graph G = (V , E,d); start vertex s;2: Output: pred-fields encode MST;3: S.build(); // build empty priority queue4: for all v ∈ V \ {s} do5: v.key←∞;6: hv ← S.insert(v);7: s.key← 0; S.insert(s);8: while S.is-empty() = false do9: v ← S.delete-min();
10: for all x ∈ V s.t. {v,x} ∈ E do11: if x.key > d(v,x) then12: S.decrease-key(hx,d(v,x));13: x.key← d(v,x);14: x.pred← v;
8 Priority Queues
Ernst Mayr, Harald Räcke 308/432
![Page 14: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/14.jpg)
Analysis of Dijkstra and Prim
Both algorithms require:
ñ 1 build() operation
ñ |V | insert() operations
ñ |V | delete-min() operations
ñ |V | is-empty() operations
ñ |E| decrease-key() operations
How good a running time can we obtain?
8 Priority Queues
Ernst Mayr, Harald Räcke 309/432
![Page 15: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/15.jpg)
Analysis of Dijkstra and Prim
Both algorithms require:
ñ 1 build() operation
ñ |V | insert() operations
ñ |V | delete-min() operations
ñ |V | is-empty() operations
ñ |E| decrease-key() operations
How good a running time can we obtain?
8 Priority Queues
Ernst Mayr, Harald Räcke 309/432
![Page 16: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/16.jpg)
8 Priority Queues
OperationBinaryHeap
BSTBinomial
HeapFibonacci
Heap*
build n n logn n logn nminimum 1 logn logn 1is-empty 1 1 1 1
insert logn logn logn 1
delete logn** logn logn logndelete-min logn logn logn logndecrease-key logn logn logn 1
merge n n logn logn 1
Note that most applications use build() only to create an empty heapwhich then costs time 1.
The standard version of binary heaps is not addressable, and hencedoes not support a delete operation.
Fibonacci heaps only give an amortized guarantee.
![Page 17: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/17.jpg)
8 Priority Queues
OperationBinaryHeap
BSTBinomial
HeapFibonacci
Heap*
build n n logn n logn nminimum 1 logn logn 1is-empty 1 1 1 1
insert logn logn logn 1
delete logn** logn logn logndelete-min logn logn logn logndecrease-key logn logn logn 1
merge n n logn logn 1
Note that most applications use build() only to create an empty heapwhich then costs time 1.
The standard version of binary heaps is not addressable, and hencedoes not support a delete operation.
Fibonacci heaps only give an amortized guarantee.
![Page 18: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/18.jpg)
8 Priority Queues
OperationBinaryHeap
BSTBinomial
HeapFibonacci
Heap*
build n n logn n logn nminimum 1 logn logn 1is-empty 1 1 1 1
insert logn logn logn 1
delete logn** logn logn logndelete-min logn logn logn logndecrease-key logn logn logn 1
merge n n logn logn 1
Note that most applications use build() only to create an empty heapwhich then costs time 1.
The standard version of binary heaps is not addressable, and hencedoes not support a delete operation.
Fibonacci heaps only give an amortized guarantee.
![Page 19: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/19.jpg)
8 Priority Queues
OperationBinaryHeap
BSTBinomial
HeapFibonacci
Heap*
build n n logn n logn nminimum 1 logn logn 1is-empty 1 1 1 1
insert logn logn logn 1
delete logn** logn logn logndelete-min logn logn logn logndecrease-key logn logn logn 1
merge n n logn logn 1
Note that most applications use build() only to create an empty heapwhich then costs time 1.
The standard version of binary heaps is not addressable, and hencedoes not support a delete operation.
Fibonacci heaps only give an amortized guarantee.
![Page 20: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/20.jpg)
8 Priority Queues
Using Binary Heaps, Prim and Dijkstra run in time
O((|V | + |E|) log |V |).
Using Fibonacci Heaps, Prim and Dijkstra run in time
O(|V | log |V | + |E|).
8 Priority Queues
Ernst Mayr, Harald Räcke 311/432
![Page 21: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/21.jpg)
8.1 Binary Heaps
ñ Nearly complete binary tree; only the last level is not full,
and this one is filled from left to right.
ñ Heap property: A node’s key is not larger than the key of
one of its children.
7
159
19311117
13 1225 43 80
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 312/432
![Page 22: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/22.jpg)
8.1 Binary Heaps
ñ Nearly complete binary tree; only the last level is not full,
and this one is filled from left to right.
ñ Heap property: A node’s key is not larger than the key of
one of its children.
7
159
19311117
13 1225 43 80
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 312/432
![Page 23: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/23.jpg)
8.1 Binary Heaps
ñ Nearly complete binary tree; only the last level is not full,
and this one is filled from left to right.
ñ Heap property: A node’s key is not larger than the key of
one of its children.
7
159
19311117
13 1225 43 80
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 312/432
![Page 24: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/24.jpg)
Binary Heaps
Operations:
ñ minimum(): return the root-element. Time O(1).ñ is-empty(): check whether root-pointer is null. Time O(1).
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 313/432
![Page 25: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/25.jpg)
Binary Heaps
Operations:
ñ minimum(): return the root-element. Time O(1).ñ is-empty(): check whether root-pointer is null. Time O(1).
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 313/432
![Page 26: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/26.jpg)
Binary Heaps
Operations:
ñ minimum(): return the root-element. Time O(1).ñ is-empty(): check whether root-pointer is null. Time O(1).
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 313/432
![Page 27: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/27.jpg)
8.1 Binary HeapsMaintain a pointer to the last element x.
ñ We can compute the predecessor of x(last element when x is deleted) in time O(logn).
go up until the last edge used was a right edge.
go left; go right until you reach a leaf
if you hit the root on the way up, go to the rightmost
element
7
159
19311117
13 1225 43 80 x
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 314/432
![Page 28: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/28.jpg)
8.1 Binary HeapsMaintain a pointer to the last element x.
ñ We can compute the predecessor of x(last element when x is deleted) in time O(logn).
go up until the last edge used was a right edge.
go left; go right until you reach a leaf
if you hit the root on the way up, go to the rightmost
element
7
159
19311117
13 1225 43 80 x
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 314/432
![Page 29: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/29.jpg)
8.1 Binary HeapsMaintain a pointer to the last element x.
ñ We can compute the predecessor of x(last element when x is deleted) in time O(logn).
go up until the last edge used was a right edge.
go left; go right until you reach a leaf
if you hit the root on the way up, go to the rightmost
element
7
159
19311117
13 1225 43 80 x
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 314/432
![Page 30: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/30.jpg)
8.1 Binary HeapsMaintain a pointer to the last element x.
ñ We can compute the predecessor of x(last element when x is deleted) in time O(logn).
go up until the last edge used was a right edge.
go left; go right until you reach a leaf
if you hit the root on the way up, go to the rightmost
element
7
159
19311117
13 1225 43 80 x
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 314/432
![Page 31: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/31.jpg)
8.1 Binary HeapsMaintain a pointer to the last element x.ñ We can compute the successor of x
(last element when an element is inserted) in time O(logn).
go up until the last edge used was a left edge.
go right; go left until you reach a null-pointer.
if you hit the root on the way up, go to the leftmost
element; insert a new element as a left child;
7
159
19311117
13 1225 43 80 x
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 315/432
![Page 32: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/32.jpg)
8.1 Binary HeapsMaintain a pointer to the last element x.ñ We can compute the successor of x
(last element when an element is inserted) in time O(logn).
go up until the last edge used was a left edge.
go right; go left until you reach a null-pointer.
if you hit the root on the way up, go to the leftmost
element; insert a new element as a left child;
7
159
19311117
13 1225 43 80 x
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 315/432
![Page 33: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/33.jpg)
8.1 Binary HeapsMaintain a pointer to the last element x.ñ We can compute the successor of x
(last element when an element is inserted) in time O(logn).
go up until the last edge used was a left edge.
go right; go left until you reach a null-pointer.
if you hit the root on the way up, go to the leftmost
element; insert a new element as a left child;
7
159
19311117
13 1225 43 80 x
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 315/432
![Page 34: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/34.jpg)
8.1 Binary HeapsMaintain a pointer to the last element x.ñ We can compute the successor of x
(last element when an element is inserted) in time O(logn).
go up until the last edge used was a left edge.
go right; go left until you reach a null-pointer.
if you hit the root on the way up, go to the leftmost
element; insert a new element as a left child;
7
159
19311117
13 1225 43 80 x
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 315/432
![Page 35: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/35.jpg)
Insert
1. Insert element at successor of x.
2. Exchange with parent until heap property is fulfilled.
7
159
19311117
13 1225 43 80 x1
Note that an exchange can either be done by moving the data or
by changing pointers. The latter method leads to an addressable
priority queue.
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 316/432
![Page 36: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/36.jpg)
Insert
1. Insert element at successor of x.
2. Exchange with parent until heap property is fulfilled.
7
159
19311117
13 1225 43 80 1 x14
Note that an exchange can either be done by moving the data or
by changing pointers. The latter method leads to an addressable
priority queue.
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 316/432
![Page 37: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/37.jpg)
Insert
1. Insert element at successor of x.
2. Exchange with parent until heap property is fulfilled.
7
159
19
31
1117
13 1225 43 80 1 x
14
Note that an exchange can either be done by moving the data or
by changing pointers. The latter method leads to an addressable
priority queue.
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 316/432
![Page 38: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/38.jpg)
Insert
1. Insert element at successor of x.
2. Exchange with parent until heap property is fulfilled.
7
15
9
19
31
1117
13 1225 43 80 1 x
14
Note that an exchange can either be done by moving the data or
by changing pointers. The latter method leads to an addressable
priority queue.
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 316/432
![Page 39: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/39.jpg)
Insert
1. Insert element at successor of x.
2. Exchange with parent until heap property is fulfilled.
7
15
9
19
31
1117
13 1225 43 80 1 x
14
Note that an exchange can either be done by moving the data or
by changing pointers. The latter method leads to an addressable
priority queue.
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 316/432
![Page 40: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/40.jpg)
Delete
1. Exchange the element to be deleted with the element epointed to by x.
2. Restore the heap-property for the element e.
7
916
19121718
27 2025 43 13 x1 e
At its new position e may either travel up or down in the tree
(but not both directions).
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 317/432
![Page 41: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/41.jpg)
Delete
1. Exchange the element to be deleted with the element epointed to by x.
2. Restore the heap-property for the element e.
7
916
19121718
27 2025 43 13 x1 e
At its new position e may either travel up or down in the tree
(but not both directions).
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 317/432
![Page 42: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/42.jpg)
Delete
1. Exchange the element to be deleted with the element epointed to by x.
2. Restore the heap-property for the element e.
7
916
19121718
27 2025 43 1 x
13e
At its new position e may either travel up or down in the tree
(but not both directions).
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 317/432
![Page 43: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/43.jpg)
Delete
1. Exchange the element to be deleted with the element epointed to by x.
2. Restore the heap-property for the element e.
7
9
16 191218
27 2025 43 1 x
13e
At its new position e may either travel up or down in the tree
(but not both directions).
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 317/432
![Page 44: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/44.jpg)
Delete
1. Exchange the element to be deleted with the element epointed to by x.
2. Restore the heap-property for the element e.
7
9
16 191218
27 2025 43 1 x
13e
At its new position e may either travel up or down in the tree
(but not both directions).
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 317/432
![Page 45: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/45.jpg)
Binary Heaps
Operations:
ñ minimum(): return the root-element. Time O(1).ñ is-empty(): check whether root-pointer is null. Time O(1).ñ insert(k): insert at successor of x and bubble up. Time
O(logn).ñ delete(h): swap with x and bubble up or sift-down. Time
O(logn).
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 318/432
![Page 46: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/46.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23 22 21 20 19 18 17
16 15 14 13 11 12 10 9 5 7 6 8 4 2 3 35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 47: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/47.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23 22 21 20 19 18 17
16 15 14 13 11 12 10 9 5 7 6 8 4 2 3 35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 48: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/48.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23 22 21 20 19 18
1716 15 14 13 11 12 10 9 5 7 6 8 4 2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 49: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/49.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23 22 21 20 19 18
1716 15 14 13 11 12 10 9 5 7 6 8 4 2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 50: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/50.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23 22 21 20 19
18 1716 15 14 13 11 12 10 9 5 7 6 8 4
2 3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 51: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/51.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23 22 21 20 19
18 1716 15 14 13 11 12 10 9 5 7 6 8 4
2 3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 52: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/52.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23 22 21 20
19 18 1716 15 14 13 11 12 10 9 5 7
6
8 4
2 3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 53: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/53.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23 22 21 20
19 18 1716 15 14 13 11 12 10 9 5 7
6
8 4
2 3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 54: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/54.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23 22 21
20 19 18 1716 15 14 13 11 12 10 9
5
7
6
8 4
2 3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 55: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/55.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23 22 21
20 19 18 1716 15 14 13 11 12 10 9
5
7
6
8 4
2 3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 56: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/56.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23 22
21 20 19 18 1716 15 14 13 11 12 10
9 5
7
6
8 4
2 3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 57: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/57.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23 22
21 20 19 18 1716 15 14 13 11 12 10
9 5
7
6
8 4
2 3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 58: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/58.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23
22 21 20 19 18 1716 15 14 13
11
12 10
9 5
7
6
8 4
2 3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 59: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/59.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23
22 21 20 19 18 1716 15 14 13
11
12 10
9 5
7
6
8 4
2 3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 60: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/60.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24
23 22 21 20 19 18 1716 15 14
13 11
12 10
9 5
7
6
8 4
2 3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 61: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/61.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24
23 22 21 20 19 18 1716 15 14
13 11
12 10
9 5
7
6
8 4
2 3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 62: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/62.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23 22 21 20 19 18 1716
15
14
13 11
12 10
9 5
7
6
8 4
2 3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 63: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/63.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 25
24 23 22 21 20 19 18 1716
15
14
13 11
12 10
9 5
7
6
8 4
2 3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 64: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/64.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26
25
24 23 22 21 20 19 18 1716
15
14
13 11
12 10
9 5
7
6
8 4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 65: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/65.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26
2524 23 22 21 20 19 18 1716
15
14
13 11
12 10
9 5
7
6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 66: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/66.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26
2524 23 22 21 20 19 18 1716
15
14
13 11
12 10
9 5
7
6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 67: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/67.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27
26
2524 23 22 21 20 19 18 1716
15
14
13 11
12 10
9
5
7
6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 68: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/68.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27
26 2524 23 22 21 20 19 18 1716
15
14
13 11
12 10
9
5
7 6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 69: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/69.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27
26 2524 23 22 21 20 19 18 1716
15
14
13 11
12 10
9
5
7 6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 70: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/70.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28
27
26 2524 23 22 21 20 19 18 1716
15
14
13 11
12 10
9 5
7 6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 71: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/71.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28
27 26 2524 23 22 21 20 19 18 1716
15
14
13 11
12
10
9 5
7 6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 72: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/72.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28
27 26 2524 23 22 21 20 19 18 1716
15
14
13 11
12
10
9 5
7 6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 73: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/73.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28
27 26 2524 23 22 21 20 19 18 1716
15
14
13
11
12
10
9 5
7 6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 74: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/74.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 2524 23 22 21 20 19 18 1716
15 14
13
11
12
10
9 5
7 6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 75: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/75.jpg)
Build Heap
We can build a heap in linear time:
31
30 29
28 27 26 2524 23 22 21 20 19 18 1716
15 14
13
11
12
10
9 5
7 6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 76: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/76.jpg)
Build Heap
We can build a heap in linear time:
31
30
29
28 27 26 2524 23 22 21 20 19 18 1716
15 14
13
11
12
10
9 5
7 6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 77: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/77.jpg)
Build Heap
We can build a heap in linear time:
31
30
29
28 27 26 2524 23 22 21 20 19 18 1716
15 14
13
11
12
10
9 5
7 6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 78: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/78.jpg)
Build Heap
We can build a heap in linear time:
31
30
2928 27 26 2524 23 22 21 20 19 18
17
16
15 14
13
11
12
10
9 5
7 6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 79: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/79.jpg)
Build Heap
We can build a heap in linear time:
31
30
2928 27 26 2524 23 22 21 20 19 18
17
16
15 14
13
11
12
10
9 5
7 6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 80: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/80.jpg)
Build Heap
We can build a heap in linear time:
31
30
2928 27 26 2524 23 22 21 20 19 18
17
16
15 14
13
11
12
10
9 5
7 6
8
4
2
3
35
∑
levels `
2` · (h− `) =∑
ii2h−i = O(2h) = O(n)
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 319/432
![Page 81: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/81.jpg)
Binary Heaps
Operations:
ñ minimum(): Return the root-element. Time O(1).ñ is-empty(): Check whether root-pointer is null. Time O(1).ñ insert(k): Insert at x and bubble up. Time O(logn).ñ delete(h): Swap with x and bubble up or sift-down. Time
O(logn).ñ build(x1, . . . , xn): Insert elements arbitrarily; then do
sift-down operations starting with the lowest layer in the
tree. Time O(n).
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 320/432
![Page 82: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/82.jpg)
Binary Heaps
The standard implementation of binary heaps is via arrays. Let
A[0, . . . , n− 1] be an array
ñ The parent of i-th element is at position b i−12 c.
ñ The left child of i-th element is at position 2i+ 1.
ñ The right child of i-th element is at position 2i+ 2.
Finding the successor of x is much easier than in the description
on the previous slide. Simply increase or decrease x.
The resulting binary heap is not addressable. The elements
don’t maintain their positions and therefore there are no stable
handles.
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 321/432
![Page 83: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/83.jpg)
Binary Heaps
The standard implementation of binary heaps is via arrays. Let
A[0, . . . , n− 1] be an array
ñ The parent of i-th element is at position b i−12 c.
ñ The left child of i-th element is at position 2i+ 1.
ñ The right child of i-th element is at position 2i+ 2.
Finding the successor of x is much easier than in the description
on the previous slide. Simply increase or decrease x.
The resulting binary heap is not addressable. The elements
don’t maintain their positions and therefore there are no stable
handles.
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 321/432
![Page 84: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/84.jpg)
Binary Heaps
The standard implementation of binary heaps is via arrays. Let
A[0, . . . , n− 1] be an array
ñ The parent of i-th element is at position b i−12 c.
ñ The left child of i-th element is at position 2i+ 1.
ñ The right child of i-th element is at position 2i+ 2.
Finding the successor of x is much easier than in the description
on the previous slide. Simply increase or decrease x.
The resulting binary heap is not addressable. The elements
don’t maintain their positions and therefore there are no stable
handles.
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 321/432
![Page 85: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/85.jpg)
Binary Heaps
The standard implementation of binary heaps is via arrays. Let
A[0, . . . , n− 1] be an array
ñ The parent of i-th element is at position b i−12 c.
ñ The left child of i-th element is at position 2i+ 1.
ñ The right child of i-th element is at position 2i+ 2.
Finding the successor of x is much easier than in the description
on the previous slide. Simply increase or decrease x.
The resulting binary heap is not addressable. The elements
don’t maintain their positions and therefore there are no stable
handles.
8.1 Binary Heaps
Ernst Mayr, Harald Räcke 321/432
![Page 86: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/86.jpg)
8.2 Binomial Heaps
OperationBinaryHeap
BSTBinomial
HeapFibonacci
Heap*
build n n logn n logn nminimum 1 logn logn 1is-empty 1 1 1 1
insert logn logn logn 1
delete logn** logn logn logndelete-min logn logn logn logndecrease-key logn logn logn 1
merge n n logn log n 1
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 322/432
![Page 87: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/87.jpg)
Binomial Trees
B0 B1 B2 B3 B4
Bt−1
Bt−1
Bt
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 323/432
![Page 88: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/88.jpg)
Binomial Trees
Properties of Binomial Trees
ñ Bk has 2k nodes.
ñ Bk has height k.
ñ The root of Bk has degree k.
ñ Bk has(k`
)nodes on level `.
ñ Deleting the root of Bk gives trees B0, B1, . . . , Bk−1.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 324/432
![Page 89: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/89.jpg)
Binomial Trees
Properties of Binomial Trees
ñ Bk has 2k nodes.
ñ Bk has height k.
ñ The root of Bk has degree k.
ñ Bk has(k`
)nodes on level `.
ñ Deleting the root of Bk gives trees B0, B1, . . . , Bk−1.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 324/432
![Page 90: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/90.jpg)
Binomial Trees
Properties of Binomial Trees
ñ Bk has 2k nodes.
ñ Bk has height k.
ñ The root of Bk has degree k.
ñ Bk has(k`
)nodes on level `.
ñ Deleting the root of Bk gives trees B0, B1, . . . , Bk−1.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 324/432
![Page 91: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/91.jpg)
Binomial Trees
Properties of Binomial Trees
ñ Bk has 2k nodes.
ñ Bk has height k.
ñ The root of Bk has degree k.
ñ Bk has(k`
)nodes on level `.
ñ Deleting the root of Bk gives trees B0, B1, . . . , Bk−1.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 324/432
![Page 92: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/92.jpg)
Binomial Trees
Properties of Binomial Trees
ñ Bk has 2k nodes.
ñ Bk has height k.
ñ The root of Bk has degree k.
ñ Bk has(k`
)nodes on level `.
ñ Deleting the root of Bk gives trees B0, B1, . . . , Bk−1.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 324/432
![Page 93: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/93.jpg)
Binomial Trees
B4
B3
B2
B1
B0
Deleting the root of B5 leaves sub-trees B4, B3, B2, B1, and B0.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 325/432
![Page 94: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/94.jpg)
Binomial Trees
B4
B3
B2
B1
B0
Deleting the leaf furthest from the root (in B5) leaves a path that
connects the roots of sub-trees B4, B3, B2, B1, and B0.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 326/432
![Page 95: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/95.jpg)
Binomial Trees
Bk−1
Bk
(k−1`
)
(k−1`−1
)
The number of nodes on level ` in tree Bk is therefore
(k− 1` − 1
)+(k− 1`
)=(k`
)
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 327/432
![Page 96: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/96.jpg)
Binomial Trees
0000
00010010
0011
0100
01010110
0111
1000
10011010
1011
1100
11011110
1111
The binomial tree Bk is a sub-graph of the hypercube Hk.
The parent of a node with label bn, . . . , b1, b0 is obtained by
setting the least significant 1-bit to 0.
The `-th level contains nodes that have ` 1’s in their label.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 328/432
![Page 97: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/97.jpg)
Binomial Trees
0000
00010010
0011
0100
01010110
0111
1000
10011010
1011
1100
11011110
1111
The binomial tree Bk is a sub-graph of the hypercube Hk.
The parent of a node with label bn, . . . , b1, b0 is obtained by
setting the least significant 1-bit to 0.
The `-th level contains nodes that have ` 1’s in their label.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 328/432
![Page 98: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/98.jpg)
Binomial Trees
0000
00010010
0011
0100
01010110
0111
1000
10011010
1011
1100
11011110
1111
The binomial tree Bk is a sub-graph of the hypercube Hk.
The parent of a node with label bn, . . . , b1, b0 is obtained by
setting the least significant 1-bit to 0.
The `-th level contains nodes that have ` 1’s in their label.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 328/432
![Page 99: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/99.jpg)
Binomial Trees
0000
00010010
0011
0100
01010110
0111
1000
10011010
1011
1100
11011110
1111
The binomial tree Bk is a sub-graph of the hypercube Hk.
The parent of a node with label bn, . . . , b1, b0 is obtained by
setting the least significant 1-bit to 0.
The `-th level contains nodes that have ` 1’s in their label.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 328/432
![Page 100: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/100.jpg)
8.2 Binomial Heaps
How do we implement trees with non-constant degree?
ñ The children of a node are arranged in a circular linked list.
ñ A child-pointer points to an arbitrary node within the list.
ñ A parent-pointer points to the parent node.
ñ Pointers x. left and x. right point to the left and right sibling
of x (if x does not have siblings then x. left = x. right = x).
p
x
a b c d
parent
child
rightleft
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 329/432
![Page 101: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/101.jpg)
8.2 Binomial Heaps
How do we implement trees with non-constant degree?
ñ The children of a node are arranged in a circular linked list.
ñ A child-pointer points to an arbitrary node within the list.
ñ A parent-pointer points to the parent node.
ñ Pointers x. left and x. right point to the left and right sibling
of x (if x does not have siblings then x. left = x. right = x).
p
x
a b c d
parent
child
rightleft
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 329/432
![Page 102: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/102.jpg)
8.2 Binomial Heaps
How do we implement trees with non-constant degree?
ñ The children of a node are arranged in a circular linked list.
ñ A child-pointer points to an arbitrary node within the list.
ñ A parent-pointer points to the parent node.
ñ Pointers x. left and x. right point to the left and right sibling
of x (if x does not have siblings then x. left = x. right = x).
p
x
a b c d
parent
child
rightleft
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 329/432
![Page 103: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/103.jpg)
8.2 Binomial Heaps
How do we implement trees with non-constant degree?
ñ The children of a node are arranged in a circular linked list.
ñ A child-pointer points to an arbitrary node within the list.
ñ A parent-pointer points to the parent node.
ñ Pointers x. left and x. right point to the left and right sibling
of x (if x does not have siblings then x. left = x. right = x).
p
x
a b c d
parent
child
rightleft
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 329/432
![Page 104: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/104.jpg)
8.2 Binomial Heaps
ñ Given a pointer to a node x we can splice out the sub-tree
rooted at x in constant time.
ñ We can add a child-tree T to a node x in constant time if we
are given a pointer to x and a pointer to the root of T .
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 330/432
![Page 105: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/105.jpg)
Binomial Heap
712
47
2
148
31
11
2924
70
13
3516
20
37
4239
92
In a binomial heap the keys are arranged in a collection of
binomial trees.
Every tree fulfills the heap-property
There is at most one tree for every dimension/order. For
example the above heap contains trees B0, B1, and B4.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 331/432
![Page 106: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/106.jpg)
Binomial Heap
712
47
2
148
31
11
2924
70
13
3516
20
37
4239
92
In a binomial heap the keys are arranged in a collection of
binomial trees.
Every tree fulfills the heap-property
There is at most one tree for every dimension/order. For
example the above heap contains trees B0, B1, and B4.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 331/432
![Page 107: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/107.jpg)
Binomial Heap
712
47
2
148
31
11
2924
70
13
3516
20
37
4239
92
In a binomial heap the keys are arranged in a collection of
binomial trees.
Every tree fulfills the heap-property
There is at most one tree for every dimension/order. For
example the above heap contains trees B0, B1, and B4.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 331/432
![Page 108: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/108.jpg)
Binomial Heap
712
47
2
148
31
11
2924
70
13
3516
20
37
4239
92
In a binomial heap the keys are arranged in a collection of
binomial trees.
Every tree fulfills the heap-property
There is at most one tree for every dimension/order. For
example the above heap contains trees B0, B1, and B4.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 331/432
![Page 109: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/109.jpg)
Binomial Heap: Merge
Given the number n of keys to be stored in a binomial heap we
can deduce the binomial trees that will be contained in the
collection.
Let Bk1 , Bk2 , Bk3 , ki < ki+1 denote the binomial trees in the
collection and recall that every tree may be contained at most
once.
Then n =∑i 2ki must hold. But since the ki are all distinct this
means that the ki define the non-zero bit-positions in the binary
representation of n.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 332/432
![Page 110: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/110.jpg)
Binomial Heap: Merge
Given the number n of keys to be stored in a binomial heap we
can deduce the binomial trees that will be contained in the
collection.
Let Bk1 , Bk2 , Bk3 , ki < ki+1 denote the binomial trees in the
collection and recall that every tree may be contained at most
once.
Then n =∑i 2ki must hold. But since the ki are all distinct this
means that the ki define the non-zero bit-positions in the binary
representation of n.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 332/432
![Page 111: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/111.jpg)
Binomial Heap: Merge
Given the number n of keys to be stored in a binomial heap we
can deduce the binomial trees that will be contained in the
collection.
Let Bk1 , Bk2 , Bk3 , ki < ki+1 denote the binomial trees in the
collection and recall that every tree may be contained at most
once.
Then n =∑i 2ki must hold. But since the ki are all distinct this
means that the ki define the non-zero bit-positions in the binary
representation of n.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 332/432
![Page 112: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/112.jpg)
Binomial Heap: Merge
Given the number n of keys to be stored in a binomial heap we
can deduce the binomial trees that will be contained in the
collection.
Let Bk1 , Bk2 , Bk3 , ki < ki+1 denote the binomial trees in the
collection and recall that every tree may be contained at most
once.
Then n =∑i 2ki must hold. But since the ki are all distinct this
means that the ki define the non-zero bit-positions in the binary
representation of n.
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 332/432
![Page 113: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/113.jpg)
Binomial Heap
Properties of a heap with n keys:
ñ Let n = bdbd−1, . . . , b0 denote binary representation of n.ñ The heap contains tree Bi iff bi = 1.ñ Hence, at most blognc + 1 trees.ñ The minimum must be contained in one of the roots.ñ The height of the largest tree is at most blognc.ñ The trees are stored in a single-linked list; ordered by
dimension/size.
712
47
2
148
31
11
2924
70
13
3516
20
37
4239
92
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 333/432
![Page 114: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/114.jpg)
Binomial Heap
Properties of a heap with n keys:
ñ Let n = bdbd−1, . . . , b0 denote binary representation of n.ñ The heap contains tree Bi iff bi = 1.ñ Hence, at most blognc + 1 trees.ñ The minimum must be contained in one of the roots.ñ The height of the largest tree is at most blognc.ñ The trees are stored in a single-linked list; ordered by
dimension/size.
712
47
2
148
31
11
2924
70
13
3516
20
37
4239
92
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 333/432
![Page 115: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/115.jpg)
Binomial Heap
Properties of a heap with n keys:
ñ Let n = bdbd−1, . . . , b0 denote binary representation of n.ñ The heap contains tree Bi iff bi = 1.ñ Hence, at most blognc + 1 trees.ñ The minimum must be contained in one of the roots.ñ The height of the largest tree is at most blognc.ñ The trees are stored in a single-linked list; ordered by
dimension/size.
712
47
2
148
31
11
2924
70
13
3516
20
37
4239
92
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 333/432
![Page 116: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/116.jpg)
Binomial Heap
Properties of a heap with n keys:
ñ Let n = bdbd−1, . . . , b0 denote binary representation of n.ñ The heap contains tree Bi iff bi = 1.ñ Hence, at most blognc + 1 trees.ñ The minimum must be contained in one of the roots.ñ The height of the largest tree is at most blognc.ñ The trees are stored in a single-linked list; ordered by
dimension/size.
712
47
2
148
31
11
2924
70
13
3516
20
37
4239
92
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 333/432
![Page 117: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/117.jpg)
Binomial Heap
Properties of a heap with n keys:
ñ Let n = bdbd−1, . . . , b0 denote binary representation of n.ñ The heap contains tree Bi iff bi = 1.ñ Hence, at most blognc + 1 trees.ñ The minimum must be contained in one of the roots.ñ The height of the largest tree is at most blognc.ñ The trees are stored in a single-linked list; ordered by
dimension/size.
712
47
2
148
31
11
2924
70
13
3516
20
37
4239
92
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 333/432
![Page 118: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/118.jpg)
Binomial Heap
Properties of a heap with n keys:
ñ Let n = bdbd−1, . . . , b0 denote binary representation of n.ñ The heap contains tree Bi iff bi = 1.ñ Hence, at most blognc + 1 trees.ñ The minimum must be contained in one of the roots.ñ The height of the largest tree is at most blognc.ñ The trees are stored in a single-linked list; ordered by
dimension/size.
712
47
2
148
31
11
2924
70
13
3516
20
37
4239
92
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 333/432
![Page 119: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/119.jpg)
Binomial Heap
Properties of a heap with n keys:
ñ Let n = bdbd−1, . . . , b0 denote binary representation of n.ñ The heap contains tree Bi iff bi = 1.ñ Hence, at most blognc + 1 trees.ñ The minimum must be contained in one of the roots.ñ The height of the largest tree is at most blognc.ñ The trees are stored in a single-linked list; ordered by
dimension/size.
712
47
2
148
31
11
2924
70
13
3516
20
37
4239
92
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 333/432
![Page 120: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/120.jpg)
Binomial Heap: Merge
The merge-operation is instrumental for binomial heaps.
A merge is easy if we have two heaps with different binomial
trees. We can simply merge the tree-lists.
Otherwise, we cannot do this because the merged heap is not
allowed to contain two trees of the same order.
Merging two trees of the same size: Add
the tree with larger root-value as a child to
the other tree.
For more trees the technique is analogous
to binary addition.
2
76
15
5
918
22
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 334/432
![Page 121: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/121.jpg)
Binomial Heap: Merge
The merge-operation is instrumental for binomial heaps.
A merge is easy if we have two heaps with different binomial
trees. We can simply merge the tree-lists.
Otherwise, we cannot do this because the merged heap is not
allowed to contain two trees of the same order.
Merging two trees of the same size: Add
the tree with larger root-value as a child to
the other tree.
For more trees the technique is analogous
to binary addition.
2
76
15
5
918
22
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 334/432
![Page 122: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/122.jpg)
Binomial Heap: Merge
The merge-operation is instrumental for binomial heaps.
A merge is easy if we have two heaps with different binomial
trees. We can simply merge the tree-lists.
Otherwise, we cannot do this because the merged heap is not
allowed to contain two trees of the same order.
Merging two trees of the same size: Add
the tree with larger root-value as a child to
the other tree.
For more trees the technique is analogous
to binary addition.
2
76
15
5
918
22
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 334/432
![Page 123: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/123.jpg)
Binomial Heap: Merge
The merge-operation is instrumental for binomial heaps.
A merge is easy if we have two heaps with different binomial
trees. We can simply merge the tree-lists.
Otherwise, we cannot do this because the merged heap is not
allowed to contain two trees of the same order.
Merging two trees of the same size: Add
the tree with larger root-value as a child to
the other tree.
For more trees the technique is analogous
to binary addition.
2
76
15
5
918
22
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 334/432
![Page 124: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/124.jpg)
Binomial Heap: Merge
The merge-operation is instrumental for binomial heaps.
A merge is easy if we have two heaps with different binomial
trees. We can simply merge the tree-lists.
Otherwise, we cannot do this because the merged heap is not
allowed to contain two trees of the same order.
Merging two trees of the same size: Add
the tree with larger root-value as a child to
the other tree.
For more trees the technique is analogous
to binary addition.
2
76
15
5
918
22
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 334/432
![Page 125: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/125.jpg)
4014
17
2
590
94
19
3027
42
3
2118
26
9
1346
54
194
39
14
2216
29
19
40
4
3914
17
4
3914
17
14
2216
29
0
19
40
4
3914
17
14
2216
29
2
590
94
19
3027
42
3
2118
26
9
1346
54
![Page 126: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/126.jpg)
4014
17
2
590
94
19
3027
42
3
2118
26
9
1346
54
194
39
14
2216
29
19
40
4
3914
17
4
3914
17
14
2216
29
0
19
40
4
3914
17
14
2216
29
2
590
94
19
3027
42
3
2118
26
9
1346
54
![Page 127: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/127.jpg)
4014
17
2
590
94
19
3027
42
3
2118
26
9
1346
54
194
39
14
2216
29
19
40
4
3914
17
4
3914
17
14
2216
29
0
19
40
4
3914
17
14
2216
29
2
590
94
19
3027
42
3
2118
26
9
1346
54
![Page 128: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/128.jpg)
4014
17
2
590
94
19
3027
42
3
2118
26
9
1346
54
194
39
14
2216
29
19
40
4
3914
17
4
3914
17
14
2216
29
0
19
40
4
3914
17
14
2216
29
2
590
94
19
3027
42
3
2118
26
9
1346
54
![Page 129: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/129.jpg)
4014
17
2
590
94
19
3027
42
3
2118
26
9
1346
54
194
39
14
2216
29
19
40
4
3914
17
4
3914
17
14
2216
29
0
19
40
4
3914
17
14
2216
29
2
590
94
19
3027
42
3
2118
26
9
1346
54
![Page 130: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/130.jpg)
4014
17
2
590
94
19
3027
42
3
2118
26
9
1346
54
194
39
14
2216
29
19
40
4
3914
17
4
3914
17
14
2216
29
0
19
40
4
3914
17
14
2216
29
2
590
94
19
3027
42
3
2118
26
9
1346
54
![Page 131: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/131.jpg)
4014
17
2
590
94
19
3027
42
3
2118
26
9
1346
54
194
39
14
2216
29
19
40
4
3914
17
4
3914
17
14
2216
29
019
40
4
3914
17
14
2216
29
2
590
94
19
3027
42
3
2118
26
9
1346
54
![Page 132: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/132.jpg)
4014
17
2
590
94
19
3027
42
3
2118
26
9
1346
54
194
39
14
2216
29
19
40
4
3914
17
4
3914
17
14
2216
29
019
40
4
3914
17
14
2216
29
2
590
94
19
3027
42
3
2118
26
9
1346
54
![Page 133: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/133.jpg)
4014
17
2
590
94
19
3027
42
3
2118
26
9
1346
54
194
39
14
2216
29
19
40
4
3914
17
4
3914
17
14
2216
29
019
40
4
3914
17
14
2216
29
2
590
94
19
3027
42
3
2118
26
9
1346
54
![Page 134: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/134.jpg)
4014
17
2
590
94
19
3027
42
3
2118
26
9
1346
54
194
39
14
2216
29
19
40
4
3914
17
4
3914
17
14
2216
29
019
40
4
3914
17
14
2216
29
2
590
94
19
3027
42
3
2118
26
9
1346
54
![Page 135: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/135.jpg)
4014
17
2
590
94
19
3027
42
3
2118
26
9
1346
54
194
39
14
2216
29
19
40
4
3914
17
4
3914
17
14
2216
29
019
40
4
3914
17
14
2216
29
2
590
94
19
3027
42
3
2118
26
9
1346
54
![Page 136: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/136.jpg)
4014
17
2
590
94
19
3027
42
3
2118
26
9
1346
54
194
39
14
2216
29
19
40
4
3914
17
4
3914
17
14
2216
29
019
40
4
3914
17
14
2216
29
2
590
94
19
3027
42
3
2118
26
9
1346
54
![Page 137: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/137.jpg)
4014
17
2
590
94
19
3027
42
3
2118
26
9
1346
54
194
39
14
2216
29
19
40
4
3914
17
4
3914
17
14
2216
29
019
40
4
3914
17
14
2216
29
2
590
94
19
3027
42
3
2118
26
9
1346
54
![Page 138: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/138.jpg)
4014
17
2
590
94
19
3027
42
3
2118
26
9
1346
54
194
39
14
2216
29
19
40
4
3914
17
4
3914
17
14
2216
29
019
40
4
3914
17
14
2216
29
2
590
94
19
3027
42
3
2118
26
9
1346
54
![Page 139: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/139.jpg)
4014
17
2
590
94
19
3027
42
3
2118
26
9
1346
54
194
39
14
2216
29
19
40
4
3914
17
4
3914
17
14
2216
29
019
40
4
3914
17
14
2216
29
2
590
94
19
3027
42
3
2118
26
9
1346
54
![Page 140: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/140.jpg)
8.2 Binomial Heaps
S1.merge(S2):ñ Analogous to binary addition.
ñ Time is proportional to the number of trees in both heaps.
ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 336/432
![Page 141: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/141.jpg)
8.2 Binomial Heaps
S1.merge(S2):ñ Analogous to binary addition.
ñ Time is proportional to the number of trees in both heaps.
ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 336/432
![Page 142: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/142.jpg)
8.2 Binomial Heaps
S1.merge(S2):ñ Analogous to binary addition.
ñ Time is proportional to the number of trees in both heaps.
ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 336/432
![Page 143: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/143.jpg)
8.2 Binomial Heaps
All other operations can be reduced to merge().
S. insert(x):ñ Create a new heap S′ that contains just the element x.
ñ Execute S.merge(S′).ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 337/432
![Page 144: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/144.jpg)
8.2 Binomial Heaps
All other operations can be reduced to merge().
S. insert(x):ñ Create a new heap S′ that contains just the element x.
ñ Execute S.merge(S′).ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 337/432
![Page 145: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/145.jpg)
8.2 Binomial Heaps
All other operations can be reduced to merge().
S. insert(x):ñ Create a new heap S′ that contains just the element x.
ñ Execute S.merge(S′).ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 337/432
![Page 146: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/146.jpg)
8.2 Binomial Heaps
S.minimum():ñ Find the minimum key-value among all roots.
ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 338/432
![Page 147: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/147.jpg)
8.2 Binomial Heaps
S. delete-min():ñ Find the minimum key-value among all roots.
ñ Remove the corresponding tree Tmin from the heap.
ñ Create a new heap S′ that contains the trees obtained from
Tmin after deleting the root (note that these are just
O(logn) trees).
ñ Compute S.merge(S′).ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 339/432
![Page 148: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/148.jpg)
8.2 Binomial Heaps
S. delete-min():ñ Find the minimum key-value among all roots.
ñ Remove the corresponding tree Tmin from the heap.
ñ Create a new heap S′ that contains the trees obtained from
Tmin after deleting the root (note that these are just
O(logn) trees).
ñ Compute S.merge(S′).ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 339/432
![Page 149: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/149.jpg)
8.2 Binomial Heaps
S. delete-min():ñ Find the minimum key-value among all roots.
ñ Remove the corresponding tree Tmin from the heap.
ñ Create a new heap S′ that contains the trees obtained from
Tmin after deleting the root (note that these are just
O(logn) trees).
ñ Compute S.merge(S′).ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 339/432
![Page 150: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/150.jpg)
8.2 Binomial Heaps
S. delete-min():ñ Find the minimum key-value among all roots.
ñ Remove the corresponding tree Tmin from the heap.
ñ Create a new heap S′ that contains the trees obtained from
Tmin after deleting the root (note that these are just
O(logn) trees).
ñ Compute S.merge(S′).ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 339/432
![Page 151: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/151.jpg)
8.2 Binomial Heaps
S. delete-min():ñ Find the minimum key-value among all roots.
ñ Remove the corresponding tree Tmin from the heap.
ñ Create a new heap S′ that contains the trees obtained from
Tmin after deleting the root (note that these are just
O(logn) trees).
ñ Compute S.merge(S′).ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 339/432
![Page 152: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/152.jpg)
8.2 Binomial Heaps
S. delete-min():ñ Find the minimum key-value among all roots.
ñ Remove the corresponding tree Tmin from the heap.
ñ Create a new heap S′ that contains the trees obtained from
Tmin after deleting the root (note that these are just
O(logn) trees).
ñ Compute S.merge(S′).ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 339/432
![Page 153: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/153.jpg)
8.2 Binomial Heaps
S. decrease-key(handle h):ñ Decrease the key of the element pointed to by h.
ñ Bubble the element up in the tree until the heap property is
fulfilled.
ñ Time: O(logn) since the trees have height O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 340/432
![Page 154: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/154.jpg)
8.2 Binomial Heaps
S. decrease-key(handle h):ñ Decrease the key of the element pointed to by h.
ñ Bubble the element up in the tree until the heap property is
fulfilled.
ñ Time: O(logn) since the trees have height O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 340/432
![Page 155: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/155.jpg)
8.2 Binomial Heaps
S. decrease-key(handle h):ñ Decrease the key of the element pointed to by h.
ñ Bubble the element up in the tree until the heap property is
fulfilled.
ñ Time: O(logn) since the trees have height O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 340/432
![Page 156: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/156.jpg)
8.2 Binomial Heaps
S. decrease-key(handle h):ñ Decrease the key of the element pointed to by h.
ñ Bubble the element up in the tree until the heap property is
fulfilled.
ñ Time: O(logn) since the trees have height O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 340/432
![Page 157: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/157.jpg)
8.2 Binomial Heaps
S. delete(handle h):ñ Execute S.decrease-key(h,−∞).ñ Execute S.delete-min().ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 341/432
![Page 158: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/158.jpg)
8.2 Binomial Heaps
S. delete(handle h):ñ Execute S.decrease-key(h,−∞).ñ Execute S.delete-min().ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 341/432
![Page 159: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/159.jpg)
8.2 Binomial Heaps
S. delete(handle h):ñ Execute S.decrease-key(h,−∞).ñ Execute S.delete-min().ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 341/432
![Page 160: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/160.jpg)
8.2 Binomial Heaps
S. delete(handle h):ñ Execute S.decrease-key(h,−∞).ñ Execute S.delete-min().ñ Time: O(logn).
8.2 Binomial Heaps
Ernst Mayr, Harald Räcke 341/432
![Page 161: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/161.jpg)
8.3 Fibonacci Heaps
Collection of trees that fulfill the heap property.
Structure is much more relaxed than binomial heaps.
7 24
4626
35
23 17
30
3
5241
44
18
39
min
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 342/432
![Page 162: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/162.jpg)
8.3 Fibonacci Heaps
Additional implementation details:
ñ Every node x stores its degree in a field x.degree. Note that
this can be updated in constant time when adding a child to
x.
ñ Every node stores a boolean value x.marked that specifies
whether x is marked or not.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 343/432
![Page 163: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/163.jpg)
8.3 Fibonacci Heaps
The potential function:
ñ t(S) denotes the number of trees in the heap.
ñ m(S) denotes the number of marked nodes.
ñ We use the potential function Φ(S) = t(S)+ 2m(S).
7 24
4626
35
23 17
30
3
5241
44
18
39
min
The potential is Φ(S) = 5+ 2 · 3 = 11.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 344/432
![Page 164: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/164.jpg)
8.3 Fibonacci Heaps
We assume that one unit of potential can pay for a constant
amount of work, where the constant is chosen “big enough” (to
take care of the constants that occur).
To make this more explicit we use c to denote the amount of
work that a unit of potential can pay for.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 345/432
![Page 165: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/165.jpg)
8.3 Fibonacci Heaps
S.minimum()
ñ Access through the min-pointer.
ñ Actual cost O(1).ñ No change in potential.
ñ Amortized cost O(1).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 346/432
![Page 166: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/166.jpg)
8.3 Fibonacci Heaps
S.merge(S′)ñ Merge the root lists.
ñ Adjust the min-pointer
7 24
4626
35
23 17
30
5
11
3
5241
44
18
39
min min
Running time:
ñ Actual cost O(1).ñ No change in potential.
ñ Hence, amortized cost is O(1).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 347/432
![Page 167: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/167.jpg)
8.3 Fibonacci Heaps
S.merge(S′)ñ Merge the root lists.
ñ Adjust the min-pointer
7 24
4626
35
23 17
30
5
11
3
5241
44
18
39
min
min
Running time:
ñ Actual cost O(1).
ñ No change in potential.
ñ Hence, amortized cost is O(1).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 347/432
![Page 168: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/168.jpg)
8.3 Fibonacci Heaps
S.merge(S′)ñ Merge the root lists.
ñ Adjust the min-pointer
7 24
4626
35
23 17
30
5
11
3
5241
44
18
39
min
min
Running time:
ñ Actual cost O(1).ñ No change in potential.
ñ Hence, amortized cost is O(1).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 347/432
![Page 169: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/169.jpg)
8.3 Fibonacci Heaps
S.merge(S′)ñ Merge the root lists.
ñ Adjust the min-pointer
7 24
4626
35
23 17
30
5
11
3
5241
44
18
39
min
min
Running time:
ñ Actual cost O(1).ñ No change in potential.
ñ Hence, amortized cost is O(1).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 347/432
![Page 170: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/170.jpg)
8.3 Fibonacci Heaps
S. insert(x)ñ Create a new tree containing x.ñ Insert x into the root-list.ñ Update min-pointer, if necessary.
7 24
4626
35
23 17
30
3
5241
44
18
39
min
x
Running time:
ñ Actual cost O(1).ñ Change in potential is +1.ñ Amortized cost is c +O(1) = O(1).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 348/432
![Page 171: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/171.jpg)
8.3 Fibonacci Heaps
S. insert(x)ñ Create a new tree containing x.ñ Insert x into the root-list.ñ Update min-pointer, if necessary.
7 24
4626
35
23 17
30
3
5241
44
18
39
min
x
Running time:
ñ Actual cost O(1).ñ Change in potential is +1.ñ Amortized cost is c +O(1) = O(1).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 348/432
![Page 172: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/172.jpg)
8.3 Fibonacci Heaps
S. insert(x)ñ Create a new tree containing x.ñ Insert x into the root-list.ñ Update min-pointer, if necessary.
7 24
4626
35
23 17
30
3
5241
44
18
39
min
x
Running time:
ñ Actual cost O(1).ñ Change in potential is +1.ñ Amortized cost is c +O(1) = O(1).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 348/432
![Page 173: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/173.jpg)
8.3 Fibonacci Heaps
S. delete-min(x)
ñ Delete minimum; add child-trees to heap;
time: D(min) · O(1).ñ Update min-pointer; time: (t +D(min)) · O(1).
7 24
4626
35
23 17
30
18
39
41
44
52
3
5241
44
18
39
min
ñ Consolidate root-list so that no roots have the same degree.
Time t · O(1) (see next slide).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 349/432
![Page 174: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/174.jpg)
8.3 Fibonacci Heaps
S. delete-min(x)ñ Delete minimum; add child-trees to heap;
time: D(min) · O(1).
ñ Update min-pointer; time: (t +D(min)) · O(1).
7 24
4626
35
23 17
30
18
39
41
44
52
3
5241
44
18
39
min
ñ Consolidate root-list so that no roots have the same degree.
Time t · O(1) (see next slide).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 349/432
![Page 175: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/175.jpg)
8.3 Fibonacci Heaps
S. delete-min(x)ñ Delete minimum; add child-trees to heap;
time: D(min) · O(1).ñ Update min-pointer; time: (t +D(min)) · O(1).
7 24
4626
35
23 17
30
18
39
41
44
52
3
5241
44
18
39
min
ñ Consolidate root-list so that no roots have the same degree.
Time t · O(1) (see next slide).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 349/432
![Page 176: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/176.jpg)
8.3 Fibonacci Heaps
S. delete-min(x)ñ Delete minimum; add child-trees to heap;
time: D(min) · O(1).ñ Update min-pointer; time: (t +D(min)) · O(1).
7 24
4626
35
23 17
30
18
39
41
44
52
3
5241
44
18
39
min
ñ Consolidate root-list so that no roots have the same degree.
Time t · O(1) (see next slide).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 349/432
![Page 177: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/177.jpg)
8.3 Fibonacci Heaps
S. delete-min(x)ñ Delete minimum; add child-trees to heap;
time: D(min) · O(1).ñ Update min-pointer; time: (t +D(min)) · O(1).
7 24
4626
35
23 17
30
18
39
41
44
52
3
5241
44
18
39
min
ñ Consolidate root-list so that no roots have the same degree.
Time t · O(1) (see next slide).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 349/432
![Page 178: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/178.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
52
18
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xx x x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 179: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/179.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
52
18
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xx x x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 180: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/180.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
52
18
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xx x x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 181: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/181.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
52
18
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xx x x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 182: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/182.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
52
18
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xx x x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 183: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/183.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
52
18
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xx x x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 184: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/184.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
5218
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xx x x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 185: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/185.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
5218
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xx x x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 186: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/186.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
5218
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xx x x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 187: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/187.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
52
18
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xx x x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 188: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/188.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
52
18
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xxx x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 189: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/189.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
52
18
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xxx x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 190: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/190.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
52
18
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xxx x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 191: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/191.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
52
18
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xxx x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 192: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/192.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
5218
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xxx x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 193: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/193.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
5218
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xxx x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 194: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/194.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23 17
30
18
39
41
44
5218
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xxx x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 195: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/195.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23
17
30
18
39
41
44
5218
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xxx x x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 196: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/196.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23
17
30
18
39
41
44
5218
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xxxx x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 197: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/197.jpg)
8.3 Fibonacci Heaps
Consolidate:
7
7
52
24
4626
35
23
17
30
18
39
41
44
5218
3941
44
18
3941
44
24
4626
35
7
5217
30
min
0 1 2 3
xxxx x
current
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 350/432
![Page 198: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/198.jpg)
8.3 Fibonacci Heaps
Actual cost for delete-min()ñ At most Dn + t elements in root-list before consolidate.
ñ Actual cost for a delete-min is at most O(1) · (Dn + t).Hence, there exists c1 s.t. actual cost is at most c1 · (Dn+ t).
Amortized cost for delete-min()
ñ t′ ≤ Dn + 1 as degrees are different after consolidating.
ñ Therefore ∆Φ ≤ Dn + 1− t;ñ We can pay c · (t −Dn − 1) from the potential decrease.
ñ The amortized cost is
c1 · (Dn + t)− c · (t −Dn − 1)
≤ (c1 + c)Dn + (c1 − c)t + c ≤ 2c(Dn + 1) ≤ O(Dn)
for c ≥ c1 .
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 351/432
![Page 199: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/199.jpg)
8.3 Fibonacci Heaps
Actual cost for delete-min()ñ At most Dn + t elements in root-list before consolidate.
ñ Actual cost for a delete-min is at most O(1) · (Dn + t).Hence, there exists c1 s.t. actual cost is at most c1 · (Dn+ t).
Amortized cost for delete-min()
ñ t′ ≤ Dn + 1 as degrees are different after consolidating.
ñ Therefore ∆Φ ≤ Dn + 1− t;ñ We can pay c · (t −Dn − 1) from the potential decrease.
ñ The amortized cost is
c1 · (Dn + t)− c · (t −Dn − 1)
≤ (c1 + c)Dn + (c1 − c)t + c ≤ 2c(Dn + 1) ≤ O(Dn)
for c ≥ c1 .
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 351/432
![Page 200: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/200.jpg)
8.3 Fibonacci Heaps
Actual cost for delete-min()ñ At most Dn + t elements in root-list before consolidate.
ñ Actual cost for a delete-min is at most O(1) · (Dn + t).Hence, there exists c1 s.t. actual cost is at most c1 · (Dn+ t).
Amortized cost for delete-min()ñ t′ ≤ Dn + 1 as degrees are different after consolidating.
ñ Therefore ∆Φ ≤ Dn + 1− t;ñ We can pay c · (t −Dn − 1) from the potential decrease.
ñ The amortized cost is
c1 · (Dn + t)− c · (t −Dn − 1)
≤ (c1 + c)Dn + (c1 − c)t + c ≤ 2c(Dn + 1) ≤ O(Dn)for c ≥ c1 .
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 351/432
![Page 201: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/201.jpg)
8.3 Fibonacci Heaps
Actual cost for delete-min()ñ At most Dn + t elements in root-list before consolidate.
ñ Actual cost for a delete-min is at most O(1) · (Dn + t).Hence, there exists c1 s.t. actual cost is at most c1 · (Dn+ t).
Amortized cost for delete-min()ñ t′ ≤ Dn + 1 as degrees are different after consolidating.
ñ Therefore ∆Φ ≤ Dn + 1− t;
ñ We can pay c · (t −Dn − 1) from the potential decrease.
ñ The amortized cost is
c1 · (Dn + t)− c · (t −Dn − 1)
≤ (c1 + c)Dn + (c1 − c)t + c ≤ 2c(Dn + 1) ≤ O(Dn)for c ≥ c1 .
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 351/432
![Page 202: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/202.jpg)
8.3 Fibonacci Heaps
Actual cost for delete-min()ñ At most Dn + t elements in root-list before consolidate.
ñ Actual cost for a delete-min is at most O(1) · (Dn + t).Hence, there exists c1 s.t. actual cost is at most c1 · (Dn+ t).
Amortized cost for delete-min()ñ t′ ≤ Dn + 1 as degrees are different after consolidating.
ñ Therefore ∆Φ ≤ Dn + 1− t;ñ We can pay c · (t −Dn − 1) from the potential decrease.
ñ The amortized cost is
c1 · (Dn + t)− c · (t −Dn − 1)
≤ (c1 + c)Dn + (c1 − c)t + c ≤ 2c(Dn + 1) ≤ O(Dn)for c ≥ c1 .
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 351/432
![Page 203: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/203.jpg)
8.3 Fibonacci Heaps
Actual cost for delete-min()ñ At most Dn + t elements in root-list before consolidate.
ñ Actual cost for a delete-min is at most O(1) · (Dn + t).Hence, there exists c1 s.t. actual cost is at most c1 · (Dn+ t).
Amortized cost for delete-min()ñ t′ ≤ Dn + 1 as degrees are different after consolidating.
ñ Therefore ∆Φ ≤ Dn + 1− t;ñ We can pay c · (t −Dn − 1) from the potential decrease.
ñ The amortized cost is
c1 · (Dn + t)− c · (t −Dn − 1)
≤ (c1 + c)Dn + (c1 − c)t + c ≤ 2c(Dn + 1) ≤ O(Dn)for c ≥ c1 .
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 351/432
![Page 204: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/204.jpg)
8.3 Fibonacci Heaps
Actual cost for delete-min()ñ At most Dn + t elements in root-list before consolidate.
ñ Actual cost for a delete-min is at most O(1) · (Dn + t).Hence, there exists c1 s.t. actual cost is at most c1 · (Dn+ t).
Amortized cost for delete-min()ñ t′ ≤ Dn + 1 as degrees are different after consolidating.
ñ Therefore ∆Φ ≤ Dn + 1− t;ñ We can pay c · (t −Dn − 1) from the potential decrease.
ñ The amortized cost is
c1 · (Dn + t)− c · (t −Dn − 1)
≤ (c1 + c)Dn + (c1 − c)t + c ≤ 2c(Dn + 1) ≤ O(Dn)for c ≥ c1 .
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 351/432
![Page 205: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/205.jpg)
8.3 Fibonacci Heaps
Actual cost for delete-min()ñ At most Dn + t elements in root-list before consolidate.
ñ Actual cost for a delete-min is at most O(1) · (Dn + t).Hence, there exists c1 s.t. actual cost is at most c1 · (Dn+ t).
Amortized cost for delete-min()ñ t′ ≤ Dn + 1 as degrees are different after consolidating.
ñ Therefore ∆Φ ≤ Dn + 1− t;ñ We can pay c · (t −Dn − 1) from the potential decrease.
ñ The amortized cost is
c1 · (Dn + t)− c · (t −Dn − 1)
≤ (c1 + c)Dn + (c1 − c)t + c
≤ 2c(Dn + 1) ≤ O(Dn)for c ≥ c1 .
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 351/432
![Page 206: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/206.jpg)
8.3 Fibonacci Heaps
Actual cost for delete-min()ñ At most Dn + t elements in root-list before consolidate.
ñ Actual cost for a delete-min is at most O(1) · (Dn + t).Hence, there exists c1 s.t. actual cost is at most c1 · (Dn+ t).
Amortized cost for delete-min()ñ t′ ≤ Dn + 1 as degrees are different after consolidating.
ñ Therefore ∆Φ ≤ Dn + 1− t;ñ We can pay c · (t −Dn − 1) from the potential decrease.
ñ The amortized cost is
c1 · (Dn + t)− c · (t −Dn − 1)
≤ (c1 + c)Dn + (c1 − c)t + c ≤ 2c(Dn + 1)
≤ O(Dn)for c ≥ c1 .
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 351/432
![Page 207: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/207.jpg)
8.3 Fibonacci Heaps
Actual cost for delete-min()ñ At most Dn + t elements in root-list before consolidate.
ñ Actual cost for a delete-min is at most O(1) · (Dn + t).Hence, there exists c1 s.t. actual cost is at most c1 · (Dn+ t).
Amortized cost for delete-min()ñ t′ ≤ Dn + 1 as degrees are different after consolidating.
ñ Therefore ∆Φ ≤ Dn + 1− t;ñ We can pay c · (t −Dn − 1) from the potential decrease.
ñ The amortized cost is
c1 · (Dn + t)− c · (t −Dn − 1)
≤ (c1 + c)Dn + (c1 − c)t + c ≤ 2c(Dn + 1) ≤ O(Dn)
for c ≥ c1 .
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 351/432
![Page 208: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/208.jpg)
8.3 Fibonacci Heaps
Actual cost for delete-min()ñ At most Dn + t elements in root-list before consolidate.
ñ Actual cost for a delete-min is at most O(1) · (Dn + t).Hence, there exists c1 s.t. actual cost is at most c1 · (Dn+ t).
Amortized cost for delete-min()ñ t′ ≤ Dn + 1 as degrees are different after consolidating.
ñ Therefore ∆Φ ≤ Dn + 1− t;ñ We can pay c · (t −Dn − 1) from the potential decrease.
ñ The amortized cost is
c1 · (Dn + t)− c · (t −Dn − 1)
≤ (c1 + c)Dn + (c1 − c)t + c ≤ 2c(Dn + 1) ≤ O(Dn)for c ≥ c1 .
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 351/432
![Page 209: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/209.jpg)
8.3 Fibonacci Heaps
If the input trees of the consolidation procedure are binomial
trees (for example only singleton vertices) then the output will
be a set of distinct binomial trees, and, hence, the Fibonacci
heap will be (more or less) a Binomial heap right after the
consolidation.
If we do not have delete or decrease-key operations then
Dn ≤ logn.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 352/432
![Page 210: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/210.jpg)
8.3 Fibonacci Heaps
If the input trees of the consolidation procedure are binomial
trees (for example only singleton vertices) then the output will
be a set of distinct binomial trees, and, hence, the Fibonacci
heap will be (more or less) a Binomial heap right after the
consolidation.
If we do not have delete or decrease-key operations then
Dn ≤ logn.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 352/432
![Page 211: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/211.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 1: decrease-key does not violate heap-property
ñ Just decrease the key-value of element referenced by h.
Nothing else to do.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 212: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/212.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 1: decrease-key does not violate heap-property
ñ Just decrease the key-value of element referenced by h.
Nothing else to do.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 213: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/213.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 1: decrease-key does not violate heap-property
ñ Just decrease the key-value of element referenced by h.
Nothing else to do.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 214: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/214.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 1: decrease-key does not violate heap-property
ñ Just decrease the key-value of element referenced by h.
Nothing else to do.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 215: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/215.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 2: heap-property is violated, but parent is not marked
ñ Decrease key-value of element x reference by h.
ñ If the heap-property is violated, cut the parent edge of x,
and make x into a root.
ñ Adjust min-pointers, if necessary.
ñ Mark the (previous) parent of x (unless it’s a root).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 216: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/216.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 2: heap-property is violated, but parent is not marked
ñ Decrease key-value of element x reference by h.
ñ If the heap-property is violated, cut the parent edge of x,
and make x into a root.
ñ Adjust min-pointers, if necessary.
ñ Mark the (previous) parent of x (unless it’s a root).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 217: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/217.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 2: heap-property is violated, but parent is not marked
ñ Decrease key-value of element x reference by h.
ñ If the heap-property is violated, cut the parent edge of x,
and make x into a root.
ñ Adjust min-pointers, if necessary.
ñ Mark the (previous) parent of x (unless it’s a root).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 218: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/218.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 2: heap-property is violated, but parent is not marked
ñ Decrease key-value of element x reference by h.
ñ If the heap-property is violated, cut the parent edge of x,
and make x into a root.
ñ Adjust min-pointers, if necessary.
ñ Mark the (previous) parent of x (unless it’s a root).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 219: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/219.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 2: heap-property is violated, but parent is not marked
ñ Decrease key-value of element x reference by h.
ñ If the heap-property is violated, cut the parent edge of x,
and make x into a root.
ñ Adjust min-pointers, if necessary.
ñ Mark the (previous) parent of x (unless it’s a root).
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 220: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/220.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 3: heap-property is violated, and parent is marked
ñ Decrease key-value of element x reference by h.
ñ Cut the parent edge of x, and make x into a root.
ñ Adjust min-pointers, if necessary.
ñ Continue cutting the parent until you arrive at an unmarked
node.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 221: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/221.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 3: heap-property is violated, and parent is marked
ñ Decrease key-value of element x reference by h.
ñ Cut the parent edge of x, and make x into a root.
ñ Adjust min-pointers, if necessary.
ñ Continue cutting the parent until you arrive at an unmarked
node.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 222: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/222.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 3: heap-property is violated, and parent is marked
ñ Decrease key-value of element x reference by h.
ñ Cut the parent edge of x, and make x into a root.
ñ Adjust min-pointers, if necessary.
ñ Continue cutting the parent until you arrive at an unmarked
node.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 223: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/223.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 3: heap-property is violated, and parent is marked
ñ Decrease key-value of element x reference by h.
ñ Cut the parent edge of x, and make x into a root.
ñ Adjust min-pointers, if necessary.
ñ Continue cutting the parent until you arrive at an unmarked
node.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 224: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/224.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 3: heap-property is violated, and parent is marked
ñ Decrease key-value of element x reference by h.
ñ Cut the parent edge of x, and make x into a root.
ñ Adjust min-pointers, if necessary.
ñ Continue cutting the parent until you arrive at an unmarked
node.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 225: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/225.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 3: heap-property is violated, and parent is marked
ñ Decrease key-value of element x reference by h.
ñ Cut the parent edge of x, and make x into a root.
ñ Adjust min-pointers, if necessary.
ñ Continue cutting the parent until you arrive at an unmarked
node.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 226: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/226.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 3: heap-property is violated, and parent is marked
ñ Decrease key-value of element x reference by h.
ñ Cut the parent edge of x, and make x into a root.
ñ Adjust min-pointers, if necessary.
ñ Continue cutting the parent until you arrive at an unmarked
node.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 227: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/227.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 3: heap-property is violated, and parent is marked
ñ Decrease key-value of element x reference by h.
ñ Cut the parent edge of x, and make x into a root.
ñ Adjust min-pointers, if necessary.
ñ Continue cutting the parent until you arrive at an unmarked
node.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 228: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/228.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
18
21
52
39
38
41
7
24
26
35
40
74
45
72
17
30
23
19
72
4
40
26
74
24
12
19
4
min
Case 3: heap-property is violated, and parent is marked
ñ Decrease key-value of element x reference by h.
ñ Cut the parent edge of x, and make x into a root.
ñ Adjust min-pointers, if necessary.
ñ Continue cutting the parent until you arrive at an unmarked
node.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 353/432
![Page 229: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/229.jpg)
Fibonacci Heaps: decrease-key(handle h, v)
Case 3: heap-property is violated, and parent is marked
ñ Decrease key-value of element x reference by h.
ñ Cut the parent edge of x, and make x into a root.
ñ Adjust min-pointers, if necessary.
ñ Execute the following:
p ← parent[x];while (p is marked)
pp ← parent[p];cut of p; make it into a root; unmark it;
p ← pp;
if p is unmarked and not a root mark it;
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 354/432
![Page 230: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/230.jpg)
Fibonacci Heaps: decrease-key(handle h, v)Actual cost:
ñ Constant cost for decreasing the value.
ñ Constant cost for each of ` cuts.
ñ Hence, cost is at most c2 · (` + 1), for some constant c2.
Amortized cost:
ñ t′ = t + `, as every cut creates one new root.
ñ m′ ≤m− (` − 1)+ 1 =m− ` + 2, since all but the first cut
unmarks a node; the last cut may mark a node.
ñ ∆Φ ≤ ` + 2(−` + 2) = 4− `ñ Amortized cost is at most
c2(`+1)+c(4−`) ≤ (c2−c)`+4c+c2 = O(1) ,if c ≥ c2.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 355/432
![Page 231: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/231.jpg)
Fibonacci Heaps: decrease-key(handle h, v)Actual cost:
ñ Constant cost for decreasing the value.
ñ Constant cost for each of ` cuts.
ñ Hence, cost is at most c2 · (` + 1), for some constant c2.
Amortized cost:
ñ t′ = t + `, as every cut creates one new root.
ñ m′ ≤m− (` − 1)+ 1 =m− ` + 2, since all but the first cut
unmarks a node; the last cut may mark a node.
ñ ∆Φ ≤ ` + 2(−` + 2) = 4− `ñ Amortized cost is at most
c2(`+1)+c(4−`) ≤ (c2−c)`+4c+c2 = O(1) ,if c ≥ c2.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 355/432
![Page 232: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/232.jpg)
Fibonacci Heaps: decrease-key(handle h, v)Actual cost:
ñ Constant cost for decreasing the value.
ñ Constant cost for each of ` cuts.
ñ Hence, cost is at most c2 · (` + 1), for some constant c2.
Amortized cost:
ñ t′ = t + `, as every cut creates one new root.
ñ m′ ≤m− (` − 1)+ 1 =m− ` + 2, since all but the first cut
unmarks a node; the last cut may mark a node.
ñ ∆Φ ≤ ` + 2(−` + 2) = 4− `ñ Amortized cost is at most
c2(`+1)+c(4−`) ≤ (c2−c)`+4c+c2 = O(1) ,if c ≥ c2.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 355/432
![Page 233: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/233.jpg)
Fibonacci Heaps: decrease-key(handle h, v)Actual cost:
ñ Constant cost for decreasing the value.
ñ Constant cost for each of ` cuts.
ñ Hence, cost is at most c2 · (` + 1), for some constant c2.
Amortized cost:
ñ t′ = t + `, as every cut creates one new root.
ñ m′ ≤m− (` − 1)+ 1 =m− ` + 2, since all but the first cut
unmarks a node; the last cut may mark a node.
ñ ∆Φ ≤ ` + 2(−` + 2) = 4− `ñ Amortized cost is at most
c2(`+1)+c(4−`) ≤ (c2−c)`+4c+c2 = O(1) ,if c ≥ c2.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 355/432
![Page 234: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/234.jpg)
Fibonacci Heaps: decrease-key(handle h, v)Actual cost:
ñ Constant cost for decreasing the value.
ñ Constant cost for each of ` cuts.
ñ Hence, cost is at most c2 · (` + 1), for some constant c2.
Amortized cost:
ñ t′ = t + `, as every cut creates one new root.
ñ m′ ≤m− (` − 1)+ 1 =m− ` + 2, since all but the first cut
unmarks a node; the last cut may mark a node.
ñ ∆Φ ≤ ` + 2(−` + 2) = 4− `ñ Amortized cost is at most
c2(`+1)+c(4−`) ≤ (c2−c)`+4c+c2 = O(1) ,if c ≥ c2.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 355/432
![Page 235: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/235.jpg)
Fibonacci Heaps: decrease-key(handle h, v)Actual cost:
ñ Constant cost for decreasing the value.
ñ Constant cost for each of ` cuts.
ñ Hence, cost is at most c2 · (` + 1), for some constant c2.
Amortized cost:
ñ t′ = t + `, as every cut creates one new root.
ñ m′ ≤m− (` − 1)+ 1 =m− ` + 2, since all but the first cut
unmarks a node; the last cut may mark a node.
ñ ∆Φ ≤ ` + 2(−` + 2) = 4− `ñ Amortized cost is at most
c2(`+1)+c(4−`) ≤ (c2−c)`+4c+c2 = O(1) ,if c ≥ c2.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 355/432
![Page 236: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/236.jpg)
Fibonacci Heaps: decrease-key(handle h, v)Actual cost:
ñ Constant cost for decreasing the value.
ñ Constant cost for each of ` cuts.
ñ Hence, cost is at most c2 · (` + 1), for some constant c2.
Amortized cost:
ñ t′ = t + `, as every cut creates one new root.
ñ m′ ≤m− (` − 1)+ 1 =m− ` + 2, since all but the first cut
unmarks a node; the last cut may mark a node.
ñ ∆Φ ≤ ` + 2(−` + 2) = 4− `ñ Amortized cost is at most
c2(`+1)+c(4−`) ≤ (c2−c)`+4c+c2 = O(1) ,if c ≥ c2.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 355/432
![Page 237: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/237.jpg)
Fibonacci Heaps: decrease-key(handle h, v)Actual cost:
ñ Constant cost for decreasing the value.
ñ Constant cost for each of ` cuts.
ñ Hence, cost is at most c2 · (` + 1), for some constant c2.
Amortized cost:
ñ t′ = t + `, as every cut creates one new root.
ñ m′ ≤m− (` − 1)+ 1 =m− ` + 2, since all but the first cut
unmarks a node; the last cut may mark a node.
ñ ∆Φ ≤ ` + 2(−` + 2) = 4− `ñ Amortized cost is at most
c2(`+1)+c(4−`) ≤ (c2−c)`+4c+c2 = O(1) ,if c ≥ c2.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 355/432
![Page 238: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/238.jpg)
Fibonacci Heaps: decrease-key(handle h, v)Actual cost:
ñ Constant cost for decreasing the value.
ñ Constant cost for each of ` cuts.
ñ Hence, cost is at most c2 · (` + 1), for some constant c2.
Amortized cost:
ñ t′ = t + `, as every cut creates one new root.
ñ m′ ≤m− (` − 1)+ 1 =m− ` + 2, since all but the first cut
unmarks a node; the last cut may mark a node.
ñ ∆Φ ≤ ` + 2(−` + 2) = 4− `ñ Amortized cost is at most
c2(`+1)+c(4−`) ≤ (c2−c)`+4c+c2 = O(1) ,if c ≥ c2.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 355/432
![Page 239: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/239.jpg)
Fibonacci Heaps: decrease-key(handle h, v)Actual cost:
ñ Constant cost for decreasing the value.
ñ Constant cost for each of ` cuts.
ñ Hence, cost is at most c2 · (` + 1), for some constant c2.
Amortized cost:
ñ t′ = t + `, as every cut creates one new root.
ñ m′ ≤m− (` − 1)+ 1 =m− ` + 2, since all but the first cut
unmarks a node; the last cut may mark a node.
ñ ∆Φ ≤ ` + 2(−` + 2) = 4− `ñ Amortized cost is at most
c2(`+1)+c(4−`) ≤ (c2−c)`+4c+c2 = O(1) ,if c ≥ c2.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 355/432
![Page 240: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/240.jpg)
Fibonacci Heaps: decrease-key(handle h, v)Actual cost:
ñ Constant cost for decreasing the value.
ñ Constant cost for each of ` cuts.
ñ Hence, cost is at most c2 · (` + 1), for some constant c2.
Amortized cost:
ñ t′ = t + `, as every cut creates one new root.
ñ m′ ≤m− (` − 1)+ 1 =m− ` + 2, since all but the first cut
unmarks a node; the last cut may mark a node.
ñ ∆Φ ≤ ` + 2(−` + 2) = 4− `ñ Amortized cost is at most
c2(`+1)+c(4−`) ≤ (c2−c)`+4c+c2 = O(1) ,if c ≥ c2.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 355/432
![Page 241: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/241.jpg)
Delete node
H. delete(x):ñ decrease value of x to −∞.
ñ delete-min.
Amortized cost: O(Dn)ñ O(1) for decrease-key.
ñ O(Dn) for delete-min.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 356/432
![Page 242: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/242.jpg)
8.3 Fibonacci Heaps
Lemma 1
Let x be a node with degree k and let y1, . . . , yk denote the
children of x in the order that they were linked to x. Then
degree(yi) ≥{
0 if i = 1
i− 2 if i > 1
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 357/432
![Page 243: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/243.jpg)
8.3 Fibonacci Heaps
Proof
ñ When yi was linked to x, at least y1, . . . , yi−1 were already
linked to x.
ñ Hence, at this time degree(x) ≥ i− 1, and therefore also
degree(yi) ≥ i− 1 as the algorithm links nodes of equal
degree only.
ñ Since, then yi has lost at most one child.
ñ Therefore, degree(yi) ≥ i− 2.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 358/432
![Page 244: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/244.jpg)
8.3 Fibonacci Heaps
Proof
ñ When yi was linked to x, at least y1, . . . , yi−1 were already
linked to x.
ñ Hence, at this time degree(x) ≥ i− 1, and therefore also
degree(yi) ≥ i− 1 as the algorithm links nodes of equal
degree only.
ñ Since, then yi has lost at most one child.
ñ Therefore, degree(yi) ≥ i− 2.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 358/432
![Page 245: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/245.jpg)
8.3 Fibonacci Heaps
Proof
ñ When yi was linked to x, at least y1, . . . , yi−1 were already
linked to x.
ñ Hence, at this time degree(x) ≥ i− 1, and therefore also
degree(yi) ≥ i− 1 as the algorithm links nodes of equal
degree only.
ñ Since, then yi has lost at most one child.
ñ Therefore, degree(yi) ≥ i− 2.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 358/432
![Page 246: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/246.jpg)
8.3 Fibonacci Heaps
Proof
ñ When yi was linked to x, at least y1, . . . , yi−1 were already
linked to x.
ñ Hence, at this time degree(x) ≥ i− 1, and therefore also
degree(yi) ≥ i− 1 as the algorithm links nodes of equal
degree only.
ñ Since, then yi has lost at most one child.
ñ Therefore, degree(yi) ≥ i− 2.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 358/432
![Page 247: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/247.jpg)
8.3 Fibonacci Heaps
ñ Let sk be the minimum possible size of a sub-tree rooted at
a node of degree k that can occur in a Fibonacci heap.
ñ sk monotonically increases with kñ s0 = 1 and s1 = 2.
Let x be a degree k node of size sk and let y1, . . . , yk be its
children.
sk = 2+k∑
i=2
size(yi)
≥ 2+k∑
i=2
si−2
= 2+k−2∑
i=0
si
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 359/432
![Page 248: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/248.jpg)
8.3 Fibonacci Heaps
ñ Let sk be the minimum possible size of a sub-tree rooted at
a node of degree k that can occur in a Fibonacci heap.
ñ sk monotonically increases with k
ñ s0 = 1 and s1 = 2.
Let x be a degree k node of size sk and let y1, . . . , yk be its
children.
sk = 2+k∑
i=2
size(yi)
≥ 2+k∑
i=2
si−2
= 2+k−2∑
i=0
si
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 359/432
![Page 249: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/249.jpg)
8.3 Fibonacci Heaps
ñ Let sk be the minimum possible size of a sub-tree rooted at
a node of degree k that can occur in a Fibonacci heap.
ñ sk monotonically increases with kñ s0 = 1 and s1 = 2.
Let x be a degree k node of size sk and let y1, . . . , yk be its
children.
sk = 2+k∑
i=2
size(yi)
≥ 2+k∑
i=2
si−2
= 2+k−2∑
i=0
si
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 359/432
![Page 250: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/250.jpg)
8.3 Fibonacci Heaps
ñ Let sk be the minimum possible size of a sub-tree rooted at
a node of degree k that can occur in a Fibonacci heap.
ñ sk monotonically increases with kñ s0 = 1 and s1 = 2.
Let x be a degree k node of size sk and let y1, . . . , yk be its
children.
sk = 2+k∑
i=2
size(yi)
≥ 2+k∑
i=2
si−2
= 2+k−2∑
i=0
si
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 359/432
![Page 251: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/251.jpg)
8.3 Fibonacci Heaps
ñ Let sk be the minimum possible size of a sub-tree rooted at
a node of degree k that can occur in a Fibonacci heap.
ñ sk monotonically increases with kñ s0 = 1 and s1 = 2.
Let x be a degree k node of size sk and let y1, . . . , yk be its
children.
sk = 2+k∑
i=2
size(yi)
≥ 2+k∑
i=2
si−2
= 2+k−2∑
i=0
si
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 359/432
![Page 252: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/252.jpg)
8.3 Fibonacci Heaps
ñ Let sk be the minimum possible size of a sub-tree rooted at
a node of degree k that can occur in a Fibonacci heap.
ñ sk monotonically increases with kñ s0 = 1 and s1 = 2.
Let x be a degree k node of size sk and let y1, . . . , yk be its
children.
sk = 2+k∑
i=2
size(yi)
≥ 2+k∑
i=2
si−2
= 2+k−2∑
i=0
si
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 359/432
![Page 253: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/253.jpg)
8.3 Fibonacci Heaps
Definition 2
Consider the following non-standard Fibonacci type sequence:
Fk =
1 if k = 0
2 if k = 1
Fk−1 + Fk−2 if k ≥ 2
φ = 12 (1 +
√5) denotes the golden ratio.
Note that φ2 = 1+φ.
Facts:
1. Fk ≥ φk.2. For k ≥ 2: Fk = 2+∑k−2
i=0 Fi.
The above facts can be easily proved by induction. From this it
follows that sk ≥ Fk ≥ φk, which gives that the maximum degree
in a Fibonacci heap is logarithmic.
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 360/432
![Page 254: 8 Priority Queues - TUM8 Priority Queues Anaddressable Priority Queuealso supports: æ handle S: insert—x–: Adds element xto the data-structure, and returns ahandleto the object](https://reader035.vdocuments.us/reader035/viewer/2022081620/6107e724070cdf40a532e7c7/html5/thumbnails/254.jpg)
k=0: 1 = F0 ≥ Φ0 = 1
k=1: 2 = F1 ≥ Φ1 ≈ 1.61
k-2,k-1→ k: Fk = Fk−1+Fk−2 ≥ Φk−1+Φk−2 = Φk−2(Φ + 1) = ΦkΦ2︷ ︸︸ ︷
k=2: 3 = F2 = 2+ 1 = 2+ F0
k-1→ k: Fk = Fk−1 + Fk−2 = 2+∑k−3i=0 Fi + Fk−2 = 2+∑k−2
i=0 Fi
8.3 Fibonacci Heaps
Ernst Mayr, Harald Räcke 361/432