fibonacci_heap 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9d5517c8d52edce5c8e372cd14457efe425f6a422fec8a02585221df8fa2f25a
+  data.tar.gz: 3a6e50318184cfa233fe840e91806a209379dccc5dde84f7739b8921e3d73712
+SHA512:
+  metadata.gz: 6a93299721795318e9cd8529e899d710a32fb2bfde25b825d31a37a1318e78afa62bece5d26d4010a3a1cfa8c6a6420c5754c47e14cc56f02f1a40545911c37a
+  data.tar.gz: 4790e9bbf353167b8a018e9e2a6b463a4159b5e5b0d434895e850466c495f55df7e92fc4744c2c25120c6474d4219382b428f905f82e56051d053db59710bd74

data/LICENSE

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

data/README.md

@@ -0,0 +1,239 @@
+# Fibonacci Heap [![Build Status](https://travis-ci.org/mudge/fibonacci_heap.svg?branch=master)](https://travis-ci.org/mudge/fibonacci_heap)
+
+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  
+**Supported Ruby versions:** 1.8.7, 1.9.2, 1.9.3, 2.0, 2.1, 2.2, 2.3
+
+## Installation
+
+```
+gem install fibonacci_heap -v '~> 0.1'
+```
+
+Or, in your `Gemfile`:
+
+```ruby
+gem 'fibonacci_heap', '~> 0.1'
+```
+
+## Usage
+
+```ruby
+require 'fibonacci_heap'
+
+heap = FibonacciHeap::Heap.new
+foo = FibonacciHeap::Node.new(1, 'foo')
+bar = FibonacciHeap::Node.new(0, 'bar')
+heap.insert(foo)
+heap.insert(bar)
+heap.pop
+#=> #<FibonacciHeap::Node key=0 value="bar">
+```
+
+## API Documentation
+
+* [`FibonacciHeap::Heap`](#fibonacciheapheap)
+  * [`.new`](#fibonacciheapheapnew)
+  * [`#n`](#fibonacciheapheapn)
+  * [`#size`](#fibonacciheapheapn)
+  * [`#length`](#fibonacciheapheapn)
+  * [`#empty?`](#fibonacciheapheapempty)
+  * [`#min`](#fibonacciheapheapmin)
+  * [`#insert(x[, k])`](#fibonacciheapheapinsertx-k)
+  * [`#concat(h2)`](#fibonacciheapheapconcath2)
+  * [`#pop`](#fibonacciheapheappop)
+  * [`#decrease_key(x, k)`](#fibonacciheapheapdecrease_keyx-k)
+  * [`#delete(x)`](#fibonacciheapheapdeletex)
+* [`FibonacciHeap::Node`](#fibonacciheapnode)
+  * [`new(key[, value])`](#fibonacciheapnodenewkey-value)
+  * [`key`](#fibonacciheapnodekey)
+  * [`value`](#fibonacciheapnodevalue)
+* [`FibonacciHeap::InvalidKeyError`](#fibonacciheapinvalidkeyerror)
+
+### `FibonacciHeap::Heap`
+
+A Fibonacci Heap data structure.
+
+A "mergeable heap" that supports several operations that run in
+constant amortized time. Structured as a collection of rooted trees
+that are min-heap ordered.
+
+#### `FibonacciHeap::Heap.new`
+
+```ruby
+heap = FibonacciHeap::Heap.new
+#=> #<FibonacciHeap n=0 min=nil>
+```
+
+Return a new, empty `FibonacciHeap::Heap` instance.
+
+#### `FibonacciHeap::Heap#n`
+
+```ruby
+heap = FibonacciHeap::Heap.new
+heap.insert(FibonacciHeap::Node.new('foo'))
+heap.n
+#=> 1
+heap.size
+#=> 1
+heap.length
+#=> 1
+```
+
+Return the current number of nodes in the heap.
+
+Aliased to `size` and `length`.
+
+#### `FibonacciHeap::Heap#empty?`
+
+```ruby
+heap = FibonacciHeap::Heap.new
+heap.empty?
+#=> true
+```
+
+Returns whether or not the heap is empty.
+
+#### `FibonacciHeap::Heap#min`
+
+```ruby
+heap = FibonacciHeap::Heap.new
+heap.insert(FibonacciHeap::Node.new(1))
+heap.insert(FibonacciHeap::Node.new(2))
+heap.min
+#=> #<FibonacciHeap::Node key=1 ...>
+```
+
+Return the smallest `FibonacciHeap::Node` node in the heap as determined by the node's `key`.
+
+Will return `nil` if the heap is empty.
+
+#### `FibonacciHeap::Heap#insert(x[, k])`
+
+```ruby
+heap = FibonacciHeap::Heap.new
+node = FibonacciHeap::Node.new(1, 'foo')
+node2 = FibonacciHeap::Node.new(0, 'bar')
+heap.insert(node)
+heap.insert(bar, 100)
+```
+
+Insert the given `FibonacciHeap::Node` `x` into the heap with an optional key `k`.
+
+Defaults to using `x`'s existing `key` for `k`.
+
+#### `FibonacciHeap::Heap#concat(h2)`
+
+```ruby
+heap = FibonacciHeap::Heap.new
+heap.insert(FibonacciHeap::Node.new(1, 'foo'))
+heap2 = FibonacciHeap::Heap.new
+heap2.insert(FibonacciHeap::Node.new(2, 'bar'))
+
+heap3 = heap.concat(heap2)
+#=> #<FibonacciHeap::Heap n=2 min=#<FibonacciHeap::Node key=1 value="foo">>
+
+heap3.pop
+#=> #<FibonacciHeap::Node key=1 value="foo" ...>
+heap3.pop
+#=> #<FibonacciHeap::Node key=2 value="bar" ...>
+```
+
+Unite the given `FibonacciHeap::Heap` `h2` with this one in a new `FibonacciHeap::Heap`.
+
+As this will mutate both collections of rooted trees, attempting to use either the original heap or `h2` after `concat` has undefined behaviour.
+
+#### `FibonacciHeap::Heap#pop`
+
+```ruby
+heap = FibonacciHeap::Heap.new
+heap.insert(FibonacciHeap::Node.new(1, 'foo'))
+heap.pop
+#=> #<FibonacciHeap::Node key=1 value="foo" ...>
+```
+
+Remove and return the smallest `FibonacciHeap::Node` from the heap.
+
+#### `FibonacciHeap::Heap#decrease_key(x, k)`
+
+```ruby
+heap = FibonacciHeap::Heap.new
+node = FibonacciHeap::Node.new(1, 'foo')
+heap.insert(node)
+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`.
+
+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.
+
+#### `FibonacciHeap::Heap#delete(x)`
+
+```ruby
+heap = FibonacciHeap::Heap.new
+node = FibonacciHeap::Node.new(1, 'foo')
+heap.insert(node)
+heap.delete(node)
+#=> #<FibonacciHeap::Node key=-Infinity value="foo">
+```
+
+Deletes the given `FibonacciHeap::Node` `x` from the heap.
+
+The node must already be inserted into the heap.
+
+### `FibonacciHeap::Node`
+
+A single node in a `FibonacciHeap::Heap`.
+
+Used internally to form both min-heap ordered trees and circular, doubly linked lists.
+
+#### `FibonacciHeap::Node.new(key[, value])`
+
+```ruby
+node = FibonacciHeap::Node.new(1)
+#=> #<FibonacciHeap::Node key=1 value=1>
+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`.
+
+Defaults to using the `key` as the value.
+
+#### `FibonacciHeap::Node#key`
+
+```ruby
+node = FibonacciHeap::Node.new(1, 'foo')
+node.key
+#=> 1
+```
+
+Return the current key of the node.
+
+#### `FibonacciHeap::Node#value`
+
+```ruby
+node = FibonacciHeap::Node.new(1, 'foo')
+node.value
+#=> "foo"
+```
+
+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.
+
+## References
+
+* Cormen, T. H., Leiserson, C. E., Rivest, R. L. & Stein, C., [Introduction to Algorithms, Third Edition](https://mitpress.mit.edu/books/introduction-algorithms-third-edition).
+
+## License
+
+Copyright © 2018 Paul Mucur
+
+Distributed under the MIT License.

data/lib/fibonacci_heap.rb

@@ -0,0 +1,2 @@
+require 'fibonacci_heap/heap'
+require 'fibonacci_heap/node'

data/lib/fibonacci_heap/circular_doubly_linked_list.rb

@@ -0,0 +1,84 @@
+module FibonacciHeap
+  # A Circular Doubly Linked List data structure.
+  #
+  # An unsorted, linear, circular list with a sentinel to simplify
+  # boundary conditions.
+  class CircularDoublyLinkedList
+    include Enumerable
+
+    # A Sentinel node to simplify boundary conditions in the linked list.
+    class Sentinel
+      attr_accessor :next, :prev
+
+      def initialize
+        @next = self
+        @prev = self
+      end
+    end
+
+    # Return the special "sentinel" or Nil node for this list.
+    attr_accessor :sentinel
+
+    # Return a new, empty list.
+    def initialize
+      @sentinel = Sentinel.new
+    end
+
+    # Return the first element of the list or nil if it is empty.
+    def head
+      return if empty?
+
+      sentinel.next
+    end
+
+    # Return the last element of the list or nil if it is empty.
+    def tail
+      return if empty?
+
+      sentinel.prev
+    end
+
+    # Return whether or not the list is empty.
+    def empty?
+      sentinel.next == sentinel
+    end
+
+    # Insert a given node into the list.
+    #
+    # New nodes will be placed at the head of the list.
+    def insert(x)
+      x.next = sentinel.next
+      sentinel.next.prev = x
+      sentinel.next = x
+      x.prev = sentinel
+    end
+
+    # Remove a given node from the list.
+    #
+    # The node must already be in the list.
+    def delete(x)
+      x.prev.next = x.next
+      x.next.prev = x.prev
+    end
+
+    # Combine this list with another, destroying the given list.
+    def concat(list)
+      list.sentinel.prev.next = sentinel.next
+      sentinel.next.prev = list.sentinel.prev
+      sentinel.next = list.sentinel.next
+      list.sentinel.prev = sentinel
+    end
+
+    # Yield each element of this list.
+    def each
+      x = sentinel.next
+
+      while x != sentinel
+        current = x
+        x = x.next
+
+        yield current
+      end
+    end
+  end
+end

data/lib/fibonacci_heap/heap.rb

@@ -0,0 +1,239 @@
+require 'fibonacci_heap/circular_doubly_linked_list'
+
+module FibonacciHeap
+  InvalidKeyError = Class.new(StandardError)
+
+  # A Fibonacci Heap data structure.
+  #
+  # A "mergeable heap" that supports several operations that run in
+  # constant amortized time. Structured as a collection of rooted trees
+  # that are min-heap ordered.
+  class Heap
+    # Return the current number of nodes in the heap.
+    attr_accessor :n
+    alias size n
+    alias length n
+
+    # Return the smallest node in the heap.
+    attr_accessor :min
+
+    # Return the root list of the heap.
+    attr_accessor :root_list
+
+    # Return a new, empty Fibonacci heap.
+    def initialize
+      @n = 0
+      @min = nil
+    end
+
+    def empty?
+      n.zero?
+    end
+
+    # Insert a new node with an optional key into the heap.
+    #
+    # The node must be compatible with a FibonacciHeap::Node.
+    #
+    # Defaults to using the existing key of the node.
+    #
+    # Corresponds to the Fib-Heap-Insert(H, x) procedure.
+    def insert(x, k = x.key)
+      x.degree = 0
+      x.p = nil
+      x.child_list = CircularDoublyLinkedList.new
+      x.mark = false
+      x.key = k
+
+      if !min
+        # Create a root list for H containing just x
+        self.root_list = CircularDoublyLinkedList.new
+        root_list.insert(x)
+
+        self.min = x
+      else
+        # Insert x into H's root list
+        root_list.insert(x)
+
+        self.min = x if x.key < min.key
+      end
+
+      self.n += 1
+
+      x
+    end
+
+    # 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.
+    #
+    # 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.min = h2.min if !min || (h2.min && h2.min.key < min.key)
+
+      h.n = n + h2.n
+
+      h
+    end
+
+    # Remove and return the minimum node from the heap.
+    #
+    # After extracting the minimum node, the heap will consolidate its internal
+    # trees.
+    #
+    # Corresponds to the Fib-Heap-Extract-Min(H) procedure.
+    def pop
+      z = min
+
+      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)
+
+        # 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
+
+          consolidate
+        end
+
+        self.n -= 1
+      end
+
+      z
+    end
+
+    # Decrease the key of a given node to a new given key.
+    #
+    # The node must be compatible with a FibonacciHeap::Node and have been inserted
+    # in the heap already. The key must be comparable.
+    #
+    # Raises an InvalidKeyError if the new key is greater than the current key.
+    #
+    # Corresponds to the Fib-Heap-Decrease-Key(H, x, k) procedure.
+    def decrease_key(x, k)
+      raise InvalidKeyError, "new key #{k} is greater than current key #{x.key}" if k > x.key
+
+      x.key = k
+      y = x.p
+
+      if y && x.key < y.key
+        cut(x, y)
+        cascading_cut(y)
+      end
+
+      self.min = x if x.key < min.key
+
+      x
+    end
+
+    # Delete a node from the heap.
+    #
+    # The given node must be compatible with a FibonacciHeap::Node and have been
+    # inserted in the heap already.
+    #
+    # Corresponds to the Fib-Heap-Delete(H, x) procedure.
+    def delete(x)
+      decrease_key(x, -1.0 / 0.0)
+      pop
+    end
+
+    def inspect
+      %(#<#{self.class} n=#{n} min=#{min.inspect}>)
+    end
+
+    private
+
+    # Corresponds to the Consolidate(H) procedure.
+    def consolidate
+      degrees = []
+
+      root_list.each do |w|
+        x = w
+        d = x.degree
+
+        while degrees[d]
+          y = degrees[d]
+
+          x, y = y, x if x.key > y.key
+
+          link(y, x)
+
+          degrees[d] = nil
+
+          d += 1
+        end
+
+        degrees[d] = x
+      end
+
+      # Empty the root list
+      self.min = nil
+      self.root_list = CircularDoublyLinkedList.new
+
+      # Reconstruct the root list from the array A
+      degrees.each do |root|
+        next unless root
+
+        root_list.insert(root)
+
+        if !min
+          self.min = root
+        elsif root.key < min.key
+          self.min = root
+        end
+      end
+    end
+
+    # Corresponds to the Fib-Heap-Link(H, y, x) procedure.
+    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
+      y.p = x
+      y.mark = false
+    end
+
+    # Corresponds to the Cut(H, x, y) procedure.
+    def cut(x, y)
+      y.child_list.delete(x)
+      y.degree -= 1
+      root_list.insert(x)
+      x.p = nil
+      x.mark = false
+    end
+
+    # Corresponds to the Cascading-Cut(H, y) procedure.
+    def cascading_cut(y)
+      z = y.p
+      return unless z
+
+      if !y.mark
+        y.mark = true
+      else
+        cut(y, z)
+        cascading_cut(z)
+      end
+    end
+  end
+end

data/lib/fibonacci_heap/node.rb

@@ -0,0 +1,56 @@
+require 'fibonacci_heap/circular_doubly_linked_list'
+
+module FibonacciHeap
+  # A single node in a Fibonacci Heap.
+  #
+  # Contains a key and optional value that can be any arbitrary object.
+  # The key will be used to sort nodes so that the key of a node is greater
+  # than or equal to the key of its parent.
+  #
+  # Defaults to storing the key as the value.
+  class Node
+    # Return the key of the node.
+    attr_accessor :key
+
+    # Return the value of the node.
+    attr_accessor :value
+
+    # Return the node next to this one.
+    attr_accessor :next
+    alias right next
+
+    # Return the node previous to this one.
+    attr_accessor :prev
+    alias left prev
+
+    # Return the degree of this node.
+    attr_accessor :degree
+
+    # Return the parent of this node or nil if there is none.
+    attr_accessor :p
+
+    # Return whether this node is marked or not.
+    attr_accessor :mark
+
+    # Return the list of child nodes for this node.
+    attr_accessor :child_list
+
+    # Return a new node with the given key and optional value.
+    #
+    # The key and value can be any arbitrary object.
+    #
+    # The node's next and previous pointers will default to itself.
+    #
+    # Defaults the value to the key.
+    def initialize(key, value = key)
+      @key = key
+      @value = value
+      @next = self
+      @prev = self
+    end
+
+    def inspect
+      %(#<#{self.class} key=#{key.inspect} value=#{value.inspect}>)
+    end
+  end
+end

data/spec/fibonacci_heap/circular_doubly_linked_list_spec.rb

@@ -0,0 +1,269 @@
+require 'fibonacci_heap'
+
+module FibonacciHeap
+  RSpec.describe CircularDoublyLinkedList do
+    describe '#insert' do
+      it 'inserts the node into an empty list' do
+        list = described_class.new
+        node = Node.new('foo')
+
+        list.insert(node)
+
+        expect(list).to contain_exactly(node)
+      end
+
+      it 'sets next and prev on the only node in a list' do
+        list = described_class.new
+        node = Node.new('foo')
+
+        list.insert(node)
+
+        expect(node.next).to eq(list.sentinel)
+      end
+
+      it 'sets the node as the head of an empty list' do
+        list = described_class.new
+        node = Node.new('foo')
+
+        list.insert(node)
+
+        expect(list.head).to eq(node)
+      end
+
+      it 'sets the node as the tail of an empty list' do
+        list = described_class.new
+        node = Node.new('foo')
+
+        list.insert(node)
+
+        expect(list.tail).to eq(node)
+      end
+
+      it 'inserts the node into a non-empty list' do
+        list = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+
+        list.insert(node)
+        list.insert(node2)
+
+        expect(list).to contain_exactly(node, node2)
+      end
+
+      it 'sets the new node as the new head in a non-empty list' do
+        list = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+
+        list.insert(node)
+        list.insert(node2)
+
+        expect(list.head).to eq(node2)
+      end
+
+      it 'retains the existing tail in a non-empty list' do
+        list = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+
+        list.insert(node)
+        list.insert(node2)
+
+        expect(list.tail).to eq(node)
+      end
+
+      it 'inserts into a list with more than two nodes' do
+        list = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+        node3 = Node.new('baz')
+
+        list.insert(node)
+        list.insert(node2)
+        list.insert(node3)
+
+        expect(list).to contain_exactly(node, node2, node3)
+      end
+    end
+
+    describe '#delete' do
+      it 'removes the node from a list with only one node' do
+        list = described_class.new
+        node = Node.new('foo')
+
+        list.insert(node)
+        list.delete(node)
+
+        expect(list).to be_empty
+        expect(list.head).to be_nil
+        expect(list.tail).to be_nil
+        expect(list.to_a).to eq([])
+      end
+
+      it 'removes a node from the tail of a non-empty list' do
+        list = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+
+        list.insert(node)
+        list.insert(node2)
+        list.delete(node)
+
+        expect(list).to contain_exactly(node2)
+        expect(list.head).to eq(node2)
+        expect(list.tail).to eq(node2)
+      end
+
+      it 'removes a node from the middle of a non-empty list' do
+        list = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+        node3 = Node.new('baz')
+
+        list.insert(node)
+        list.insert(node2)
+        list.insert(node3)
+        list.delete(node2)
+
+        expect(list).to contain_exactly(node, node3)
+        expect(list.tail).to eq(node)
+        expect(list.head).to eq(node3)
+      end
+
+      it 'can remove all nodes from a non-empty list' do
+        list = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+        node3 = Node.new('baz')
+
+        list.insert(node)
+        list.insert(node2)
+        list.insert(node3)
+        list.delete(node2)
+        list.delete(node)
+        list.delete(node3)
+
+        expect(list).to be_empty
+        expect(list.head).to be_nil
+        expect(list.tail).to be_nil
+        expect(list.to_a).to eq([])
+      end
+
+      it 'does not alter the pointers of the deleted node' do
+        list = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+        node3 = Node.new('baz')
+
+        list.insert(node)
+        list.insert(node2)
+        list.insert(node3)
+        list.delete(node2)
+
+        expect(node2.next).to eq(node)
+        expect(node2.prev).to eq(node3)
+      end
+    end
+
+    describe '#empty?' do
+      it 'is true if there is no head node' do
+        list = described_class.new
+
+        expect(list).to be_empty
+      end
+    end
+
+    describe '#each' do
+      it 'yields nothing if the list is empty' do
+        list = described_class.new
+
+        expect { |b| list.each(&b) }.to yield_successive_args
+      end
+
+      it 'yields nodes' do
+        list = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+        list.insert(node)
+        list.insert(node2)
+
+        expect { |b| list.each(&b) }.to yield_successive_args(node2, node)
+      end
+
+      it 'yields more than two nodes' do
+        list = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+        node3 = Node.new('baz')
+        list.insert(node)
+        list.insert(node2)
+        list.insert(node3)
+
+        expect { |b| list.each(&b) }.to yield_successive_args(node3, node2, node)
+      end
+
+      it 'is not affected by changes to the node while iterating' do
+        list = described_class.new
+        list2 = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+        node3 = Node.new('baz')
+        list.insert(node)
+        list.insert(node2)
+        list2.insert(node3)
+
+        expect { |b|
+          list.each do |n|
+            list2.insert(n)
+            b.to_proc.call(n)
+          end
+        }.to yield_successive_args(node2, node)
+      end
+    end
+
+    describe '#concat' do
+      it 'combines two lists' do
+        list = described_class.new
+        list2 = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+        node3 = Node.new('baz')
+        node4 = Node.new('quux')
+        list.insert(node)
+        list.insert(node2)
+        list2.insert(node3)
+        list2.insert(node4)
+
+        list.concat(list2)
+
+        expect(list).to contain_exactly(node, node2, node3, node4)
+      end
+
+      it 'combines an empty list a non-empty one' do
+        list = described_class.new
+        list2 = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+        list2.insert(node)
+        list2.insert(node2)
+
+        list.concat(list2)
+
+        expect(list).to contain_exactly(node, node2)
+      end
+
+      it 'combines a non-empty list with an empty one' do
+        list = described_class.new
+        list2 = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+        list.insert(node)
+        list.insert(node2)
+
+        list.concat(list2)
+
+        expect(list).to contain_exactly(node, node2)
+      end
+    end
+  end
+end

data/spec/fibonacci_heap/heap_spec.rb

@@ -0,0 +1,311 @@
+require 'fibonacci_heap'
+
+module FibonacciHeap
+  RSpec.describe Heap do
+    it 'initializes n to 0' do
+      heap = described_class.new
+
+      expect(heap.n).to be_zero
+    end
+
+    it 'initializes min to nil' do
+      heap = described_class.new
+
+      expect(heap.min).to be_nil
+    end
+
+    describe '#inspect' do
+      it 'lists the size and min of the heap' do
+        heap = described_class.new
+        heap.insert(Node.new(1, 'foo'))
+
+        expect(heap.inspect).to eq('#<FibonacciHeap::Heap n=1 min=#<FibonacciHeap::Node key=1 value="foo">>')
+      end
+    end
+
+    describe '#n' do
+      it 'returns the size of the heap' do
+        heap = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('foo')
+
+        heap.insert(node)
+        heap.insert(node2)
+
+        expect(heap.n).to eq(2)
+      end
+
+      it 'is aliased to #size' do
+        heap = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('foo')
+
+        heap.insert(node)
+        heap.insert(node2)
+
+        expect(heap.size).to eq(2)
+      end
+
+      it 'is aliased to #length' do
+        heap = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('foo')
+
+        heap.insert(node)
+        heap.insert(node2)
+
+        expect(heap.length).to eq(2)
+      end
+    end
+
+    describe '#empty?' do
+      it 'returns true if the heap has no nodes' do
+        heap = described_class.new
+
+        expect(heap).to be_empty
+      end
+
+      it 'returns false if the heap has any nodes' do
+        heap = described_class.new
+        heap.insert(Node.new('foo'))
+
+        expect(heap).to_not be_empty
+      end
+    end
+
+    describe '#min' do
+      it 'returns the smallest node in the heap' do
+        heap = described_class.new
+        node = Node.new(10)
+        node2 = Node.new(0)
+
+        heap.insert(node)
+        heap.insert(node2)
+
+        expect(heap.min).to eq(node2)
+      end
+    end
+
+    describe '#insert' do
+      it 'adds the node to the root list' do
+        heap = described_class.new
+        node = Node.new('foo')
+
+        heap.insert(node)
+
+        expect(heap.root_list).to include(node)
+      end
+
+      it 'sets the node to min for an empty heap' do
+        heap = described_class.new
+        node = Node.new('foo')
+
+        heap.insert(node)
+
+        expect(heap.min).to eq(node)
+      end
+
+      it 'does not override min if a smaller node already exists' do
+        heap = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+
+        heap.insert(node2)
+        heap.insert(node)
+
+        expect(heap.min).to eq(node2)
+      end
+
+      it 'overrides min if the new node is smallest' do
+        heap = described_class.new
+        node = Node.new('foo')
+        node2 = Node.new('bar')
+
+        heap.insert(node)
+        heap.insert(node2)
+
+        expect(heap.min).to eq(node2)
+      end
+
+      it 'increases the number of nodes in the heap' do
+        heap = described_class.new
+        node = Node.new('foo')
+
+        heap.insert(node)
+
+        expect(heap.n).to eq(1)
+      end
+
+      it 'returns the inserted node' do
+        heap = described_class.new
+        node = Node.new('foo')
+
+        expect(heap.insert(node)).to eq(node)
+      end
+    end
+
+    describe '#pop' do
+      it 'returns nil if the heap is empty' do
+        heap = described_class.new
+
+        expect(heap.pop).to be_nil
+      end
+
+      it 'returns the smallest node' do
+        heap = described_class.new
+        node = Node.new(1)
+        node2 = Node.new(2)
+
+        heap.insert(node)
+        heap.insert(node2)
+
+        expect(heap.pop).to eq(node)
+      end
+
+      it 'works with more than two nodes' do
+        heap = described_class.new
+        node = Node.new(-1)
+        heap.insert(node)
+
+        25.times do |i|
+          heap.insert(Node.new(i))
+        end
+
+        expect(heap.pop).to eq(node)
+      end
+
+      it 'decreases the size of the heap' do
+        heap = described_class.new
+        node = Node.new(1)
+        node2 = Node.new(2)
+
+        heap.insert(node)
+        heap.insert(node2)
+        heap.pop
+
+        expect(heap.n).to eq(1)
+      end
+
+      it 'works when the min is in the middle of a tree' do
+        heap = described_class.new
+        node = Node.new(4)
+        node2 = Node.new(2)
+        node3 = Node.new(1)
+        node4 = Node.new(3)
+
+        heap.insert(node)
+        heap.insert(node2)
+        heap.insert(node3)
+        heap.insert(node4)
+
+        expect(heap.pop).to eq(node3)
+        expect(heap.pop).to eq(node2)
+        expect(heap.pop).to eq(node4)
+        expect(heap.pop).to eq(node)
+      end
+
+      it 'distinguishes a single root by linking together left and right' do
+        heap = described_class.new
+        root = Node.new('root')
+
+        heap.insert(root)
+
+        expect(root.left).to eq(root.right)
+      end
+
+      it 'does not link together left and right for multiple roots' do
+        heap = described_class.new
+        root = Node.new('foo')
+        root2 = Node.new('foo')
+
+        heap.insert(root)
+        heap.insert(root2)
+
+        expect(root.left).not_to eq(root.right)
+        expect(root2.left).not_to eq(root2.right)
+      end
+    end
+
+    describe '#decrease_key' do
+      it 'raises an error if the key is greater than the existing value' do
+        heap = described_class.new
+        node = Node.new(1)
+        heap.insert(node)
+
+        expect { heap.decrease_key(node, 4) }.to raise_error(InvalidKeyError)
+      end
+
+      it 'decreases the key of the node' do
+        heap = described_class.new
+        node = Node.new(2)
+        node2 = Node.new(3)
+        heap.insert(node)
+        heap.insert(node2)
+
+        heap.decrease_key(node2, 1)
+
+        expect(node2.key).to eq(1)
+      end
+
+      it 'updates the min of the heap' do
+        heap = described_class.new
+        node = Node.new(2)
+        node2 = Node.new(3)
+        heap.insert(node)
+        heap.insert(node2)
+
+        heap.decrease_key(node2, 1)
+
+        expect(heap.min).to eq(node2)
+      end
+
+      it 'returns the decreased node' do
+        heap = described_class.new
+        node = Node.new(2)
+        heap.insert(node)
+
+        expect(heap.decrease_key(node, 1)).to eq(node)
+      end
+    end
+
+    describe '#delete' do
+      it 'removes the node from the heap' do
+        heap = described_class.new
+        node = Node.new(2)
+        node2 = Node.new(1)
+        heap.insert(node)
+        heap.insert(node2)
+
+        heap.delete(node)
+
+        expect(heap.pop).to eq(node2)
+        expect(heap.pop).to be_nil
+      end
+
+      it 'returns the deleted node' do
+        heap = described_class.new
+        node = Node.new(1)
+        heap.insert(node)
+
+        expect(heap.delete(node)).to eq(node)
+      end
+    end
+
+    describe '#concat' do
+      it 'unite the given heap with this one' do
+        heap = described_class.new
+        node = Node.new(1)
+        heap2 = described_class.new
+        node2 = Node.new(2)
+        heap.insert(node)
+        heap2.insert(node2)
+
+        heap3 = heap.concat(heap2)
+
+        expect(heap3.pop).to eq(node)
+        expect(heap3.pop).to eq(node2)
+        expect(heap3.pop).to be_nil
+      end
+    end
+  end
+end

data/spec/fibonacci_heap/node_spec.rb

@@ -0,0 +1,29 @@
+require 'fibonacci_heap/node'
+
+module FibonacciHeap
+  RSpec.describe Node do
+    describe '#next' do
+      it 'is initialized to itself by default' do
+        node = described_class.new('foo')
+
+        expect(node.next).to eq(node)
+      end
+    end
+
+    describe '#prev' do
+      it 'is initialized to itself by default' do
+        node = described_class.new('foo')
+
+        expect(node.prev).to eq(node)
+      end
+    end
+
+    describe '#inspect' do
+      it 'lists the current key and value' do
+        node = described_class.new(1, 'foo')
+
+        expect(node.inspect).to eq('#<FibonacciHeap::Node key=1 value="foo">')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.example_status_persistence_file_path = 'spec/examples.txt'
+  config.disable_monkey_patching!
+  config.warnings = true
+  config.default_formatter = 'doc' if config.files_to_run.one?
+  config.profile_examples = 10
+  config.order = :random
+  Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: fibonacci_heap
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Paul Mucur
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+description: |2
+      A Ruby implementation of the Fibonacci heap data structure ideal for use as
+      a priority queue with Dijkstra's algorithm.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fibonacci_heap.rb
+- lib/fibonacci_heap/circular_doubly_linked_list.rb
+- lib/fibonacci_heap/heap.rb
+- lib/fibonacci_heap/node.rb
+- spec/fibonacci_heap/circular_doubly_linked_list_spec.rb
+- spec/fibonacci_heap/heap_spec.rb
+- spec/fibonacci_heap/node_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/mudge/fibonacci_heap
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: A Ruby implementation of the Fibonacci heap data structure
+test_files:
+- spec/spec_helper.rb
+- spec/fibonacci_heap/node_spec.rb
+- spec/fibonacci_heap/heap_spec.rb
+- spec/fibonacci_heap/circular_doubly_linked_list_spec.rb