Namespace: go.std.container.heap
v1.0Contents
Summary
Provides a lowlevel interface to the container/heap package.
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
minimumvalued 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
highestpriority item from the queue. The Examples include such an
implementation; the file example_pq_test.go has the complete source.
Index
Legend

Constant
Variable
Function
Macro
Special form
Type
GoVar
Receiver/Method
Constants
Constants are variables with :const true in their metadata. Joker currently does not recognize them as special; as such, it allows redefining them or their values.
(None.)
Variables

(None.)
Functions, Macros, and Special Forms

Fix
Function v1.0(Fix h i)
Fix reestablishes the heap ordering after the element at index i has changed its value.
Changing the value of the element at index i and then calling Fix is equivalent to,
but less expensive than, calling Remove(h, i) followed by a Push of the new value.
The complexity is O(log n) where n = h.Len().
Go input arguments: (h Interface, i int)
Joker input arguments: [^Interface h, ^Int i] 
Init
Function v1.0(Init h)
Init establishes the heap invariants required by the other routines in this package.
Init is idempotent with respect to the heap invariants
and may be called whenever the heap invariants may have been invalidated.
The complexity is O(n) where n = h.Len().
Go input arguments: (h Interface)
Joker input arguments: [^Interface h] 
Pop
Function v1.0(Pop h)
Pop removes and returns the minimum element (according to Less) from the heap.
The complexity is O(log n) where n = h.Len().
Pop is equivalent to Remove(h, 0).
Go input arguments: (h Interface)
Go returns: interface{}
Joker input arguments: [^Interface h]
Joker returns: ^GoObject 
Push
Function v1.0(Push h x)
Push pushes the element x onto the heap.
The complexity is O(log n) where n = h.Len().
Go input arguments: (h Interface, x interface{})
Joker input arguments: [^Interface h, ^GoObject x] 
Remove
Function v1.0(Remove h i)
Remove removes and returns the element at index i from the heap.
The complexity is O(log n) where n = h.Len().
Go input arguments: (h Interface, i int)
Go returns: interface{}
Joker input arguments: [^Interface h, ^Int i]
Joker returns: ^GoObject
Types

Interface
Abstract Type v1.0The Interface type describes the requirements
for a type using the routines in this package.
Any type that implements it may be used as a
minheap 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.

Len
Method for Interface v1.0([])

Less
Method for Interface v1.0([i j])

Pop
Method for Interface v1.0([])

Push
Method for Interface v1.0([x])

Swap
Method for Interface v1.0([i j])

arrayOfInterface
Concrete Type v1.0The Interface type describes the requirements
for a type using the routines in this package.
Any type that implements it may be used as a
minheap 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.