fibonacci_heap 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d5517c8d52edce5c8e372cd14457efe425f6a422fec8a02585221df8fa2f25a
-  data.tar.gz: 3a6e50318184cfa233fe840e91806a209379dccc5dde84f7739b8921e3d73712
+  metadata.gz: 68aaf5872d76003db0e72b8e732fb657cf02da219739fb152739bc943cd19ef5
+  data.tar.gz: 9ac530f4499a41aca100ad0b7f22f802f161f8b5c51b0f5137cc181301a9b19a
 SHA512:
-  metadata.gz: 6a93299721795318e9cd8529e899d710a32fb2bfde25b825d31a37a1318e78afa62bece5d26d4010a3a1cfa8c6a6420c5754c47e14cc56f02f1a40545911c37a
-  data.tar.gz: 4790e9bbf353167b8a018e9e2a6b463a4159b5e5b0d434895e850466c495f55df7e92fc4744c2c25120c6474d4219382b428f905f82e56051d053db59710bd74
+  metadata.gz: 1bd78f32dabd4ac5763f2c6452c4be430e077cbf0f10290a7792cf97599439d7eeb369c6aed42cc3e473657025583b4eb98f868ad45cc6a76aa444a2f6228d32
+  data.tar.gz: 0532212274f8f18902664c608b0bf3fe2a933eec70e84249b5f0f891795ccafb3dcb0ccdccdbd75dba6e412cc1146d82476999a09b9bf32d7d22f5dbecb70d5e

data/README.md

@@ -2,7 +2,7 @@
 
 A Ruby implementation of the [Fibonacci heap](https://en.wikipedia.org/wiki/Fibonacci_heap) data structure ideal for use as a priority queue with [Dijkstra's algorithm](https://en.wikipedia.org/wiki/Dijkstra's_algorithm#Using_a_priority_queue).
 
-**Current version:** 0.1.0  
+**Current version:** 0.2.0  
 **Supported Ruby versions:** 1.8.7, 1.9.2, 1.9.3, 2.0, 2.1, 2.2, 2.3
 
 ## Installation
@@ -45,6 +45,7 @@ heap.pop
   * [`#pop`](#fibonacciheapheappop)
   * [`#decrease_key(x, k)`](#fibonacciheapheapdecrease_keyx-k)
   * [`#delete(x)`](#fibonacciheapheapdeletex)
+  * [`#clear`](#fibonacciheapheapclear)
 * [`FibonacciHeap::Node`](#fibonacciheapnode)
   * [`new(key[, value])`](#fibonacciheapnodenewkey-value)
   * [`key`](#fibonacciheapnodekey)
@@ -66,7 +67,7 @@ heap = FibonacciHeap::Heap.new
 #=> #<FibonacciHeap n=0 min=nil>
 ```
 
-Return a new, empty `FibonacciHeap::Heap` instance.
+Return a new, empty [`FibonacciHeap::Heap`](#fibonacciheapheap) instance.
 
 #### `FibonacciHeap::Heap#n`
 
@@ -105,7 +106,7 @@ heap.min
 #=> #<FibonacciHeap::Node key=1 ...>
 ```
 
-Return the smallest `FibonacciHeap::Node` node in the heap as determined by the node's `key`.
+Return the smallest [`FibonacciHeap::Node`](#fibonacciheapnode) node in the heap as determined by the node's `key`.
 
 Will return `nil` if the heap is empty.
 
@@ -119,7 +120,7 @@ heap.insert(node)
 heap.insert(bar, 100)
 ```
 
-Insert the given `FibonacciHeap::Node` `x` into the heap with an optional key `k`.
+Insert the given [`FibonacciHeap::Node`](#fibonacciheapnode) `x` into the heap with an optional key `k`.
 
 Defaults to using `x`'s existing `key` for `k`.
 
@@ -140,7 +141,7 @@ heap3.pop
 #=> #<FibonacciHeap::Node key=2 value="bar" ...>
 ```
 
-Unite the given `FibonacciHeap::Heap` `h2` with this one in a new `FibonacciHeap::Heap`.
+Unite the given [`FibonacciHeap::Heap`](#fibonacciheapheap) `h2` with this one in a new [`FibonacciHeap::Heap`](#fibonacciheapheap).
 
 As this will mutate both collections of rooted trees, attempting to use either the original heap or `h2` after `concat` has undefined behaviour.
 
@@ -153,7 +154,7 @@ heap.pop
 #=> #<FibonacciHeap::Node key=1 value="foo" ...>
 ```
 
-Remove and return the smallest `FibonacciHeap::Node` from the heap.
+Remove and return the smallest [`FibonacciHeap::Node`](#fibonacciheapnode) from the heap.
 
 #### `FibonacciHeap::Heap#decrease_key(x, k)`
 
@@ -165,11 +166,11 @@ heap.decrease_key(node, 0)
 #=> #<FibonacciHeap::Node key=0 value="foo">
 ```
 
-Decrease the key of the given `FibonacciHeap::Node` `x` to the new given key `k`.
+Decrease the key of the given [`FibonacciHeap::Node`](#fibonacciheapnode) `x` to the new given key `k`.
 
 The node must already be inserted into the heap and the key must be comparable.
 
-Raises a `FibonacciHeap::InvalidKeyError` if the new key is greater than the current key.
+Raises a [`FibonacciHeap::InvalidKeyError`](#fibonacciheapinvalidkeyerror) if the new key is greater than the current key.
 
 #### `FibonacciHeap::Heap#delete(x)`
 
@@ -181,13 +182,24 @@ heap.delete(node)
 #=> #<FibonacciHeap::Node key=-Infinity value="foo">
 ```
 
-Deletes the given `FibonacciHeap::Node` `x` from the heap.
+Deletes the given [`FibonacciHeap::Node`](#fibonacciheapnode) `x` from the heap.
 
 The node must already be inserted into the heap.
 
+#### `FibonacciHeap::Heap#clear`
+
+```ruby
+heap = FibonacciHeap::Heap.new
+heap.insert(FibonacciHeap::Node.new(1, 'foo'))
+heap.clear
+#=> #<FibonacciHeap::Heap n=0 min=nil>
+```
+
+Remove all nodes from the heap, emptying it.
+
 ### `FibonacciHeap::Node`
 
-A single node in a `FibonacciHeap::Heap`.
+A single node in a [`FibonacciHeap::Heap`](#fibonacciheapheap).
 
 Used internally to form both min-heap ordered trees and circular, doubly linked lists.
 
@@ -200,7 +212,7 @@ node = FibonacciHeap::Node.new(1, 'foo')
 #=> #<FibonacciHeap::Node key=1 value="foo">
 ```
 
-Return a new `FibonacciHeap::Node` with the given key `key` and an optional value `value`.
+Return a new [`FibonacciHeap::Node`](#fibonacciheapnode) with the given key `key` and an optional value `value`.
 
 Defaults to using the `key` as the value.
 
@@ -226,7 +238,7 @@ Return the current value of the node.
 
 ### `FibonacciHeap::InvalidKeyError`
 
-Raised when attempting to decrease a key but the key is greater than the current key.
+Raised when attempting to decrease a key but the new key is greater than the current key.
 
 ## References
 

data/lib/fibonacci_heap/circular_doubly_linked_list.rb

@@ -66,7 +66,7 @@ module FibonacciHeap
       list.sentinel.prev.next = sentinel.next
       sentinel.next.prev = list.sentinel.prev
       sentinel.next = list.sentinel.next
-      list.sentinel.prev = sentinel
+      list.sentinel.next.prev = sentinel
     end
 
     # Yield each element of this list.

data/lib/fibonacci_heap/heap.rb

@@ -26,6 +26,7 @@ module FibonacciHeap
       @min = nil
     end
 
+    # Return whether or not this heap is empty.
     def empty?
       n.zero?
     end
@@ -65,15 +66,16 @@ module FibonacciHeap
     # Unite the given Fibonacci heap into this one, returning a new heap.
     #
     # Note that uniting the heaps will mutate their root lists, destroying them
-    # both so attempting to use them has undefined behaviour.
+    # both so attempting to use them after uniting has undefined behaviour.
     #
     # Corresponds to the Fib-Heap-Union(H1, H2) procedure.
     def concat(h2)
       h = self.class.new
       h.min = min
 
-      h.root_list = root_list
-      h.root_list.concat(h2.root_list)
+      h.root_list = CircularDoublyLinkedList.new
+      h.root_list.concat(root_list) unless empty?
+      h.root_list.concat(h2.root_list) unless h2.empty?
 
       h.min = h2.min if !min || (h2.min && h2.min.key < min.key)
 
@@ -90,34 +92,30 @@ module FibonacciHeap
     # Corresponds to the Fib-Heap-Extract-Min(H) procedure.
     def pop
       z = min
+      return unless z
 
-      if z
-        # For each child x of z
-        z.child_list.each do |x|
-
-          # Add x to the root list of H
-          root_list.insert(x)
-          x.p = nil
-        end
-
-        # Remove z from the root list of H
-        root_list.delete(z)
+      # For each child x of z
+      z.child_list.each do |x|
+        # Add x to the root list of H
+        root_list.insert(x)
+        x.p = nil
+      end
 
-        # Is z the only node on the root list?
-        if z.right == z.left
-          # Empty the heap
-          self.min = nil
-          self.root_list = CircularDoublyLinkedList.new
-        else
-          # Set min to another root
-          self.min = root_list.head
+      # Remove z from the root list of H
+      root_list.delete(z)
 
-          consolidate
-        end
+      # Was z the only node on the root list?
+      if z.right == z.left
+        self.min = nil
+      else
+        # Set min to another root
+        self.min = root_list.head
 
-        self.n -= 1
+        consolidate
       end
 
+      self.n -= 1
+
       z
     end
 
@@ -156,6 +154,15 @@ module FibonacciHeap
       pop
     end
 
+    # Remove all nodes from the heap, emptying it.
+    def clear
+      self.root_list = CircularDoublyLinkedList.new
+      self.min = nil
+      self.n = 0
+
+      self
+    end
+
     def inspect
       %(#<#{self.class} n=#{n} min=#{min.inspect}>)
     end
@@ -164,7 +171,9 @@ module FibonacciHeap
 
     # Corresponds to the Consolidate(H) procedure.
     def consolidate
-      degrees = []
+      # let A[0..D(H.n)] be a new array
+      max_degree = (Math.log(n) / Math.log(2)).floor
+      degrees = Array.new(max_degree + 1)
 
       root_list.each do |w|
         x = w
@@ -186,8 +195,8 @@ module FibonacciHeap
       end
 
       # Empty the root list
-      self.min = nil
       self.root_list = CircularDoublyLinkedList.new
+      self.min = nil
 
       # Reconstruct the root list from the array A
       degrees.each do |root|
@@ -207,6 +216,7 @@ module FibonacciHeap
     def link(y, x)
       # remove y from the root list of H
       root_list.delete(y)
+
       # make y a child of x, incrementing x.degree
       x.child_list.insert(y)
       x.degree += 1

data/lib/fibonacci_heap/node.rb

@@ -1,5 +1,3 @@
-require 'fibonacci_heap/circular_doubly_linked_list'
-
 module FibonacciHeap
   # A single node in a Fibonacci Heap.
   #

data/spec/fibonacci_heap/circular_doubly_linked_list_spec.rb

@@ -239,7 +239,7 @@ module FibonacciHeap
         expect(list).to contain_exactly(node, node2, node3, node4)
       end
 
-      it 'combines an empty list a non-empty one' do
+      it 'combines an empty list with a non-empty one' do
         list = described_class.new
         list2 = described_class.new
         node = Node.new('foo')
@@ -252,6 +252,18 @@ module FibonacciHeap
         expect(list).to contain_exactly(node, node2)
       end
 
+      it 'removes any reference to the other list sentinel' do
+        list = described_class.new
+        list2 = described_class.new
+        node = Node.new('foo')
+        list2.insert(node)
+
+        list.concat(list2)
+
+        expect(node.next).to eq(list.sentinel)
+        expect(node.prev).to eq(list.sentinel)
+      end
+
       it 'combines a non-empty list with an empty one' do
         list = described_class.new
         list2 = described_class.new

data/spec/fibonacci_heap/heap_spec.rb

@@ -23,6 +23,42 @@ module FibonacciHeap
       end
     end
 
+    describe '#clear' do
+      it 'empties the heap' do
+        heap = described_class.new
+        heap.insert(Node.new(1, 'foo'))
+
+        heap.clear
+
+        expect(heap).to be_empty
+      end
+
+      it 'clears the min node' do
+        heap = described_class.new
+        heap.insert(Node.new(1, 'foo'))
+
+        heap.clear
+
+        expect(heap.min).to be_nil
+      end
+
+      it 'empties the root list' do
+        heap = described_class.new
+        heap.insert(Node.new(1, 'foo'))
+
+        heap.clear
+
+        expect(heap.root_list).to be_empty
+      end
+
+      it 'returns the emptied heap' do
+        heap = described_class.new
+        heap.insert(Node.new(1, 'foo'))
+
+        expect(heap.clear).to eq(heap)
+      end
+    end
+
     describe '#n' do
       it 'returns the size of the heap' do
         heap = described_class.new
@@ -224,6 +260,28 @@ module FibonacciHeap
         expect(root.left).not_to eq(root.right)
         expect(root2.left).not_to eq(root2.right)
       end
+
+      it 'removes the last node in the heap' do
+        heap = described_class.new
+        root = Node.new('foo')
+        heap.insert(root)
+
+        expect(heap.pop).to eq(root)
+        expect(heap.pop).to be_nil
+        expect(heap.min).to be_nil
+      end
+
+      it 'can have nodes inserted after being emptied' do
+        heap = described_class.new
+        root = Node.new('foo')
+        heap.insert(root)
+        heap.pop
+        root2 = Node.new('bar')
+        heap.insert(root2)
+
+        expect(heap.pop).to eq(root2)
+        expect(heap.pop).to be_nil
+      end
     end
 
     describe '#decrease_key' do
@@ -292,7 +350,7 @@ module FibonacciHeap
     end
 
     describe '#concat' do
-      it 'unite the given heap with this one' do
+      it 'unites the given heap with this one' do
         heap = described_class.new
         node = Node.new(1)
         heap2 = described_class.new
@@ -306,6 +364,39 @@ module FibonacciHeap
         expect(heap3.pop).to eq(node2)
         expect(heap3.pop).to be_nil
       end
+
+      it 'unites an empty heap with a non-empty heap' do
+        heap = described_class.new
+        heap2 = described_class.new
+        node = Node.new(1)
+        heap2.insert(node)
+
+        heap3 = heap.concat(heap2)
+
+        expect(heap3.pop).to eq(node)
+        expect(heap3.pop).to be_nil
+      end
+
+      it 'unites a non-empty heap with an empty heap' do
+        heap = described_class.new
+        heap2 = described_class.new
+        node = Node.new(1)
+        heap.insert(node)
+
+        heap3 = heap.concat(heap2)
+
+        expect(heap3.pop).to eq(node)
+        expect(heap3.pop).to be_nil
+      end
+
+      it 'unites two empty heaps' do
+        heap = described_class.new
+        heap2 = described_class.new
+
+        heap3 = heap.concat(heap2)
+
+        expect(heap3.pop).to be_nil
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fibonacci_heap
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Paul Mucur
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-13 00:00:00.000000000 Z
+date: 2018-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec