├── .gitignore
├── util.go
├── pqinterface.go
├── LICENSE
├── readme.md
├── boheap.go
├── boheap_test.go
└── bonode.go


/.gitignore:
--------------------------------------------------------------------------------
1 | # IntelliJ stuff
2 | .idea
3 | *.iml


--------------------------------------------------------------------------------
/util.go:
--------------------------------------------------------------------------------
 1 | package BrodalOkasakiHeap
 2 | 
 3 | import "fmt"
 4 | 
 5 | 
 6 | func printSpace(amount int) {
 7 |     for i:=0; i<amount; i++ {
 8 |         fmt.Print(" ")
 9 |     }
10 | }


--------------------------------------------------------------------------------
/pqinterface.go:
--------------------------------------------------------------------------------
 1 | package BrodalOkasakiHeap
 2 | 
 3 | /*
 4 | Generic operations to be performed over heap structure.
 5 |  */
 6 | type PriorityQueue interface {
 7 |     Insert(int)				// Insert an element into the pqueue.
 8 |     Pop()    	int			// Return and remove the topmost key, determined by the implementation.
 9 |     Peek()    	int			// Return the topmost key
10 |     Size()		int			// Get the size of pqueue.
11 |     Merge(PriorityQueue)	// Merge two of the same-type priority queue (this means you shouldn't attempt merging a binary heap with a binomial heap).
12 | 
13 |     // Brodal-Okasaki heaps does not support DecreaseKey() operation, but in the discussion section of the paper,
14 |     // the author mentions a few ideas on how it might be possible.
15 |     // DecreaseKey()
16 | }
17 | 
18 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 ckaygusu
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | Introduction
 2 | ============
 3 | Brodal-Okasaki heap is a tree structure that satisfies the heap property. It is asympotically optimal, supporting
 4 | 
 5 | * Inserting a new value
 6 | * Finding the minimum value
 7 | * Merging with another queue
 8 | * Decreasing an element within the queue
 9 | 
10 | on O(1) worst-case execution time, and supporting
11 | 
12 | * Deleting the minimum value
13 | 
14 | on O(logn) time.
15 | 
16 | The heap is first described in the paper that may be accessed from [here](http://www.brics.dk/RS/96/37/BRICS-RS-96-37.pdf).
17 | This implementation follows the original description as close as possible, but there are a few differences/ambigiuous
18 | points that is explained in the code.
19 | 
20 | 
21 | Prerequisites
22 | =============
23 | One who wish to venture further should get familiar with
24 | 
25 | * Heaps in general and
26 | * Binomial Heap  (I have an implementation using Go in [this repository](https://github.com/ckaygusu/BinomialHeap).)
27 | 
28 | You are free to try to make sense what is present in this repository, but I think getting familiar with these concepts
29 | will help you have easier time with it.
30 | 
31 | 
32 | Brodal-Okasaki heap
33 | ===================
34 | This data structure is a heavily modified version of the binomial heap;
35 | 
36 | * A different subtree linking mechanism is introduced to make Insert() perform in O(1).
37 |     * Takes O(logn) in ordinary binomial heap.
38 |     * This variant is called "Skew-Binomial Heap".
39 | * Adding a root node that holds the minimum element.
40 | * The data structure is allowed to contain itself to make Merge() perform in O(1).
41 |     * Takes O(logn) in skew-binomial and ordinary binomial heaps.
42 | 
43 | These three modifications yields us an asymptotically optimal data structure, which means we cannot improve any of the
44 | worst-case bounds without increasing the bound for some other operation.
45 | 
46 | 
47 | Asymptotic Optimality
48 | =======================
49 | Skew-Binomial heaps do really reduce the work done over the binomial heaps, but Brodal-Okasaki heaps achieve the same
50 | asymptotical improvement by doing most of the actual work under Pop().
51 | 
52 | * Peek() ("findMin" operation) takes O(1) time because we determine the next minimum element within the runtime of
53 | Pop() operation. Determining the minimum element takes O(logn) time.
54 | * Merge() takes O(1) time, because this operation simply puts the other queue under the carpet and inserts only
55 | the root node of other queue. Actual merging operation is done within the runtime of Pop() when we pop a node that
56 | happens to have nodes "under the carpet".
57 | * Actual Pop() operation (as in binomial heap) already takes O(logn) time.
58 | 
59 | Since it does not matter whether we perform 3*logn or 50*logn operations, under "O" notation they are all O(logn).
60 | By this little hack, we achieve asymptotical optimality, where everything except Pop() is done under O(1).
61 | 
62 | As you can see, we don't really reduce the amount of work done here, we just push them under the same umbrella so
63 | the chart looks nice and dandy. Because of this, I agree with the authors stating this data structure is of little
64 | practical interest but serves as an theoretical example that this kind of asymptotical performance is possible.
65 | 
66 | 
67 | Functional vs Imperative
68 | ========================
69 | In the paper, Brodal-Okasaki heap has a functional implementation. Here, I made the implementation in a imperative
70 | language (Go) so some of the concepts may not translate directly.
71 | 
72 | 
73 | Puzzles
74 | =======
75 | After grasping this data structure, you may play with it by
76 | 
77 | * Optimizing for performance. This implementation is horribly inefficient, and there are a lot of points that can
78 | be optimized.
79 | * I left out some questions as comments in the code. Try to tackle them, they are not too complicated.


--------------------------------------------------------------------------------
/boheap.go:
--------------------------------------------------------------------------------
  1 | package BrodalOkasakiHeap
  2 | import "fmt"
  3 | 
  4 | 
  5 | /*
  6 | "BOHeap" is a wrapper around "BONode". This structure is defines an entrypoint for a Brodal-Okasaki heap and
  7 | implements the priority queue interface using operations defined for "BONode" structure.
  8 |  */
  9 | type BOHeap struct {
 10 |     root	*BONode
 11 |     size 	int
 12 | }
 13 | 
 14 | 
 15 | /*
 16 | Create a new Brodal-Okasaki heap.
 17 |  */
 18 | func NewBOHeap() *BOHeap {
 19 |     return &BOHeap {
 20 |         root: nil,
 21 |         size: 0,
 22 |     }
 23 | }
 24 | 
 25 | 
 26 | /*
 27 | Insert a new value to the heap.
 28 | 
 29 | This function depends on another "insert" function, but executing this function always performs the insertion procedure
 30 | of the skew-binomial heaps, which is simply described as follows:
 31 |     1. Get two nodes from the children of root node that has the minimum ranks.
 32 |     2. Skew-link those two nodes and the new node.
 33 |     3. Insert this newly linked node among the children of root.
 34 | 
 35 | Much of the logical complexity is hidden in the "skew-linking" procedure. Read "BONode.skewLink".
 36 |  */
 37 | func (bq *BOHeap) Insert(value int) {
 38 |     newnode := newBONode(value)
 39 |     bq.size += 1
 40 |     bq.insert(newnode)
 41 | }
 42 | 
 43 | /*
 44 | Delete and return the minimum valued node.
 45 | 
 46 | Since we do almost everything under Pop(), this function is a bit complicated. I implemented Pop() as follows:
 47 | 
 48 |     1. Get the minimum node among the children of root.
 49 |     2. If this node has elements in its subqueue, add them to the original queue.
 50 |     3. For every children of the minimum node;
 51 |         3a. Insert the child again to the original heap.
 52 | 
 53 | All suboperations (1, 2, 3) take O(logn) time. As you can see, Pop() does every operation that takes O(logn) time, hence
 54 | the asymptotical optimality.
 55 | 
 56 | In the original paper, re-inserting the children of a node involves partitioning the children. I didn't bother understanding
 57 | what the authors really meant, and made a slight modification here. Figure out the difference.
 58 |  */
 59 | func (bq *BOHeap) Pop() int {
 60 |     bq.size -= 1
 61 |     retval := bq.root.value
 62 | 
 63 |     if bq.root.subqueue_head != nil {
 64 |         bq.merge_subqueue()
 65 |     }
 66 | 
 67 |     minchild := bq.root.getMinChild()
 68 | 
 69 |     if minchild == nil {
 70 |         // minchild == nil signifies the heap is empty.
 71 |         bq.root = nil
 72 |     } else {
 73 |         minchild.rogue()
 74 |         bq.reInsertChildren(minchild)
 75 |         bq.promoteToRoot(minchild)
 76 |     }
 77 | 
 78 |     return retval
 79 | }
 80 | 
 81 | 
 82 | /*
 83 | Return the minimum valued element in the queue.
 84 |  */
 85 | func (bq *BOHeap) Peek() int {
 86 |     // Minimum is the global root so we have O(1) access time.
 87 |     return bq.root.value
 88 | }
 89 | 
 90 | 
 91 | /*
 92 | Return the total keys present in the queue.
 93 |  */
 94 | func (bq *BOHeap) Size() int {
 95 |     return bq.size
 96 | }
 97 | 
 98 | 
 99 | /*
100 | Instead of doing the merge operation immediately, we do it when we need it. This is also called "lazy-evaluation".
101 | Implementation of this operation is:
102 |     * Move the children head to the subqueue head.
103 |     * Insert the root of other queue as if it is a singleton node.
104 |  */
105 | func (bq* BOHeap) Merge(other *BOHeap) {
106 |     bq.size += other.size
107 | 
108 |     oroot := other.root
109 |     oroot.moveChildrenToSubqueue()
110 | 
111 |     bq.insert(oroot)
112 | }
113 | 
114 | 
115 | // ====== Helper functions =======
116 | 
117 | 
118 | /*
119 | This method performs the actual insertion operation. It is a bit complicated because it has to deal with 4 cases:
120 |     * Insertion when the queue is empty
121 |     * Insertion when the new node's value is smaller than the root.
122 |     * Insertion of nodes with rank 0
123 |         * We perform the insertion procedure of skew binomial heaps.
124 |     * Insertion of nodes with rank >0
125 |         * We perform the insertion procedure of ordinary binomial heaps.
126 |  */
127 | func (bq* BOHeap) insert(newnode *BONode) {
128 |     if bq.root == nil {
129 |         // When the queue is empty.
130 |         bq.root = newnode
131 |     } else if newnode.value < bq.root.value {  // If you put "<=" instead of "<", an infinite loop occurs. Find why.
132 |         oldroot := bq.swapWithRoot(newnode)
133 |         bq.insert(oldroot)
134 |     } else {
135 |         if newnode.rank > 0 {
136 |             bq.insert_binomial(newnode)
137 |         } else {
138 |             bq.insert_skew(newnode)
139 |         }
140 |     }
141 | }
142 | 
143 | 
144 | /*
145 | Merge the subqueue. Essentially, re-insert the immediate children, but for the subqueue.
146 |  */
147 | func (bq* BOHeap) merge_subqueue() {
148 |     for _, node := range bq.root.subqueueIterator() {
149 |         node.rogue_subqueue()
150 |         bq.insert(node)
151 |     }
152 | }
153 | 
154 | /*
155 | Re-insert the children. Simple.
156 |  */
157 | func (bq* BOHeap) reInsertChildren(bon *BONode) {
158 |     // Reinsert the children of the GIVEN node.
159 |     for _, node := range bon.childrenIterator() {
160 |         node.rogue()
161 |         bq.insert(node)
162 |     }
163 | }
164 | 
165 | 
166 | /*
167 | This function performs skew-binomial insertion, which is;
168 |     * Get the minimum ranked 2 children.
169 |     * Compare the ranks of those 2 children
170 |         * If they have the same rank, skew-link them, and simply insert the resulting node.
171 |         * If they have different ranks, simply insert the newnode.
172 |     It is important to note that "newnode" has a rank of 0. This method should not run for nodes that has rank <>0
173 |  */
174 | func (bq* BOHeap) insert_skew(newnode *BONode) {
175 |     node1, node2 := bq.root.getSmallestRankChildren()
176 |     mergednode := skewLink(node1, node2, newnode)
177 |     bq.root.adopt(mergednode)
178 | }
179 | 
180 | 
181 | /*
182 | This is the insertion procedure for ordinary binomial heaps, which is;
183 |     * Get a child that has the same rank for the other node.
184 |         * If such node exists, among those two who has smaller value adopts the other one. Insert the newly made node
185 |           into the queue.
186 |         * If not, simply insert the other node.
187 | 
188 | This operation can possibly take O(logn) time under normal implementation.
189 | Consider the case, inserting a node of rank 3 to the binomial heap that has the following state (numbers imply ranks):
190 | 
191 |     * (4 3) <-- 3
192 | 
193 | This will cause another insertion operation
194 | 
195 |     * (4) <-- 4
196 | 
197 | In the worst case, this operation cascades up to "logn" time, but this fact doesn't harm the asymptotical optimality,
198 | since it can only be executed under Pop().
199 |  */
200 | func (bq* BOHeap) insert_binomial(other *BONode) {
201 |     // "other" is assumed to be rogue.
202 | 
203 |     srnode := bq.root.getSameRankChild(other.rank)
204 | 
205 |     if srnode == nil {
206 |         bq.root.adopt(other)
207 |     } else {
208 |         newnode := simpleLink(srnode, other)
209 |         // There is a recursion here. If the aforementioned cascading to be occur, it shall be done so by recursing
210 |         // the next line of code. Figure it out yourself.
211 |         bq.insert(newnode)
212 |     }
213 | }
214 | 
215 | 
216 | /*
217 | Swap the other node with the existing root.
218 |  */
219 | func (bq* BOHeap) swapWithRoot(newroot *BONode) *BONode {
220 |     // "newroot" is assumed to be rogue and childless.
221 |     oldroot := bq.root
222 | 
223 |     // Since the children has a reference to their parents, we need to iterate through all of them anyway.
224 |     // Simply transferring "children_head" won't work.
225 |     for _, node := range oldroot.childrenIterator() {
226 |         node.rogue()
227 |         newroot.adopt(node)
228 |     }
229 | 
230 |     oldroot.rank = 0
231 | 
232 |     bq.root = newroot
233 |     return oldroot
234 | }
235 | 
236 | 
237 | /*
238 | Promote the selected node to be the new root.
239 |  */
240 | func (bq* BOHeap) promoteToRoot(minnode *BONode) {
241 |     // There is a bug. What is it?
242 |     bq.root.value = minnode.value
243 |     bq.root.subqueue_head = minnode.subqueue_head
244 | }
245 | 
246 | 
247 | func (bq* BOHeap) print() {
248 |     if bq.root == nil {
249 |         fmt.Println("heap is empty.")
250 |     } else {
251 |         bq.root.print_recursive(0)
252 |     }
253 | }


--------------------------------------------------------------------------------
/boheap_test.go:
--------------------------------------------------------------------------------
  1 | package BrodalOkasakiHeap
  2 | 
  3 | 
  4 | import (
  5 |     "testing"
  6 |     "math/rand"
  7 | )
  8 | 
  9 | 
 10 | func Test_adopt_rankorder_1(t *testing.T) {
 11 |     root := newBONode(0)
 12 | 
 13 |     n1 := newBONode(1)
 14 |     n1.rank = 1
 15 | 
 16 |     n2 := newBONode(2)
 17 |     n2.rank = 2
 18 | 
 19 |     n3 := newBONode(3)
 20 |     n3.rank = 3
 21 | 
 22 |     n4 := newBONode(4)
 23 |     n4.rank = 4
 24 | 
 25 |     root.adopt(n1)
 26 |     root.adopt(n2)
 27 |     root.adopt(n3)
 28 |     root.adopt(n4)
 29 | 
 30 | 
 31 | 
 32 |     child := root.children_head
 33 |     if child != n1 {t.Errorf("Expected %d, got %d", n1.value, child.value)}
 34 | 
 35 |     child = child.rightsibling
 36 |     if child != n2 {t.Errorf("Expected %d, got %d", n2.value, child.value)}
 37 | 
 38 |     child = child.rightsibling
 39 |     if child != n3 {t.Errorf("Expected %d, got %d", n3.value, child.value)}
 40 | 
 41 |     child = child.rightsibling
 42 |     if child != n4 {t.Errorf("Expected %d, got %d", n4.value, child.value)}
 43 | }
 44 | 
 45 | 
 46 | func Test_adopt_rankorder_2(t *testing.T) {
 47 |     root := newBONode(0)
 48 | 
 49 |     n1 := newBONode(1)
 50 |     n1.rank = 1
 51 | 
 52 |     n2 := newBONode(2)
 53 |     n2.rank = 2
 54 | 
 55 |     n3 := newBONode(3)
 56 |     n3.rank = 3
 57 | 
 58 |     n4 := newBONode(4)
 59 |     n4.rank = 4
 60 | 
 61 |     n4_2 := newBONode(5)
 62 |     n4_2.rank = 4
 63 | 
 64 |     root.adopt(n4_2)
 65 |     root.adopt(n4)
 66 |     root.adopt(n3)
 67 |     root.adopt(n2)
 68 |     root.adopt(n1)
 69 | 
 70 |     child := root.children_head
 71 |     if child != n1 {t.Errorf("Expected %d, got %d", n1.value, child.value)}
 72 | 
 73 |     child = child.rightsibling
 74 |     if child != n2 {t.Errorf("Expected %d, got %d", n2.value, child.value)}
 75 | 
 76 |     child = child.rightsibling
 77 |     if child != n3 {t.Errorf("Expected %d, got %d", n3.value, child.value)}
 78 | 
 79 |     child = child.rightsibling
 80 |     if child != n4 {t.Errorf("Expected %d, got %d", n4.value, child.value)}
 81 | }
 82 | 
 83 | 
 84 | func Test_adopt_rankorder_3(t *testing.T) {
 85 |     root := newBONode(0)
 86 | 
 87 |     n1 := newBONode(1)
 88 |     n1.rank = 0
 89 | 
 90 |     n2 := newBONode(2)
 91 |     n2.rank = 0
 92 | 
 93 |     n3 := newBONode(3)
 94 |     n3.rank = 3
 95 | 
 96 |     n4 := newBONode(4)
 97 |     n4.rank = 1
 98 | 
 99 |     root.adopt(n1)
100 |     root.adopt(n2)
101 |     root.adopt(n3)
102 |     root.adopt(n4)
103 | 
104 |     if !rankOrdered(root) {t.Errorf("not rank ordered")}
105 | }
106 | 
107 | 
108 | func Test_smallestrank_1(t *testing.T) {
109 |     root := newBONode(0)
110 | 
111 |     n1 := newBONode(1)
112 |     n1.rank = 1
113 | 
114 |     n2 := newBONode(2)
115 |     n2.rank = 1
116 | 
117 |     n3 := newBONode(3)
118 |     n3.rank = 5
119 | 
120 |     n4 := newBONode(4)
121 |     n4.rank = 6
122 | 
123 |     root.adopt(n1)
124 |     root.adopt(n2)
125 |     root.adopt(n3)
126 |     root.adopt(n4)
127 | 
128 |     m1, m2 := root.getSmallestRankChildren()
129 | 
130 |     if (m1 != n1) && (m1 != n2) {t.Errorf("false smallest rank children")}
131 |     if (m1 != n2) && (m2 != n2) {t.Errorf("false smallest rank children.")}
132 | 
133 | }
134 | 
135 | 
136 | func Test_insert_1(t *testing.T) {
137 |     heap := NewBOHeap()
138 | 
139 |     n1 := newBONode(1)
140 |     n2 := newBONode(2)
141 | 
142 |     heap.insert(n1)
143 |     heap.insert(n2)
144 | 
145 |     if heap.root != n1 {t.Errorf("wrong root.")}
146 |     if !isChild(heap.root, n2) {t.Errorf("n2 not a child of root.")}
147 | 
148 |     if n1.children_head != n2 {t.Errorf("relationship error.")}
149 |     if n2.parent != heap.root {t.Errorf("relationship error.")}
150 | }
151 | 
152 | 
153 | func Test_insert_2(t *testing.T) {
154 |     heap := NewBOHeap()
155 | 
156 |     n1 := newBONode(1)
157 |     n2 := newBONode(2)
158 |     n3 := newBONode(3)
159 |     n4 := newBONode(4)
160 | 
161 |     heap.insert(n1)
162 |     heap.insert(n2)
163 |     heap.insert(n3)
164 |     heap.insert(n4)
165 | 
166 |     if heap.root != n1 {t.Errorf("wrong root.")}
167 |     if !isChild(n2, n3) {t.Errorf("relationship error.")}
168 |     if !isChild(n2, n4) {t.Errorf("relationship error.")}
169 | 
170 |     if n2.parent != n1 {t.Errorf("relationship error.")}
171 |     if n3.parent != n2 {t.Errorf("relationship error.")}
172 |     if n4.parent != n2 {t.Errorf("relationship error.")}
173 | }
174 | 
175 | 
176 | func Test_pop_1(t *testing.T) {
177 |     heap := NewBOHeap()
178 | 
179 |     heap.Insert(1)
180 |     heap.Insert(2)
181 |     heap.Insert(3)
182 |     heap.Insert(4)
183 | 
184 |     if heap.Pop() != 1 {t.Errorf("wrong pop value")}
185 | }
186 | 
187 | 
188 | func Test_rankorder_1 (t *testing.T) {
189 |     const SIZE = 30
190 | 
191 |     heap := NewBOHeap()
192 |     arr := interval(0, SIZE)
193 |     insert_mult(heap, arr)
194 | 
195 |     for i:=0; i<SIZE; i++ {
196 |         heap.Pop()
197 |         if !rankOrdered(heap.root) {t.Errorf("not rank ordered")}
198 |     }
199 | }
200 | 
201 | 
202 | func Test_heapsort_1(t *testing.T) {
203 |     heap := NewBOHeap()
204 | 
205 |     for i:=30; i>=0; i-- {
206 |         heap.Insert(i)
207 |     }
208 | 
209 |     for i:=0; i<=30; i++ {
210 |         pval := heap.Pop()
211 |         if pval != i {t.Errorf("expected %d, got %d", i, pval)}
212 |     }
213 | }
214 | 
215 | 
216 | func Test_heapsort_missing_1(t *testing.T) {
217 |     const SIZE = 25
218 |     rand.Seed(1)
219 | 
220 |     nums := interval(0, SIZE)
221 |     nums = shuffle(nums)
222 | 
223 |     heap := NewBOHeap()
224 | 
225 |     for _, elem := range nums {
226 |         heap.Insert(elem)
227 |     }
228 | 
229 |     for i:=0; i<5; i++ {
230 |         heap.Pop()
231 |     }
232 | 
233 |     if !isChild_int(heap.root, 6) {t.Errorf("relationship error.")}
234 | }
235 | 
236 | 
237 | func Test_insert_shuffle(t *testing.T) {
238 |     const SIZE = 25
239 |     rand.Seed(1)
240 | 
241 |     nums := interval(0, SIZE)
242 |     nums = shuffle(nums)
243 | 
244 |     heap := NewBOHeap()
245 | 
246 |     for _, elem := range nums {
247 |         heap.Insert(elem)
248 |     }
249 | 
250 | }
251 | 
252 | 
253 | func Test_heapsort_shuffle_1(t *testing.T) {
254 |     const SIZE = 25
255 |     rand.Seed(1)
256 | 
257 |     nums := interval(0, SIZE)
258 |     nums = shuffle(nums)
259 | 
260 |     heap := NewBOHeap()
261 | 
262 |     for _, elem := range nums {
263 |         heap.Insert(elem)
264 |     }
265 | 
266 |     for i:=0; i<SIZE; i++ {
267 |         pval := heap.Pop()
268 |         if pval != i {t.Errorf("expected %d, got %d", i, pval)}
269 |     }
270 | }
271 | 
272 | 
273 | func Test_insert_binomial(t *testing.T) {
274 |     heap := NewBOHeap()
275 | 
276 |     n0 := newBONode(0)
277 | 
278 |     n1 := newBONode(1)
279 |     n1.rank = 3
280 | 
281 |     n2 := newBONode(2)
282 |     n2.rank = 4
283 | 
284 |     n3 := newBONode(3)
285 |     n3.rank = 5
286 | 
287 |     n4 := newBONode(4)
288 |     n4.rank = 6
289 | 
290 |     catalyst := newBONode(100)
291 |     catalyst.rank = 3
292 | 
293 |     heap.insert(n0)
294 |     heap.insert(n1)
295 |     heap.insert(n2)
296 |     heap.insert(n3)
297 |     heap.insert(n4)
298 |     heap.insert(catalyst)
299 | 
300 |     if n1.rank != 7 {t.Errorf("rank error.")}
301 |     if catalyst.parent != n1 {t.Errorf("relationship error.")}
302 | 
303 | }
304 | 
305 | 
306 | func Test_merge_1(t *testing.T) {
307 |     const (
308 |         SIZE1 = 10
309 |         SIZE2 = SIZE1 * 2
310 |     )
311 | 
312 |     h1 := NewBOHeap()
313 |     h2 := NewBOHeap()
314 | 
315 |     insert_mult(h1, interval(0, SIZE1))
316 |     insert_mult(h2, interval(SIZE1, SIZE2))
317 | 
318 |     h1.Merge(h2)
319 | 
320 |     if h1.size != SIZE2 {t.Errorf("size error, expected %d, got %d", SIZE2, h1.size)}
321 | 
322 |     for i:=0; i<SIZE2; i++ {
323 |         pval := h1.Pop()
324 |         if pval != i {t.Errorf("expected %d, got %d", i, pval)}
325 |     }
326 | }
327 | 
328 | 
329 | func Test_merge_shuffle(t *testing.T) {
330 |     const (
331 |         SIZE1 = 1000
332 |         SIZE2 = SIZE1 * 2
333 |     )
334 | 
335 |     h1 := NewBOHeap()
336 |     h2 := NewBOHeap()
337 | 
338 |     s1 := interval(0, SIZE1)
339 |     s1 = shuffle(s1)
340 |     insert_mult(h1, s1)
341 | 
342 |     s2 := interval(SIZE1, SIZE2)
343 |     s2 = shuffle(s2)
344 |     insert_mult(h2, s2)
345 | 
346 |     h1.Merge(h2)
347 | 
348 |     if h1.size != SIZE2 {t.Errorf("size error, expected %d, got %d", SIZE2, h1.size)}
349 | 
350 |     for i:=0; i<SIZE2; i++ {
351 |         pval := h1.Pop()
352 |         if pval != i {t.Errorf("expected %d, got %d", i, pval)}
353 |     }
354 | }
355 | 
356 | 
357 | // ====== Helpers ======
358 | func interval(start int, end int) []int {
359 |     // [start, end)
360 |     slice := make([]int, 0, end-start)
361 | 
362 |     for i:=start; i<end; i++ {
363 |         slice = append(slice, i)
364 |     }
365 |     return slice
366 | }
367 | 
368 | func insert_mult(bq* BOHeap, values []int) {
369 |     for _, elem := range values {
370 |         bq.Insert(elem)
371 |     }
372 | }
373 | 
374 | 
375 | func shuffle(slice []int) []int {
376 |     shuffled := make([]int, len(slice), len(slice))
377 |     copy(shuffled, slice)
378 | 
379 |     for i:=0; i<len(shuffled); i++ {
380 |         index := rand.Intn(len(shuffled)-i)
381 |         index += i
382 | 
383 |         // swap i'th and index'th element
384 |         tmp := shuffled[i]
385 |         shuffled[i] = shuffled[index]
386 |         shuffled[index] = tmp
387 |     }
388 |     return shuffled
389 | }
390 | 
391 | 
392 | func isChild(parent *BONode, canditate *BONode) bool {
393 |     child := parent.children_head
394 |     for child != nil {
395 |         if child == canditate {
396 |             return true
397 |         }
398 |         child = child.rightsibling
399 |     }
400 |     return false
401 | }
402 | 
403 | 
404 | func isChild_int(parent *BONode, value int) bool {
405 |     child := parent.children_head
406 |     for child != nil {
407 |         if child.value == value {
408 |             return true
409 |         }
410 |         child = child.rightsibling
411 |     }
412 |     return false
413 | }
414 | 
415 | 
416 | func rankOrdered(parent *BONode) bool {
417 |     if parent == nil || !parent.hasChildren() || parent.children_head.rightsibling == nil {
418 |         // no children or 1 child.
419 |         return true
420 |     }
421 | 
422 |     prev := parent.children_head
423 |     next := parent.children_head.rightsibling
424 | 
425 |     for next != nil {
426 |         if prev.rank > next.rank {
427 |             return false
428 |         }
429 |         prev = next
430 |         next = next.rightsibling
431 |     }
432 |     return true
433 | }


--------------------------------------------------------------------------------
/bonode.go:
--------------------------------------------------------------------------------
  1 | package BrodalOkasakiHeap
  2 | import "fmt"
  3 | 
  4 | 
  5 | /*
  6 | This is the structure that denotes a single node of the Brodal-Okasaki heap.
  7 | 
  8 | I liberally added new fields to this struct. The original description does not need that much information per node.
  9 |  */
 10 | type BONode struct {
 11 |     // This is the value that a node has.
 12 |     value			int
 13 | 
 14 |     // Subqueue mechanism implements "data-structure-bootstrapping". While merging, children_head field is cleared
 15 |     // and moved to subqueue_head.
 16 |     subqueue_head	*BONode
 17 | 
 18 |     // Children of a node is held in a doubly-linked-list fashion. The parent has a reference to the head of the list.
 19 |     children_head	*BONode
 20 | 
 21 |     // Every children has a reference to her parent. Leftsibling is the previous, rightsibling is the next element.
 22 |     parent 			*BONode
 23 |     rightsibling	*BONode
 24 |     leftsibling		*BONode
 25 | 
 26 |     // Rank of a node.
 27 |     rank			int
 28 | }
 29 | 
 30 | 
 31 | /*
 32 | Create a new node.
 33 |  */
 34 | func newBONode(value int) *BONode {
 35 |     return &BONode {
 36 |         value: value,
 37 | 
 38 |         subqueue_head: nil,
 39 |         children_head: nil,
 40 | 
 41 |         parent: nil,
 42 |         rightsibling: nil,
 43 |         leftsibling: nil,
 44 | 
 45 |         rank: 0,
 46 |     }
 47 | }
 48 | 
 49 | 
 50 | /*
 51 | A node adopts the other node, being its parent.
 52 | Here we adjust the necessary fields accordingly to make this connection.
 53 |  */
 54 | func (bon* BONode) adopt(other *BONode) {
 55 | 
 56 |     // Parent relations
 57 |     other.parent = bon
 58 | 
 59 |     // Sibling relations
 60 |     bon.putNodeAmongChildren(other)
 61 | }
 62 | 
 63 | 
 64 | /*
 65 | Inserting the newly-parented node into the doubly-linked-list of children.
 66 |  */
 67 | func (bon* BONode) putNodeAmongChildren(other *BONode) {
 68 |     var prev *BONode
 69 |     var next *BONode
 70 | 
 71 |     prev = nil
 72 |     next = bon.children_head
 73 | 
 74 |     for next != nil && other.rank > next.rank {
 75 |         prev = next
 76 |         next = next.rightsibling
 77 |     }
 78 | 
 79 |     if prev == nil && next == nil {
 80 |         // This means children list is empty.
 81 |         bon.children_head = other
 82 |     } else if prev == nil && next != nil {
 83 |         // We get to this state when there are only 1 child on the list, and our new node has smaller rank than
 84 |         // the existing one.
 85 |         bon.children_head = other
 86 | 
 87 |         other.rightsibling = next
 88 |         next.leftsibling = other
 89 |     } else if prev != nil && next == nil {
 90 |         // We got to the end of the list, our new node has the highest rank.
 91 |         prev.rightsibling = other
 92 |         other.leftsibling = prev
 93 |     } else if prev != nil && next != nil {
 94 |         // Standard case, we hit somewhere in between the list.
 95 |         prev.rightsibling = other
 96 |         next.leftsibling = other
 97 | 
 98 |         other.leftsibling = prev
 99 |         other.rightsibling = next
100 |     }
101 | }
102 | 
103 | 
104 | /*
105 | A node goes rogue, severing its ties with its parent and siblings.
106 | */
107 | func (bon* BONode) rogue() {
108 |     if bon.parent == nil {
109 |         return  // If no parent, this node hasn't been adopted yet. No need to go through.
110 |     }
111 |     parent := bon.parent
112 | 
113 |     if parent.children_head == bon {
114 |         parent.children_head = bon.rightsibling  // This can set "nil" to parent.children_head
115 |     } else {
116 |         bon.leftsibling.rightsibling = bon.rightsibling
117 |         if bon.rightsibling != nil {
118 |             bon.rightsibling.leftsibling = bon.leftsibling
119 |         }
120 |     }
121 |     bon.parent = nil
122 |     bon.leftsibling = nil
123 |     bon.rightsibling = nil
124 | }
125 | 
126 | 
127 | /*
128 | Essentially same functionality as "rogue", but this one works for subqueued children.
129 |  */
130 | func (bon* BONode) rogue_subqueue() {
131 |     if bon.parent == nil {
132 |         return
133 |     }
134 |     parent := bon.parent
135 | 
136 |     if parent.subqueue_head == bon {
137 |         parent.subqueue_head = bon.rightsibling
138 |     } else {
139 |         bon.leftsibling.rightsibling = bon.rightsibling
140 |         if bon.rightsibling != nil {
141 |             bon.rightsibling.leftsibling = bon.leftsibling
142 |         }
143 |     }
144 |     bon.parent = nil
145 |     bon.leftsibling = nil
146 |     bon.rightsibling = nil
147 | 
148 | }
149 | 
150 | /*
151 | Essential skew-linking procedure is described for "BOHeap.insert_skew"
152 | 
153 | This function simply performs the linking procedure given the nodes.
154 |  */
155 | func skewLink(firnode *BONode, secnode *BONode, newnode *BONode) *BONode {
156 |     if firnode == nil || secnode == nil {
157 |         // This happens when the parent has less than 2 children.
158 |         return newnode
159 |     } else if firnode.rank != secnode.rank {
160 |         // Inequal ranks. We are going to just simply insert the new node.
161 |         return newnode
162 |     } else {
163 |         // Here is the skew linking.
164 |         // Get the minimum valued node among those 3, make her parent and the other two her children.
165 |         currRank := firnode.rank  // We can also use secnode to get this value.
166 | 
167 |         minnode, node1, node2 := min_of_3(firnode, secnode, newnode)
168 | 
169 |         minnode.rogue()
170 |         node1.rogue()
171 |         node2.rogue()
172 | 
173 |         minnode.adopt(node1)
174 |         minnode.adopt(node2)
175 |         minnode.rank = currRank + 1
176 | 
177 |         return minnode
178 |     }
179 | }
180 | 
181 | 
182 | /*
183 | This function links the two nodes according to binomilal heap linking procedure. The description is given for
184 | "BOHeap.insert_binomial"
185 | 
186 | The returning node is assumed to be rogue for code-simplifying reasons.
187 |  */
188 | func simpleLink(existingnode *BONode, newnode *BONode) *BONode {
189 |     existingnode.rogue()
190 | 
191 |     if existingnode.value < newnode.value {
192 |         existingnode.adopt(newnode)
193 |         existingnode.rank += 1
194 |         return existingnode
195 |     } else {
196 |         newnode.adopt(existingnode)
197 |         newnode.rank += 1
198 |         return newnode
199 |     }
200 | }
201 | 
202 | 
203 | /*
204 | Return the minimum-valued child.
205 |  */
206 | func (bon* BONode) getMinChild() *BONode {
207 |     if !bon.hasChildren() {
208 |         return nil
209 |     }
210 | 
211 |     minchild := bon.children_head
212 |     checknode := minchild.rightsibling
213 | 
214 |     for checknode != nil {
215 |         if checknode.value < minchild.value {
216 |             minchild = checknode
217 |         }
218 |         checknode = checknode.rightsibling
219 |     }
220 | 
221 |     return minchild
222 | }
223 | 
224 | 
225 | func (bon* BONode) hasChildren() bool {
226 |     return bon.children_head != nil
227 | }
228 | 
229 | 
230 | /*
231 | Return the smallest ranked 2 children of a given node.
232 | 
233 | The doubly-linked-list of children is rank ordered, so we don't need to do any searching.
234 |  */
235 | func (bon* BONode) getSmallestRankChildren() (*BONode, *BONode) {
236 |     if bon.children_head == nil {
237 |         return nil, nil
238 |     } else {
239 |         return bon.children_head, bon.children_head.rightsibling
240 |     }
241 | }
242 | 
243 | 
244 | /*
245 | Simple.
246 |  */
247 | func (bon* BONode) getSameRankChild(rank int) *BONode {
248 |     child := bon.children_head
249 |     for child != nil {
250 |         if child.rank == rank {
251 |             return child
252 |         }
253 |         child = child.rightsibling
254 |     }
255 |     return nil
256 | }
257 | 
258 | 
259 | /*
260 | Print a single node.
261 |  */
262 | func (bon* BONode) print_singular() {
263 |     /*
264 |         fmt.Printf("Node: %d, Rank: %d, address: %p left: %p right: %p parent: %p child_head: %p",
265 |             bon.value, bon.rank, bon, bon.leftsibling, bon.rightsibling ,bon.parent, bon.children_head)
266 |     */
267 |     var sqstr string
268 | 
269 |     if bon.subqueue_head != nil {
270 |         sqstr = "has subqueue"
271 |     } else {
272 |         sqstr = ""
273 |     }
274 | 
275 |     str := fmt.Sprintf("Node: %d, Rank: %d %s", bon.value, bon.rank, sqstr)
276 |     fmt.Print(str)
277 | }
278 | 
279 | 
280 | /*
281 | Print a node and all of its children recursively in depth-first fashion.
282 |  */
283 | func (bon* BONode) print_recursive(level int) {
284 |     printSpace(level)
285 |     bon.print_singular()
286 |     fmt.Println()
287 | 
288 |     children := bon.children_head
289 |     for children != nil {
290 |         children.print_recursive(level+4)
291 |         children = children.rightsibling
292 |     }
293 | }
294 | 
295 | 
296 | /*
297 | Minimum of 3 algorithm.
298 | 
299 | First returning value is the minimum, other two are the rest.
300 | 
301 | I decided to return all of them in a sense, because if we don't do that, we need to do additional work back in the
302 | calling function to determine which one was the smallest.
303 |  */
304 | func min_of_3(n1 *BONode, n2 *BONode, n3 *BONode) (*BONode, *BONode, *BONode) {
305 |     if n1.value < n2.value {
306 |         if n1.value < n3.value {
307 |             return n1, n2, n3
308 |         } else {  // n3 <= n1 <= n2
309 |             return n3, n1, n2
310 |         }
311 |     } else {  // n2 <= n1 ? n3
312 |         if n2.value < n3.value {
313 |             return n2, n1, n3
314 |         } else {  // n3 <= n2 <= n1
315 |             return n3, n1, n2
316 |         }
317 |     }
318 | }
319 | 
320 | 
321 | /*
322 | Put subqueue elements to a container, and return them.
323 | I use this to iterate over elements. We can't trust traversing the children-linked-list because the operations that
324 | may be performed can modify this list, hence we may not traverse all of the elements.
325 |  */
326 | func (bon* BONode) subqueueIterator() []*BONode {
327 |     itercont := make([]*BONode, 0, 8)
328 | 
329 |     child := bon.subqueue_head
330 |     for child != nil {
331 |         itercont = append(itercont, child)
332 |         child = child.rightsibling
333 |     }
334 |     return itercont
335 | }
336 | 
337 | 
338 | /*
339 | Read subqueueIterator. Same thing for the children.
340 |  */
341 | func (bon* BONode) childrenIterator() []*BONode {
342 |     itercont := make([]*BONode, 0, 8)
343 | 
344 |     child := bon.children_head
345 |     for child != nil {
346 |         itercont = append(itercont, child)
347 |         child = child.rightsibling
348 |     }
349 |     return itercont
350 | }
351 | 
352 | 
353 | func (bon* BONode) moveChildrenToSubqueue() {
354 |     // There is a bug here. Care to find out?
355 | 
356 |     bon.subqueue_head = bon.children_head
357 |     bon.children_head = nil
358 | }
359 | 
360 | 
361 | // ====== Container helpers ======
362 | func appendList(container []*BONode, head *BONode) []*BONode {
363 |     node := head
364 |     newc := container
365 |     for node != nil {
366 |         newc = append(newc, node)
367 |         node = node.rightsibling
368 |     }
369 |     return newc
370 | }
371 | 


--------------------------------------------------------------------------------