algorithms 0.6.1-java
Sign up to get free protection for your applications and to get access to all the features.
- data/CHANGELOG.markdown +193 -0
- data/Gemfile +9 -0
- data/Manifest +51 -0
- data/README.markdown +84 -0
- data/Rakefile +18 -0
- data/algorithms.gemspec +23 -0
- data/benchmarks/deque.rb +17 -0
- data/benchmarks/sorts.rb +34 -0
- data/benchmarks/treemaps.rb +51 -0
- data/ext/algorithms/string/extconf.rb +4 -0
- data/ext/algorithms/string/string.c +68 -0
- data/ext/containers/bst/bst.c +247 -0
- data/ext/containers/bst/extconf.rb +4 -0
- data/ext/containers/deque/deque.c +247 -0
- data/ext/containers/deque/extconf.rb +4 -0
- data/ext/containers/rbtree_map/extconf.rb +4 -0
- data/ext/containers/rbtree_map/rbtree.c +498 -0
- data/ext/containers/splaytree_map/extconf.rb +4 -0
- data/ext/containers/splaytree_map/splaytree.c +419 -0
- data/lib/algorithms.rb +65 -0
- data/lib/algorithms/search.rb +84 -0
- data/lib/algorithms/sort.rb +238 -0
- data/lib/algorithms/string.rb +9 -0
- data/lib/containers/deque.rb +171 -0
- data/lib/containers/heap.rb +502 -0
- data/lib/containers/kd_tree.rb +110 -0
- data/lib/containers/priority_queue.rb +113 -0
- data/lib/containers/queue.rb +68 -0
- data/lib/containers/rb_tree_map.rb +398 -0
- data/lib/containers/splay_tree_map.rb +269 -0
- data/lib/containers/stack.rb +67 -0
- data/lib/containers/suffix_array.rb +68 -0
- data/lib/containers/trie.rb +182 -0
- data/spec/bst_gc_mark_spec.rb +25 -0
- data/spec/bst_spec.rb +25 -0
- data/spec/deque_gc_mark_spec.rb +18 -0
- data/spec/deque_spec.rb +108 -0
- data/spec/heap_spec.rb +131 -0
- data/spec/kd_expected_out.txt +10000 -0
- data/spec/kd_test_in.txt +10000 -0
- data/spec/kd_tree_spec.rb +34 -0
- data/spec/map_gc_mark_spec.rb +29 -0
- data/spec/priority_queue_spec.rb +75 -0
- data/spec/queue_spec.rb +61 -0
- data/spec/rb_tree_map_spec.rb +123 -0
- data/spec/search_spec.rb +28 -0
- data/spec/sort_spec.rb +28 -0
- data/spec/splay_tree_map_spec.rb +106 -0
- data/spec/stack_spec.rb +60 -0
- data/spec/string_spec.rb +15 -0
- data/spec/suffix_array_spec.rb +40 -0
- data/spec/trie_spec.rb +59 -0
- metadata +106 -0
@@ -0,0 +1,502 @@
|
|
1
|
+
=begin rdoc
|
2
|
+
A Heap is a container that satisfies the heap property that nodes are always smaller in
|
3
|
+
value than their parent node.
|
4
|
+
|
5
|
+
The Containers::Heap class is flexible and upon initialization, takes an optional block
|
6
|
+
that determines how the items are ordered. Two versions that are included are the
|
7
|
+
Containers::MaxHeap and Containers::MinHeap that return the largest and smallest items on
|
8
|
+
each invocation, respectively.
|
9
|
+
|
10
|
+
This library implements a Fibonacci heap, which allows O(1) complexity for most methods.
|
11
|
+
=end
|
12
|
+
class Containers::Heap
|
13
|
+
include Enumerable
|
14
|
+
|
15
|
+
# call-seq:
|
16
|
+
# size -> int
|
17
|
+
#
|
18
|
+
# Return the number of elements in the heap.
|
19
|
+
def size
|
20
|
+
@size
|
21
|
+
end
|
22
|
+
alias_method :length, :size
|
23
|
+
|
24
|
+
# call-seq:
|
25
|
+
# Heap.new(optional_array) { |x, y| optional_comparison_fn } -> new_heap
|
26
|
+
#
|
27
|
+
# If an optional array is passed, the entries in the array are inserted into the heap with
|
28
|
+
# equal key and value fields. Also, an optional block can be passed to define the function
|
29
|
+
# that maintains heap property. For example, a min-heap can be created with:
|
30
|
+
#
|
31
|
+
# minheap = Heap.new { |x, y| (x <=> y) == -1 }
|
32
|
+
# minheap.push(6)
|
33
|
+
# minheap.push(10)
|
34
|
+
# minheap.pop #=> 6
|
35
|
+
#
|
36
|
+
# Thus, smaller elements will be parent nodes. The heap defaults to a min-heap if no block
|
37
|
+
# is given.
|
38
|
+
def initialize(ary=[], &block)
|
39
|
+
@compare_fn = block || lambda { |x, y| (x <=> y) == -1 }
|
40
|
+
@next = nil
|
41
|
+
@size = 0
|
42
|
+
@stored = {}
|
43
|
+
|
44
|
+
ary.each { |n| push(n) } unless ary.empty?
|
45
|
+
end
|
46
|
+
|
47
|
+
# call-seq:
|
48
|
+
# push(key, value) -> value
|
49
|
+
# push(value) -> value
|
50
|
+
#
|
51
|
+
# Inserts an item with a given key into the heap. If only one parameter is given,
|
52
|
+
# the key is set to the value.
|
53
|
+
#
|
54
|
+
# Complexity: O(1)
|
55
|
+
#
|
56
|
+
# heap = MinHeap.new
|
57
|
+
# heap.push(1, "Cat")
|
58
|
+
# heap.push(2)
|
59
|
+
# heap.pop #=> "Cat"
|
60
|
+
# heap.pop #=> 2
|
61
|
+
def push(key, value=key)
|
62
|
+
raise ArgumentError, "Heap keys must not be nil." unless key
|
63
|
+
node = Node.new(key, value)
|
64
|
+
# Add new node to the left of the @next node
|
65
|
+
if @next
|
66
|
+
node.right = @next
|
67
|
+
node.left = @next.left
|
68
|
+
node.left.right = node
|
69
|
+
@next.left = node
|
70
|
+
if @compare_fn[key, @next.key]
|
71
|
+
@next = node
|
72
|
+
end
|
73
|
+
else
|
74
|
+
@next = node
|
75
|
+
end
|
76
|
+
@size += 1
|
77
|
+
|
78
|
+
arr = []
|
79
|
+
w = @next.right
|
80
|
+
until w == @next do
|
81
|
+
arr << w.value
|
82
|
+
w = w.right
|
83
|
+
end
|
84
|
+
arr << @next.value
|
85
|
+
@stored[key] ||= []
|
86
|
+
@stored[key] << node
|
87
|
+
value
|
88
|
+
end
|
89
|
+
alias_method :<<, :push
|
90
|
+
|
91
|
+
# call-seq:
|
92
|
+
# has_key?(key) -> true or false
|
93
|
+
#
|
94
|
+
# Returns true if heap contains the key.
|
95
|
+
#
|
96
|
+
# Complexity: O(1)
|
97
|
+
#
|
98
|
+
# minheap = MinHeap.new([1, 2])
|
99
|
+
# minheap.has_key?(2) #=> true
|
100
|
+
# minheap.has_key?(4) #=> false
|
101
|
+
def has_key?(key)
|
102
|
+
@stored[key] && !@stored[key].empty? ? true : false
|
103
|
+
end
|
104
|
+
|
105
|
+
# call-seq:
|
106
|
+
# next -> value
|
107
|
+
# next -> nil
|
108
|
+
#
|
109
|
+
# Returns the value of the next item in heap order, but does not remove it.
|
110
|
+
#
|
111
|
+
# Complexity: O(1)
|
112
|
+
#
|
113
|
+
# minheap = MinHeap.new([1, 2])
|
114
|
+
# minheap.next #=> 1
|
115
|
+
# minheap.size #=> 2
|
116
|
+
def next
|
117
|
+
@next && @next.value
|
118
|
+
end
|
119
|
+
|
120
|
+
# call-seq:
|
121
|
+
# next_key -> key
|
122
|
+
# next_key -> nil
|
123
|
+
#
|
124
|
+
# Returns the key associated with the next item in heap order, but does not remove the value.
|
125
|
+
#
|
126
|
+
# Complexity: O(1)
|
127
|
+
#
|
128
|
+
# minheap = MinHeap.new
|
129
|
+
# minheap.push(1, :a)
|
130
|
+
# minheap.next_key #=> 1
|
131
|
+
#
|
132
|
+
def next_key
|
133
|
+
@next && @next.key
|
134
|
+
end
|
135
|
+
|
136
|
+
# call-seq:
|
137
|
+
# clear -> nil
|
138
|
+
#
|
139
|
+
# Removes all elements from the heap, destructively.
|
140
|
+
#
|
141
|
+
# Complexity: O(1)
|
142
|
+
#
|
143
|
+
def clear
|
144
|
+
@next = nil
|
145
|
+
@size = 0
|
146
|
+
@stored = {}
|
147
|
+
nil
|
148
|
+
end
|
149
|
+
|
150
|
+
# call-seq:
|
151
|
+
# empty? -> true or false
|
152
|
+
#
|
153
|
+
# Returns true if the heap is empty, false otherwise.
|
154
|
+
def empty?
|
155
|
+
@next.nil?
|
156
|
+
end
|
157
|
+
|
158
|
+
# call-seq:
|
159
|
+
# merge!(otherheap) -> merged_heap
|
160
|
+
#
|
161
|
+
# Does a shallow merge of all the nodes in the other heap.
|
162
|
+
#
|
163
|
+
# Complexity: O(1)
|
164
|
+
#
|
165
|
+
# heap = MinHeap.new([5, 6, 7, 8])
|
166
|
+
# otherheap = MinHeap.new([1, 2, 3, 4])
|
167
|
+
# heap.merge!(otherheap)
|
168
|
+
# heap.size #=> 8
|
169
|
+
# heap.pop #=> 1
|
170
|
+
def merge!(otherheap)
|
171
|
+
raise ArgumentError, "Trying to merge a heap with something not a heap" unless otherheap.kind_of? Containers::Heap
|
172
|
+
other_root = otherheap.instance_variable_get("@next")
|
173
|
+
if other_root
|
174
|
+
@stored = @stored.merge(otherheap.instance_variable_get("@stored")) { |key, a, b| (a << b).flatten }
|
175
|
+
# Insert othernode's @next node to the left of current @next
|
176
|
+
@next.left.right = other_root
|
177
|
+
ol = other_root.left
|
178
|
+
other_root.left = @next.left
|
179
|
+
ol.right = @next
|
180
|
+
@next.left = ol
|
181
|
+
|
182
|
+
@next = other_root if @compare_fn[other_root.key, @next.key]
|
183
|
+
end
|
184
|
+
@size += otherheap.size
|
185
|
+
end
|
186
|
+
|
187
|
+
# call-seq:
|
188
|
+
# pop -> value
|
189
|
+
# pop -> nil
|
190
|
+
#
|
191
|
+
# Returns the value of the next item in heap order and removes it from the heap.
|
192
|
+
#
|
193
|
+
# Complexity: O(1)
|
194
|
+
#
|
195
|
+
# minheap = MinHeap.new([1, 2])
|
196
|
+
# minheap.pop #=> 1
|
197
|
+
# minheap.size #=> 1
|
198
|
+
def pop
|
199
|
+
return nil unless @next
|
200
|
+
popped = @next
|
201
|
+
if @size == 1
|
202
|
+
clear
|
203
|
+
return popped.value
|
204
|
+
end
|
205
|
+
# Merge the popped's children into root node
|
206
|
+
if @next.child
|
207
|
+
@next.child.parent = nil
|
208
|
+
|
209
|
+
# get rid of parent
|
210
|
+
sibling = @next.child.right
|
211
|
+
until sibling == @next.child
|
212
|
+
sibling.parent = nil
|
213
|
+
sibling = sibling.right
|
214
|
+
end
|
215
|
+
|
216
|
+
# Merge the children into the root. If @next is the only root node, make its child the @next node
|
217
|
+
if @next.right == @next
|
218
|
+
@next = @next.child
|
219
|
+
else
|
220
|
+
next_left, next_right = @next.left, @next.right
|
221
|
+
current_child = @next.child
|
222
|
+
@next.right.left = current_child
|
223
|
+
@next.left.right = current_child.right
|
224
|
+
current_child.right.left = next_left
|
225
|
+
current_child.right = next_right
|
226
|
+
@next = @next.right
|
227
|
+
end
|
228
|
+
else
|
229
|
+
@next.left.right = @next.right
|
230
|
+
@next.right.left = @next.left
|
231
|
+
@next = @next.right
|
232
|
+
end
|
233
|
+
consolidate
|
234
|
+
|
235
|
+
unless @stored[popped.key].delete(popped)
|
236
|
+
raise "Couldn't delete node from stored nodes hash"
|
237
|
+
end
|
238
|
+
@size -= 1
|
239
|
+
|
240
|
+
popped.value
|
241
|
+
end
|
242
|
+
alias_method :next!, :pop
|
243
|
+
|
244
|
+
# call-seq:
|
245
|
+
# change_key(key, new_key) -> [new_key, value]
|
246
|
+
# change_key(key, new_key) -> nil
|
247
|
+
#
|
248
|
+
# Changes the key from one to another. Doing so must not violate the heap property or
|
249
|
+
# an exception will be raised. If the key is found, an array containing the new key and
|
250
|
+
# value pair is returned, otherwise nil is returned.
|
251
|
+
#
|
252
|
+
# In the case of duplicate keys, an arbitrary key is changed. This will be investigated
|
253
|
+
# more in the future.
|
254
|
+
#
|
255
|
+
# Complexity: amortized O(1)
|
256
|
+
#
|
257
|
+
# minheap = MinHeap.new([1, 2])
|
258
|
+
# minheap.change_key(2, 3) #=> raise error since we can't increase the value in a min-heap
|
259
|
+
# minheap.change_key(2, 0) #=> [0, 2]
|
260
|
+
# minheap.pop #=> 2
|
261
|
+
# minheap.pop #=> 1
|
262
|
+
def change_key(key, new_key, delete=false)
|
263
|
+
return if @stored[key].nil? || @stored[key].empty? || (key == new_key)
|
264
|
+
|
265
|
+
# Must maintain heap property
|
266
|
+
raise "Changing this key would not maintain heap property!" unless (delete || @compare_fn[new_key, key])
|
267
|
+
node = @stored[key].shift
|
268
|
+
if node
|
269
|
+
node.key = new_key
|
270
|
+
@stored[new_key] ||= []
|
271
|
+
@stored[new_key] << node
|
272
|
+
parent = node.parent
|
273
|
+
if parent
|
274
|
+
# if heap property is violated
|
275
|
+
if delete || @compare_fn[new_key, parent.key]
|
276
|
+
cut(node, parent)
|
277
|
+
cascading_cut(parent)
|
278
|
+
end
|
279
|
+
end
|
280
|
+
if delete || @compare_fn[node.key, @next.key]
|
281
|
+
@next = node
|
282
|
+
end
|
283
|
+
return [node.key, node.value]
|
284
|
+
end
|
285
|
+
nil
|
286
|
+
end
|
287
|
+
|
288
|
+
# call-seq:
|
289
|
+
# delete(key) -> value
|
290
|
+
# delete(key) -> nil
|
291
|
+
#
|
292
|
+
# Deletes the item with associated key and returns it. nil is returned if the key
|
293
|
+
# is not found. In the case of nodes with duplicate keys, an arbitrary one is deleted.
|
294
|
+
#
|
295
|
+
# Complexity: amortized O(log n)
|
296
|
+
#
|
297
|
+
# minheap = MinHeap.new([1, 2])
|
298
|
+
# minheap.delete(1) #=> 1
|
299
|
+
# minheap.size #=> 1
|
300
|
+
def delete(key)
|
301
|
+
pop if change_key(key, nil, true)
|
302
|
+
end
|
303
|
+
|
304
|
+
# Node class used internally
|
305
|
+
class Node # :nodoc:
|
306
|
+
attr_accessor :parent, :child, :left, :right, :key, :value, :degree, :marked
|
307
|
+
|
308
|
+
def initialize(key, value)
|
309
|
+
@key = key
|
310
|
+
@value = value
|
311
|
+
@degree = 0
|
312
|
+
@marked = false
|
313
|
+
@right = self
|
314
|
+
@left = self
|
315
|
+
end
|
316
|
+
|
317
|
+
def marked?
|
318
|
+
@marked == true
|
319
|
+
end
|
320
|
+
|
321
|
+
end
|
322
|
+
|
323
|
+
# make node a child of a parent node
|
324
|
+
def link_nodes(child, parent)
|
325
|
+
# link the child's siblings
|
326
|
+
child.left.right = child.right
|
327
|
+
child.right.left = child.left
|
328
|
+
|
329
|
+
child.parent = parent
|
330
|
+
|
331
|
+
# if parent doesn't have children, make new child its only child
|
332
|
+
if parent.child.nil?
|
333
|
+
parent.child = child.right = child.left = child
|
334
|
+
else # otherwise insert new child into parent's children list
|
335
|
+
current_child = parent.child
|
336
|
+
child.left = current_child
|
337
|
+
child.right = current_child.right
|
338
|
+
current_child.right.left = child
|
339
|
+
current_child.right = child
|
340
|
+
end
|
341
|
+
parent.degree += 1
|
342
|
+
child.marked = false
|
343
|
+
end
|
344
|
+
private :link_nodes
|
345
|
+
|
346
|
+
# Makes sure the structure does not contain nodes in the root list with equal degrees
|
347
|
+
def consolidate
|
348
|
+
roots = []
|
349
|
+
root = @next
|
350
|
+
min = root
|
351
|
+
# find the nodes in the list
|
352
|
+
loop do
|
353
|
+
roots << root
|
354
|
+
root = root.right
|
355
|
+
break if root == @next
|
356
|
+
end
|
357
|
+
degrees = []
|
358
|
+
roots.each do |root|
|
359
|
+
min = root if @compare_fn[root.key, min.key]
|
360
|
+
# check if we need to merge
|
361
|
+
if degrees[root.degree].nil? # no other node with the same degree
|
362
|
+
degrees[root.degree] = root
|
363
|
+
next
|
364
|
+
else # there is another node with the same degree, consolidate them
|
365
|
+
degree = root.degree
|
366
|
+
until degrees[degree].nil? do
|
367
|
+
other_root_with_degree = degrees[degree]
|
368
|
+
if @compare_fn[root.key, other_root_with_degree.key] # determine which node is the parent, which one is the child
|
369
|
+
smaller, larger = root, other_root_with_degree
|
370
|
+
else
|
371
|
+
smaller, larger = other_root_with_degree, root
|
372
|
+
end
|
373
|
+
link_nodes(larger, smaller)
|
374
|
+
degrees[degree] = nil
|
375
|
+
root = smaller
|
376
|
+
degree += 1
|
377
|
+
end
|
378
|
+
degrees[degree] = root
|
379
|
+
min = root if min.key == root.key # this fixes a bug with duplicate keys not being in the right order
|
380
|
+
end
|
381
|
+
end
|
382
|
+
@next = min
|
383
|
+
end
|
384
|
+
private :consolidate
|
385
|
+
|
386
|
+
def cascading_cut(node)
|
387
|
+
p = node.parent
|
388
|
+
if p
|
389
|
+
if node.marked?
|
390
|
+
cut(node, p)
|
391
|
+
cascading_cut(p)
|
392
|
+
else
|
393
|
+
node.marked = true
|
394
|
+
end
|
395
|
+
end
|
396
|
+
end
|
397
|
+
private :cascading_cut
|
398
|
+
|
399
|
+
# remove x from y's children and add x to the root list
|
400
|
+
def cut(x, y)
|
401
|
+
x.left.right = x.right
|
402
|
+
x.right.left = x.left
|
403
|
+
y.degree -= 1
|
404
|
+
if (y.degree == 0)
|
405
|
+
y.child = nil
|
406
|
+
elsif (y.child == x)
|
407
|
+
y.child = x.right
|
408
|
+
end
|
409
|
+
x.right = @next
|
410
|
+
x.left = @next.left
|
411
|
+
@next.left = x
|
412
|
+
x.left.right = x
|
413
|
+
x.parent = nil
|
414
|
+
x.marked = false
|
415
|
+
end
|
416
|
+
private :cut
|
417
|
+
|
418
|
+
end
|
419
|
+
|
420
|
+
# A MaxHeap is a heap where the items are returned in descending order of key value.
|
421
|
+
class Containers::MaxHeap < Containers::Heap
|
422
|
+
|
423
|
+
# call-seq:
|
424
|
+
# MaxHeap.new(ary) -> new_heap
|
425
|
+
#
|
426
|
+
# Creates a new MaxHeap with an optional array parameter of items to insert into the heap.
|
427
|
+
# A MaxHeap is created by calling Heap.new { |x, y| (x <=> y) == 1 }, so this is a convenience class.
|
428
|
+
#
|
429
|
+
# maxheap = MaxHeap.new([1, 2, 3, 4])
|
430
|
+
# maxheap.pop #=> 4
|
431
|
+
# maxheap.pop #=> 3
|
432
|
+
def initialize(ary=[])
|
433
|
+
super(ary) { |x, y| (x <=> y) == 1 }
|
434
|
+
end
|
435
|
+
|
436
|
+
# call-seq:
|
437
|
+
# max -> value
|
438
|
+
# max -> nil
|
439
|
+
#
|
440
|
+
# Returns the item with the largest key, but does not remove it from the heap.
|
441
|
+
#
|
442
|
+
# maxheap = MaxHeap.new([1, 2, 3, 4])
|
443
|
+
# maxheap.max #=> 4
|
444
|
+
def max
|
445
|
+
self.next
|
446
|
+
end
|
447
|
+
|
448
|
+
# call-seq:
|
449
|
+
# max! -> value
|
450
|
+
# max! -> nil
|
451
|
+
#
|
452
|
+
# Returns the item with the largest key and removes it from the heap.
|
453
|
+
#
|
454
|
+
# maxheap = MaxHeap.new([1, 2, 3, 4])
|
455
|
+
# maxheap.max! #=> 4
|
456
|
+
# maxheap.size #=> 3
|
457
|
+
def max!
|
458
|
+
self.pop
|
459
|
+
end
|
460
|
+
end
|
461
|
+
|
462
|
+
# A MinHeap is a heap where the items are returned in ascending order of key value.
|
463
|
+
class Containers::MinHeap < Containers::Heap
|
464
|
+
|
465
|
+
# call-seq:
|
466
|
+
# MinHeap.new(ary) -> new_heap
|
467
|
+
#
|
468
|
+
# Creates a new MinHeap with an optional array parameter of items to insert into the heap.
|
469
|
+
# A MinHeap is created by calling Heap.new { |x, y| (x <=> y) == -1 }, so this is a convenience class.
|
470
|
+
#
|
471
|
+
# minheap = MinHeap.new([1, 2, 3, 4])
|
472
|
+
# minheap.pop #=> 1
|
473
|
+
# minheap.pop #=> 2
|
474
|
+
def initialize(ary=[])
|
475
|
+
super(ary) { |x, y| (x <=> y) == -1 }
|
476
|
+
end
|
477
|
+
|
478
|
+
# call-seq:
|
479
|
+
# min -> value
|
480
|
+
# min -> nil
|
481
|
+
#
|
482
|
+
# Returns the item with the smallest key, but does not remove it from the heap.
|
483
|
+
#
|
484
|
+
# minheap = MinHeap.new([1, 2, 3, 4])
|
485
|
+
# minheap.min #=> 1
|
486
|
+
def min
|
487
|
+
self.next
|
488
|
+
end
|
489
|
+
|
490
|
+
# call-seq:
|
491
|
+
# min! -> value
|
492
|
+
# min! -> nil
|
493
|
+
#
|
494
|
+
# Returns the item with the smallest key and removes it from the heap.
|
495
|
+
#
|
496
|
+
# minheap = MinHeap.new([1, 2, 3, 4])
|
497
|
+
# minheap.min! #=> 1
|
498
|
+
# minheap.size #=> 3
|
499
|
+
def min!
|
500
|
+
self.pop
|
501
|
+
end
|
502
|
+
end
|