mirror of
https://github.com/sablierapp/sablier.git
synced 2025-12-21 13:23:03 +01:00
82 lines
2.2 KiB
Go
82 lines
2.2 KiB
Go
// Package heap provides heap operations for any type that implements
|
|
// heap.Interface. A heap is a tree with the property that each node is the
|
|
// minimum-valued node in its subtree.
|
|
//
|
|
// The minimum element in the tree is the root, at index 0.
|
|
//
|
|
// A heap is a common way to implement a priority queue. To build a priority
|
|
// queue, implement the Heap interface with the (negative) priority as the
|
|
// ordering for the Less method, so Push adds items while Pop removes the
|
|
// highest-priority item from the queue. The Examples include such an
|
|
// implementation; the file example_pq_test.go has the complete source.
|
|
//
|
|
|
|
package tinykv
|
|
|
|
type tohVal = *timeout
|
|
|
|
// Any type that implements heap.Interface may be used as a
|
|
// min-heap with the following invariants (established after
|
|
// Init has been called or if the data is empty or sorted):
|
|
//
|
|
// !h.Less(j, i) for 0 <= i < h.Len() and 2*i+1 <= j <= 2*i+2 and j < h.Len()
|
|
//
|
|
// Note that Push and Pop in this interface are for package heap's
|
|
// implementation to call. To add and remove things from the heap,
|
|
// use heap.Push and heap.Pop.
|
|
type timeheapInterface interface {
|
|
Len() int
|
|
Less(i, j int) bool
|
|
Swap(i, j int)
|
|
Push(x tohVal) // add x as element Len()
|
|
Pop() tohVal // remove and return element Len() - 1.
|
|
}
|
|
|
|
// Push pushes the element x onto the heap. The complexity is
|
|
// O(log(n)) where n = h.Len().
|
|
func timeheapPush(h timeheapInterface, x tohVal) {
|
|
h.Push(x)
|
|
timeheapup(h, h.Len()-1)
|
|
}
|
|
|
|
// Pop removes the minimum element (according to Less) from the heap
|
|
// and returns it. The complexity is O(log(n)) where n = h.Len().
|
|
// It is equivalent to Remove(h, 0).
|
|
func timeheapPop(h timeheapInterface) tohVal {
|
|
n := h.Len() - 1
|
|
h.Swap(0, n)
|
|
timeheapdown(h, 0, n)
|
|
return h.Pop()
|
|
}
|
|
|
|
func timeheapup(h timeheapInterface, j int) {
|
|
for {
|
|
i := (j - 1) / 2 // parent
|
|
if i == j || !h.Less(j, i) {
|
|
break
|
|
}
|
|
h.Swap(i, j)
|
|
j = i
|
|
}
|
|
}
|
|
|
|
func timeheapdown(h timeheapInterface, i0, n int) bool {
|
|
i := i0
|
|
for {
|
|
j1 := 2*i + 1
|
|
if j1 >= n || j1 < 0 { // j1 < 0 after int overflow
|
|
break
|
|
}
|
|
j := j1 // left child
|
|
if j2 := j1 + 1; j2 < n && h.Less(j2, j1) {
|
|
j = j2 // = 2*i + 2 // right child
|
|
}
|
|
if !h.Less(j, i) {
|
|
break
|
|
}
|
|
h.Swap(i, j)
|
|
i = j
|
|
}
|
|
return i > i0
|
|
}
|