lazy_priority_queue 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0fd645a3f0b657b9d5f8d406e3d1c36e88d4e9f0
+  data.tar.gz: 805c1d6fdc15a7604b05457c896009e6e4af17de
+SHA512:
+  metadata.gz: 34178a91738b2884553b73555f9e1a5daaa4a60deb6735ff26fad10704aaf417bc8f244384256dec41eae70ca6343aeac2833581f4e5c8aca89d88e1904132b6
+  data.tar.gz: c963785af0360405e04a0bf0b6b4ce3cfd23e70f8c59a7c7eb710bc5b2bd2ab40f000dc603ea39757c5e1d124ce13b2fcfb7e345d3bc756992ceaa2aabce84a0

data/lib/lazy_priority_queue.rb

@@ -0,0 +1,144 @@
+class LazyPriorityQueue
+
+  Node = Struct.new :element,
+                    :key,
+                    :rank,
+                    :parent,
+                    :left_child,
+                    :right_sibling
+
+  def initialize top_condition, &heap_property
+    @roots = []
+    @references = {}
+    @top_condition = top_condition
+    @heap_property = heap_property
+  end
+
+  def enqueue element, key
+    raise 'The provided element already is in the queue.' if @references[element]
+
+    node = Node.new element, key, 0
+
+    @top = @top ? select(@top, node) : node
+    @roots << node
+    @references[element] = node
+
+    element
+  end
+
+  def change_priority element, new_key
+    node = @references[element]
+
+    raise 'Element provided is not in the queue.' unless node
+
+    test_node = node.clone
+    test_node.key = new_key
+    raise 'Priority can only be changed to a more prioritary value.' unless @heap_property[test_node, node]
+
+    node.key = new_key
+    node = sift_up node
+    @top = select(@top, node) unless node.parent
+
+    element
+  end
+
+  def peek
+    @top and @top.element
+  end
+
+  def dequeue
+    return unless @top
+
+    element = @top.element
+    @references.delete element
+    @roots.delete @top
+
+    child = @top.left_child
+
+    while child
+      next_child = child.right_sibling
+      child.parent = nil
+      child.right_sibling = nil
+      @roots << child
+      child = next_child
+    end
+
+    @roots = coalesce @roots
+    @top = @roots.inject { |top, node| select top, node }
+
+    element
+  end
+
+  def delete element
+    change_priority element, @top_condition
+    dequeue
+  end
+
+  def empty?; @references.empty? end
+  def size; @references.size end
+
+  private
+
+  def sift_up node
+    return node unless node.parent and not @heap_property[node.parent, node]
+
+    node.parent.key, node.key = node.key, node.parent.key
+    node.parent.element, node.element = node.element, node.parent.element
+
+    @references[node.element] = node
+    @references[node.parent.element] = node.parent
+
+    sift_up node.parent
+  end
+
+  def select parent_node, child_node
+    @heap_property[parent_node, child_node] ? parent_node : child_node
+  end
+
+  def coalesce trees
+    coalesced_trees = []
+
+    while tree = trees.pop
+      if coalesced_tree = coalesced_trees[tree.rank]
+        # This line must go before than...
+        coalesced_trees[tree.rank] = nil
+        # ...this one.
+        trees << add(tree, coalesced_tree)
+      else
+        coalesced_trees[tree.rank] = tree
+      end
+    end
+
+    coalesced_trees.compact
+  end
+
+  def add node_one, node_two
+    raise 'Both nodes must hold the same rank.' if node_one.rank != node_two.rank
+    raise 'Both nodes must be roots (no parents).' if node_one.parent || node_two.parent
+
+    adder_node, addend_node = @heap_property[node_one, node_two] ? [node_one, node_two] : [node_two, node_one]
+
+    addend_node.parent = adder_node
+
+    # This line must go before than...
+    addend_node.right_sibling = adder_node.left_child
+    # ...this one.
+    adder_node.left_child = addend_node
+
+    adder_node.rank += 1
+
+    adder_node
+  end
+end
+
+class MinPriorityQueue < LazyPriorityQueue
+  def initialize
+    super(-Float::INFINITY) { |parent_node, child_node| parent_node.key <= child_node.key }
+  end
+end
+
+class MaxPriorityQueue < LazyPriorityQueue
+  def initialize
+    super( Float::INFINITY) { |parent_node, child_node| parent_node.key >= child_node.key }
+  end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: lazy_priority_queue
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Matías Battocchia
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-11 00:00:00.000000000 Z
+dependencies: []
+description: Lazy priority queue is a priority queue which implements a lazy binomial
+  heap. It supports the change priority operation, being suitable for algorithms like
+  Dijkstra's shortest path and Prim's minimum spanning tree. It can be instantiated
+  as a min-priority queue as well as a max-priority queue.
+email: matias@riseup.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/lazy_priority_queue.rb
+homepage: https://github.com/matiasbattocchia/lazy_priority_queue
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: A priority queue which implements a lazy binomial heap.
+test_files: []