algorithms 0.0.1

data/History.txt

@@ -0,0 +1,23 @@
+=== June 13, 2008
+
+  * Implemented Sedgewick's Left Leaning Red Black Tree in C!
+
+=== June 12, 2008
+
+  * Implemented Sedgewick's Left Leaning Red Black Tree
+
+=== June 10, 2008
+
+  * Implemented merge! for other heaps and heap initialization from an array
+  * Implemented Queue
+
+
+=== June 9, 2008
+
+  * Finished binomial heap implementation
+
+
+=== June 8, 2008
+
+  * Added Stack
+  * Working on heap

data/Manifest

@@ -0,0 +1,23 @@
+benchmark.rb
+ext/containers/priority_queue/extconf.rb
+ext/containers/priority_queue/priority_queue.c
+ext/containers/tree_map/extconf.rb
+ext/containers/tree_map/Rakefile
+ext/containers/tree_map/rbtree.c
+History.txt
+lib/algorithms.rb
+lib/containers/hash.rb
+lib/containers/heap.rb
+lib/containers/priority_queue.rb
+lib/containers/queue.rb
+lib/containers/stack.rb
+lib/containers/tree_map.rb
+Manifest
+Rakefile
+README.txt
+spec/heap_spec.rb
+spec/priority_queue_spec.rb
+spec/priority_queue_test.rb
+spec/queue_spec.rb
+spec/stack_spec.rb
+spec/tree_map_spec.rb

data/README.txt

@@ -0,0 +1,58 @@
+= algorithms
+
+* http://rubyforge.org/projects/algorithms/
+
+== DESCRIPTION:
+
+Using the right data structure or algorithm for the situation is an important aspect of programming. In computer science literature, many data structures and algorithms have been researched and extensively documented. However, there is still no standard library in Ruby implementing useful structures and algorithms like Red/Black Trees, tries, graphs, different sorting algorithms, etc. This project will create such a library with documentation on when to use a particular structure/algorithm. It will also come with a benchmark suite to compare performance in different situations.
+
+== FEATURES/PROBLEMS:
+
+Done so far:
+* Heaps (Maximum, Minimum)
+* Priority Queue
+* Stack
+* Queue
+* TreeMap
+
+== SYNOPSIS:
+
+  require 'rubygems'
+  require 'algorithms'
+  
+  include Containers
+  max_heap = MaxHeap.new
+
+== REQUIREMENTS:
+
+* Ruby 1.8
+* C compiler for extensions (optional)
+
+== INSTALL:
+
+* sudo gem install
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Kanwei Li
+
+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/Rakefile

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'echoe'
+
+Echoe.new('algorithms') do |p|
+  p.author  = 'Kanwei Li'
+  p.email   = 'kanwei@gmail.com'
+  p.summary = 'A library of algorithms and containers.'
+  p.url     = 'http://rubyforge.org/projects/algorithms/'
+  p.version = "0.0.1"
+  p.runtime_dependencies = []
+end
+
+task :default => :spec
+
+task :spec => :compile do
+  sh "spec -c spec/"
+end

data/algorithms.gemspec

@@ -0,0 +1,105 @@
+
+# Gem::Specification for Algorithms-0.0.1
+# Originally generated by Echoe
+
+--- !ruby/object:Gem::Specification 
+name: algorithms
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Kanwei Li
+autorequire: 
+bindir: bin
+
+date: 2008-06-25 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: echoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A library of algorithms and containers.
+email: kanwei@gmail.com
+executables: []
+
+extensions: 
+- ext/containers/priority_queue/extconf.rb
+- ext/containers/tree_map/extconf.rb
+extra_rdoc_files: 
+- ext/containers/priority_queue/extconf.rb
+- ext/containers/priority_queue/priority_queue.c
+- ext/containers/tree_map/extconf.rb
+- ext/containers/tree_map/Rakefile
+- ext/containers/tree_map/rbtree.c
+- lib/algorithms.rb
+- lib/containers/hash.rb
+- lib/containers/heap.rb
+- lib/containers/priority_queue.rb
+- lib/containers/queue.rb
+- lib/containers/stack.rb
+- lib/containers/tree_map.rb
+- README.txt
+files: 
+- benchmark.rb
+- ext/containers/priority_queue/extconf.rb
+- ext/containers/priority_queue/priority_queue.c
+- ext/containers/tree_map/extconf.rb
+- ext/containers/tree_map/Rakefile
+- ext/containers/tree_map/rbtree.c
+- History.txt
+- lib/algorithms.rb
+- lib/containers/hash.rb
+- lib/containers/heap.rb
+- lib/containers/priority_queue.rb
+- lib/containers/queue.rb
+- lib/containers/stack.rb
+- lib/containers/tree_map.rb
+- Manifest
+- Rakefile
+- README.txt
+- spec/heap_spec.rb
+- spec/priority_queue_spec.rb
+- spec/priority_queue_test.rb
+- spec/queue_spec.rb
+- spec/stack_spec.rb
+- spec/tree_map_spec.rb
+- algorithms.gemspec
+has_rdoc: true
+homepage: http://rubyforge.org/projects/algorithms/
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Algorithms
+- --main
+- README.txt
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - "="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: algorithms
+rubygems_version: 1.2.0
+specification_version: 2
+summary: A library of algorithms and containers.
+test_files: []

data/benchmark.rb

@@ -0,0 +1,49 @@
+require 'lib/algorithms'
+require 'benchmark'
+include Benchmark
+
+# Benchmark heap
+@random_array = []
+@num_items = 10000
+@num_items.times { |x| @random_array << rand(@num_items) }
+# @heap = DS::MaxHeap.new(@random_array)
+
+# benchmark do |bench|
+#   bench.report("Array#max:\t ") do
+#     @num_items.times { @random_array.delete_at(@random_array.index(@random_array.max)) }
+#   end
+#   bench.report("MaxHeap:\t ") do
+#     @num_items.times { @heap.get_max! }
+#   end
+# end
+
+# Benchmark Search trees
+@tree = Containers::TreeMap.new
+@ctree = Containers::TreeMap.new
+@hash = Hash.new
+
+benchmark do |bench|
+  bench.report("Tree: \t") do
+    @random_array.each { |x| @tree[x] = x }
+  end
+  
+  bench.report("CTree: \t") do
+    @random_array.each { |x| @ctree[x] = x }
+  end
+  
+  bench.report("Hash: \t") do
+    @hash.each { |x| @hash[x] = x }
+  end
+
+  bench.report("Hash: \t") do
+    @num_items.times { |n| @hash.has_key?(n) }
+  end
+  
+  bench.report("Tree: \t") do
+    @num_items.times { |n| @tree.contains?(n) }
+  end
+  
+  bench.report("CTree: \t") do
+    @num_items.times { |n| @ctree.contains?(n) }
+  end
+end

data/ext/containers/priority_queue/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+extension_name = "CPriorityQueue"
+dir_config(extension_name)
+create_makefile(extension_name)

data/ext/containers/priority_queue/priority_queue.c

@@ -0,0 +1,948 @@
+/*
+ * :main:CPriorityQueue
+ *
+ * Ruby extension implementing a priority queue
+ * 
+ * This is a fibonacci heap priority queue implementation.
+ *
+ * (c) 2005 Brian Schr�der
+ * 
+ * Please submit bugreports to priority_queue@brian-schroeder.de
+ *
+ * This extension is under the same license as ruby.
+ * 
+ * Do not hold me reliable for anything that happens to you, your programs or
+ * anything else because of this extension. It worked for me, but there is no
+ * guarantee it will work for you.
+ *
+ * Except for using a value except of a void* the priority queue c-code is ruby
+ * agnostic.
+ *
+ * Modifications by Kanwei Li
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include "ruby.h"
+#include <math.h>
+
+#define FALSE 0;
+#define TRUE 1;
+
+// Node Structure
+typedef struct struct_priority_node {
+  unsigned int degree;
+  VALUE priority;
+  VALUE object;
+  struct struct_priority_node* parent;
+  struct struct_priority_node* child;
+  struct struct_priority_node* left;
+  struct struct_priority_node* right;
+  int mark;
+} priority_node;
+
+// The Priority Queue
+typedef struct {
+  priority_node* rootlist;
+  priority_node* min;
+  unsigned int length;
+  int (*compare_function)(VALUE p1, VALUE p2); // Should return < 0 for a < b, 0 for a == b, > 0 for a > b
+} priority_queue;
+
+////////////////////////////////////////////////////////////////////////////////
+// Node Manipulation Functions
+////////////////////////////////////////////////////////////////////////////////
+
+// Create a priority node structure
+priority_node* create_priority_node(VALUE object, VALUE priority) {
+  priority_node* result = ALLOC(priority_node);
+  result->degree   = 0;
+  result->priority = priority;
+  result->object = object;
+  result->parent = NULL;
+  result->child = NULL;
+  result->left = result;
+  result->right = result;
+  result->mark = FALSE;  
+  return result;
+}
+
+// Use this to free a node struct
+void priority_node_free(priority_node* n) {
+  free(n);
+}
+
+static
+void priority_node_free_recursively(priority_node* n) {
+  if (!n)
+    return;
+
+  priority_node* n1 = n;
+  do {
+    priority_node *n2 = n1->right;
+    priority_node_free_recursively(n1->child);
+    priority_node_free(n1);
+    n1 = n2;
+  } while(n1 != n);
+}
+
+// link two binomial heaps
+static 
+priority_node* link_nodes(priority_queue* q, priority_node* b1, priority_node* b2) {
+  if (q->compare_function(b2->priority, b1->priority) < 0)
+    return link_nodes(q, b2, b1);
+  b2->parent = b1;
+  priority_node* child = b1->child;
+  b1->child = b2;
+  if (child) {
+    b2->left  = child->left;
+    b2->left->right = b2;
+    b2->right = child;
+    b2->right->left = b2;
+  } else {
+    b2->left = b2;
+    b2->right = b2;
+  }
+  b1->degree++;
+  b2->mark = FALSE; // TODO: Check if it is not rather b1 that should be marked as false
+  return b1;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Queue Manipulation Functions
+////////////////////////////////////////////////////////////////////////////////
+
+// Create an empty priority queue
+priority_queue* create_priority_queue(int (*compare_function)(VALUE, VALUE)) {
+  priority_queue *result = ALLOC(priority_queue);
+  result->min = NULL;
+  result->rootlist = NULL;
+  result->length = 0;
+  result->compare_function = compare_function;
+  return result;
+}
+
+// Free a priority queue and all the nodes it contains
+void priority_queue_free(priority_queue* q) {
+  priority_node_free_recursively(q->rootlist);
+  free(q);
+}
+
+// Insert a node into the rootlist
+// Does not change length value
+static
+priority_queue* insert_tree(priority_queue* const q, priority_node* const tree) {
+    if (q->rootlist) {
+      priority_node* l = q->rootlist->left;
+      l->right = tree;
+      q->rootlist->left = tree;
+      tree->left = l;
+      tree->right = q->rootlist;
+      if (q->compare_function(tree->priority, q->min->priority) < 0)
+	q->min = tree;
+    } else {
+      q->rootlist = tree;
+      q->min = tree;
+    }
+    return q;
+}
+
+// Meld two queues into one new queue. We take the first queue and the rootnode of the second queue. // TODO: Expose in API
+static
+priority_queue* meld_queue(priority_queue* q1, priority_node* q2, unsigned int length_q2) {
+  if (!q1->rootlist) {
+    q1->rootlist = q2;
+    q1->min = q2;
+    q1->length = length_q2;
+  } else {
+    priority_node* r1 = q1->rootlist->left;
+    priority_node* r2 = q2->left;  
+
+    q1->rootlist->left = r2;
+    r2->right = q1->rootlist;
+
+    q2->left = r1;
+    r1->right = q2;
+
+    q1->length = q1->length + length_q2;
+
+    if (q1->compare_function(q2->priority, q1->min->priority) < 0)
+      q1->min = q2;
+  }
+
+  return q1;
+}
+
+// Add an object and a priority to a priority queue. Returns a pointer to a
+// priority_node structure, which can be used in delete_node and priority_queue_change_priority
+// operations.
+priority_node* priority_queue_add_node(priority_queue* q, VALUE object, VALUE priority) {
+  priority_node* result = create_priority_node(object, priority);
+  insert_tree(q, result);
+  q->length++;
+  return result;
+}
+
+// Does not change length
+static 
+priority_node* delete_first(priority_queue* const q) {  
+  if (q->rootlist) {
+    priority_node* result = q->rootlist;
+    if (result == result->right)
+      q->rootlist = NULL;
+    else {
+      q->rootlist = result->right;
+      result->left->right = result->right;
+      result->right->left = result->left;
+      result->right = result;
+      result->left = result;
+    }
+    return result;
+  } else {
+    return NULL;
+  }
+}
+
+static
+void assert_pointers_correct(priority_node* n) {
+  if (!n) return;
+
+  priority_node *n1 = n->right;
+  while(n != n1) {
+    if (n1->child && (n1 != n1->child->parent)) 
+      printf("Eltern-Kind Zeiger inkorrekt: %p\n", n);
+
+    if (n1 != n1->right->left)
+      printf("Rechts-links inkorrekt: %p\n", n);
+
+    if (n1 != n1->left->right)
+      printf("links-Rechts inkorrekt: %p\n", n);
+
+    assert_pointers_correct(n1->child);
+    n1 = n1->right;
+  }
+}
+
+// Consolidate a queue in amortized O(log n)
+static 
+void consolidate_queue(priority_queue* const q) {
+  unsigned int array_size = 2 * log(q->length) / log(2) + 1;
+  priority_node* tree_by_degree[array_size];
+  unsigned int i;
+  for (i=0; i<array_size; i++)
+    tree_by_degree[i] = NULL;
+
+  priority_node* n = NULL;
+  while (((n = delete_first(q)))) {
+    priority_node* n1 = NULL;
+    while (((n1 = tree_by_degree[n->degree]))) {
+      tree_by_degree[n->degree] = NULL;
+      n = link_nodes(q, n, n1);
+    }
+    tree_by_degree[n->degree] = n;
+  }
+
+  // Find minimum value in O(log n) 
+  q->rootlist = NULL;
+  q->min = NULL;
+  for (i=0; i<array_size; i++) {    
+    if (tree_by_degree[i] != NULL) {
+      insert_tree(q, tree_by_degree[i]);
+    }
+  }
+}
+
+// Delete and extract priority_node with minimal priority O(log n)
+priority_node* priority_queue_delete_min(priority_queue* q) {
+  if (!q->rootlist) return NULL;
+  priority_node* min = q->min;
+
+  if (q->length == 1){ // length == 1
+    q->rootlist = NULL;
+    q->min = NULL;
+    q->length = 0;
+  } else {
+    unsigned int length = q->length;
+    // Abtrennen.
+    if (q->min == q->rootlist) {
+      if (q->min == q->min->right) {
+	q->rootlist = NULL;
+	q->min = NULL;
+      } else {
+	q->rootlist = q->min->right;
+      }
+    }
+    min->left->right = min->right;
+    min->right->left = min->left;
+    min->left = min;
+    min->right = min;
+    if (min->child) {
+      // Kinder und Eltern trennen, Markierung aufheben, und kleinstes Kind bestimmen.
+      priority_node* n = min->child;
+      do {
+	n->parent = NULL;
+	n->mark = FALSE;
+	n = n->right;
+      } while (n!=min->child);
+
+      // Kinder einf�gen
+      if (q->rootlist) {
+	priority_node* const l1 = q->rootlist->left;
+	priority_node* const l2 = n->left;
+
+	l1->right = n;
+	n->left = l1;
+	l2->right = q->rootlist;
+	q->rootlist->left = l2;
+      } else {
+	q->rootlist = n;
+      }
+    }
+
+    // Gr��e anpassen
+    q->length = length-1;
+
+    // Wieder aufh�bschen
+    consolidate_queue(q);
+  }
+
+  return min;
+}
+
+static
+  priority_queue* cut_node(priority_queue* q, priority_node* n) {
+    if (!n->parent)
+      return q;  
+    n->parent->degree--;
+    if (n->parent->child == n) {
+      if (n->right == n)
+	n->parent->child = NULL;
+      else
+	n->parent->child = n->right;  
+    }
+    n->parent = NULL;
+    n->right->left = n->left;
+    n->left->right = n->right;
+
+    n->right = q->rootlist;
+    n->left  = q->rootlist->left;
+    q->rootlist->left->right = n;
+    q->rootlist->left = n;
+    q->rootlist = n;
+
+    n->mark = FALSE;
+
+    return q;
+  }
+
+// change the priority of a priority_node and restructure the queue
+// Does not free the priority node
+priority_queue* priority_queue_delete(priority_queue* q, priority_node* n) {
+  if (n->child) {
+    priority_node* c = n->child;
+    priority_node* e = n->child;
+    do {
+      priority_node* r = c->right;
+      cut_node(q, c);
+      c = r;
+    } while (c != e);
+  }
+  if (n->parent)
+    cut_node(q, n);
+  if (n == n->right) {
+    q->min = NULL;
+    q->rootlist = NULL;
+  } else {
+    if (q->rootlist == n)
+      q->rootlist = n->right;
+    if (q->min == n) {
+      priority_node* n1 = n->right;
+      q->min = n1;
+      do {
+	if (q->compare_function(n1->priority, q->min->priority) <= 0) 
+	  q->min = n1;
+	n1 = n1->right;
+      } while(n1 != n);
+    }
+    n->right->left = n->left;
+    n->left->right = n->right;
+    n->left = n;
+    n->right = n;
+  }
+  q->length -= 1;
+  return q;
+}
+
+// change the priority of a priority_node and restructure the queue
+priority_queue* priority_queue_change_priority(priority_queue* q, priority_node* n, VALUE priority) {
+  if (q->compare_function(n->priority, priority) <= 0) { // Priority was increased. Remove the node and reinsert.
+    priority_queue_delete(q, n);
+    n->priority = priority;
+    meld_queue(q, n, 1);
+    return q;
+  }    
+  n->priority = priority;
+  if (q->compare_function(n->priority, q->min->priority) < 0)
+    q->min = n;
+  if (!(n->parent) || (q->compare_function(n->parent->priority, n->priority) <= 0)) // Already in rootlist or bigger than parent
+    return q;
+  do { // Cascading Cuts
+    priority_node* p = n->parent;
+    cut_node(q, n);
+    n = p;
+  } while (n->mark && n->parent);
+  if (n->parent)
+    n->mark = TRUE;
+  return q;
+}
+
+// Get the priority_node with the minimum priority from a queue
+priority_node* priority_queue_min(priority_queue *q) {
+  return q->min;
+}
+
+int priority_queue_empty(priority_queue *q) {
+  return q->min == NULL;
+}
+
+// change the priority of a priority_node and restructure the queue
+priority_queue* priority_queue_each_node(priority_queue* q, priority_node* n, 
+    void (*each)(priority_queue* q_, priority_node* n_, void* args), void* arguments) {
+  priority_node* end = n;
+  do {
+    priority_node* next = n->right;
+    (*each)(q, n, arguments);
+    if (n->child)
+      priority_queue_each_node(q, n->child, each, arguments);
+    n = n->right;
+    if (n != next)
+      break;
+  } while (n != end);
+  return q;
+}
+
+priority_queue* priority_queue_each(priority_queue* q,  
+    void (*each)(priority_queue* q, priority_node* n, void* args), void* arguments) {
+  if (q->rootlist)
+    priority_queue_each_node(q, q->rootlist, each, arguments);
+  return q;
+}
+////////////////////////////////////////////////////////////////////////////////
+// Define the ruby classes
+////////////////////////////////////////////////////////////////////////////////
+
+static int id_compare_operator;
+static int id_format;
+static int id_display;
+
+priority_queue* get_pq_from_value(VALUE self) {
+  priority_queue *q; 
+  Data_Get_Struct(self, priority_queue, q);
+  return q;
+}
+
+static
+int priority_compare_function(VALUE a, VALUE b) {
+  return FIX2INT(rb_funcall((VALUE) a, id_compare_operator, 1, (VALUE) b));
+}
+
+static
+void pq_free(void *p) {
+  priority_queue_free(p);
+}
+
+static
+void pq_mark_recursive(priority_node* n) {
+  if (!n) return;
+  rb_gc_mark((VALUE) n->object);
+  rb_gc_mark((VALUE) n->priority);
+  priority_node* n1 = n->child;
+  if (!n1) return;
+  do {
+    pq_mark_recursive(n1);
+    n1 = n1->right;
+  } while (n1 != n->child);
+}
+
+static
+void pq_mark(void *q) {  
+  priority_node* n1 = ((priority_queue*) q)->rootlist;
+  if (!n1)
+    return;
+  priority_node* n2 = n1;
+  do {
+    pq_mark_recursive(n1);
+    n1 = n1->right;
+  } while (n1 != n2);
+}
+
+static 
+VALUE pq_alloc(VALUE klass) {
+  priority_queue *q;
+  VALUE object;
+
+  q = create_priority_queue(&priority_compare_function);
+
+  object = Data_Wrap_Struct(klass, pq_mark, pq_free, q);
+
+  return object;
+}
+
+/*
+ * Create a new, empty PriorityQueue
+ */
+static
+VALUE pq_init(VALUE self) {
+  rb_iv_set(self, "@__node_by_object__", rb_hash_new());
+
+  return self;
+}
+
+/*
+ * Add an object to the queue.
+ */
+static
+VALUE pq_push(VALUE self, VALUE object, VALUE priority) {
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+
+  priority_queue* q = get_pq_from_value(self);
+
+  priority_node* n = priority_queue_add_node(q, object, priority);
+
+  rb_hash_aset(hash, object, ULONG2NUM((unsigned long) n)); // TODO: This is hackish, maybe its better to also wrap the nodes.
+
+  return self;
+}
+
+/* call-seq:
+ *     min -> [object, priority]
+ *     
+ * Return the pair [object, priority] with minimal priority or nil when the
+ * queue is empty.
+ *
+ *     q = PriorityQueue.new
+ *     q["a"] = 10
+ *     q["b"] = 20
+ *     q.min          #=> ["a", 10]
+ *     q.delete_min   #=> ["a", 10]
+ *     q.min          #=> ["b", 20]
+ *     q.delete_min   #=> ["b", 20]
+ *     q.min          #=> nil
+ */
+static
+VALUE pq_min(VALUE self) {
+  priority_queue* q = get_pq_from_value(self);
+
+  priority_node* n = priority_queue_min(q);
+  if (n)
+    return rb_ary_new3(2, n->object, n->priority);
+  else
+    return Qnil;
+}
+
+/* call-seq:
+ *     min_key -> object
+ *     
+ * Return the key that has the minimal priority or nil when the queue is empty.
+ *
+ *     q = PriorityQueue.new
+ *     q["a"] = 10
+ *     q["b"] = 20
+ *     q.min_key      #=> "a"
+ *     q.delete_min   #=> ["a", 10]
+ *     q.min_key      #=> "b"
+ *     q.delete_min   #=> ["b", 20]
+ *     q.min_key      #=> nil
+ */
+static
+VALUE pq_min_key(VALUE self) {
+  priority_queue* q = get_pq_from_value(self);
+
+  priority_node* n = priority_queue_min(q);
+  if (n)
+    return n->object;
+  else
+    return Qnil;
+}
+
+/* call-seq:
+ *     min_priority -> priority
+ *
+ * Return the minimal priority or nil when the queue is empty.
+ *
+ *     q = PriorityQueue.new
+ *     q["a"] = 10
+ *     q["b"] = 20
+ *     q.min_priority #=> 10
+ *     q.delete_min   #=> ["a", 10]
+ *     q.min_priority #=> 20
+ *     q.delete_min   #=> ["b", 20]
+ *     q.min_priority #=> nil
+ */
+static
+VALUE pq_min_priority(VALUE self) {
+  priority_queue* q = get_pq_from_value(self);
+
+  priority_node* n = priority_queue_min(q);
+  if (n)
+    return n->priority;
+  else
+    return Qnil;
+}
+
+/* call-seq:
+ *    delete_min -> [key, priority]
+ * 
+ * Delete key with minimal priority and return [key, priority]
+ *
+ *    q = PriorityQueue.new
+ *    q["a"] = 1
+ *    q["b"] = 0
+ *    q.delete_min #=> ["b", 0]
+ *    q.delete_min #=> ["a", 1]
+ *    q.delete_min #=> nil
+ */
+static
+VALUE pq_delete_min(VALUE self) {
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+  priority_queue* q = get_pq_from_value(self);
+
+  priority_node* n = priority_queue_delete_min(q);
+
+  if (n) {
+    rb_hash_delete(hash, n->object); // TODO: Maybe we have a problem here with garbage collection of n->object?
+    return rb_ary_new3(2, n->object, n->priority);  
+  } else {
+    return Qnil;
+  }
+}
+
+/* call-seq:
+ *    delete_min_return_key -> key
+ * 
+ * Delete key with minimal priority and return the key
+ *
+ *    q = PriorityQueue.new
+ *    q["a"] = 1
+ *    q["b"] = 0
+ *    q.delete_min_return_key #=> "b"
+ *    q.delete_min_return_key #=> "a"
+ *    q.delete_min_return_key #=> nil
+ */
+static
+VALUE pq_delete_min_return_key(VALUE self) {
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+  priority_queue* q = get_pq_from_value(self);
+
+  priority_node* n = priority_queue_delete_min(q);
+
+  if (n) {
+    rb_hash_delete(hash, n->object); // TODO: Maybe we have a problem here with garbage collection of n->object?
+    return n->object;  
+  } else {
+    return Qnil;
+  }
+}
+
+/*
+ * call-seq:
+ *   delete_min_return_priority -> priority
+ *
+ * Delete key with minimal priority and return the priority value
+ *
+ *    q = PriorityQueue.new
+ *    q["a"] = 1
+ *    q["b"] = 0
+ *    q.delete_min_return_priority #=> 0
+ *    q.delete_min_return_priority #=> 1
+ *    q.delete_min_return_priority #=> nil
+ */
+static
+VALUE pq_delete_min_return_priority(VALUE self) {
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+  priority_queue* q = get_pq_from_value(self);
+
+  priority_node* n = priority_queue_delete_min(q);
+
+  if (n) {
+    rb_hash_delete(hash, n->object); // TODO: Maybe we have a problem here with garbage collection of n->object?
+    return n->priority;  
+  } else {
+    return Qnil;
+  }
+}
+
+/*
+ * call-seq:
+ *     [key] = priority
+ *     change_priority(key, priority)
+ *     push(key, priority)
+ *
+ * Set the priority of a key.
+ *
+ *     q = PriorityQueue.new
+ *     q["car"] = 50
+ *     q["train"] = 50
+ *     q["bike"] = 10
+ *     q.min #=> ["bike", 10]
+ *     q["car"] = 0
+ *     q.min #=> ["car", 0]
+ */
+static
+VALUE pq_change_priority(VALUE self, VALUE object, VALUE priority) {
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+  priority_queue* q = get_pq_from_value(self);
+
+  VALUE node = rb_hash_aref(hash, object);
+  if (NIL_P(node)) {
+    pq_push(self, object, priority);
+  } else {
+    priority_queue_change_priority(q, (priority_node*) NUM2ULONG(node), priority);
+  }
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *     [key] -> priority
+ *
+ * Return the priority of a key or nil if the key is not in the queue.
+ *
+ *     q = PriorityQueue.new
+ *     (0..10).each do | i | q[i.to_s] = i end
+ *     q["5"] #=> 5
+ *     q[5] #=> nil
+ */
+static
+VALUE pq_get_priority(VALUE self, VALUE object) {
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+
+  VALUE node_pointer = rb_hash_aref(hash, object);
+  
+  if (NIL_P(node_pointer))
+    return Qnil;
+  else
+    return (VALUE) (((priority_node*) NUM2ULONG(node_pointer))->priority);
+}
+
+/*
+ * call-seq:
+ *     has_key? key -> boolean
+ *     
+ * Return false if the key is not in the queue, true otherwise.
+ *
+ *     q = PriorityQueue.new
+ *     (0..10).each do | i | q[i.to_s] = i end
+ *     q.has_key("5") #=> true 
+ *     q.has_key(5)   #=> false
+ */
+static
+VALUE pq_has_key(VALUE self, VALUE object) {
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+
+  VALUE node_pointer = rb_hash_aref(hash, object);
+  
+  return NIL_P(node_pointer) ? Qfalse : Qtrue;
+}
+/* call-seq:
+ *     length -> Fixnum
+ * 
+ * Returns the number of elements of the queue.
+ * 
+ *     q = PriorityQueue.new
+ *     q.length #=> 0
+ *     q[0] = 1
+ *     q.length #=> 1
+ */
+static
+VALUE pq_length(VALUE self) {
+  priority_queue* q = get_pq_from_value(self);
+
+  return INT2NUM(q->length);
+}
+
+/* call-seq:
+ *    delete(key) -> [key, priority]
+ *    delete(key) -> nil
+ * 
+ * Delete a key from the priority queue. Returns nil when the key was not in
+ * the queue and [key, priority] otherwise.
+ * 
+ *     q = PriorityQueue.new
+ *     (0..10).each do | i | q[i.to_s] = i end
+ *     q.delete(5)                               #=> ["5", 5]
+ *     q.delete(5)                               #=> nil
+ */
+static
+VALUE pq_delete(VALUE self, VALUE object) {
+  priority_queue* q = get_pq_from_value(self);
+
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+
+  VALUE node_pointer = rb_hash_aref(hash, object);  
+  
+  if (NIL_P(node_pointer))
+    return Qnil;
+  else {
+    priority_node* n = (priority_node*) NUM2ULONG(node_pointer);
+    VALUE object = n->object;
+    VALUE priority = n->priority;
+    priority_queue_delete(q, n);
+    rb_hash_delete(hash, object);
+    priority_node_free(n);
+    return rb_ary_new3(2, object, priority);
+  }
+}
+
+
+// Dot a single node of a priority queue. Called by pq_to_dot to do the inner work.
+// (I'm not proud of this function ;-( )
+static
+void pq_node2dot(VALUE result_string, priority_node* n, unsigned int level) {
+  if (n == NULL) return;  
+  unsigned int i;
+  for (i=0; i<level; i++) rb_str_cat2(result_string, "  ");  
+  if (n->mark)
+    rb_str_concat(result_string,
+	rb_funcall(Qnil, id_format, 4, rb_str_new2("NODE%i [label=\"%s (%s)\"];\n"), 
+	  ULONG2NUM((unsigned long) n), n->object, n->priority));
+  else
+    rb_str_concat(result_string,
+	rb_funcall(Qnil, id_format, 4, rb_str_new2("NODE%i [label=\"%s (%s)\",shape=box];\n"), 
+	  ULONG2NUM((unsigned long) n), n->object, n->priority));
+  if (n->child != NULL) {
+    priority_node* n1 = n->child;
+    do {
+      pq_node2dot(result_string, n1, level + 1);
+      for (i=0; i<level; i++) rb_str_cat2(result_string, "  ");  
+      rb_str_concat(result_string,
+	  rb_funcall(Qnil, id_format, 4, rb_str_new2("NODE%i -> NODE%i;\n"), 
+	    ULONG2NUM((unsigned long) n), ULONG2NUM((unsigned long) n1)));
+      n1 = n1->right;
+    } while(n1 != n->child);
+  }
+}
+
+/* 
+ * Print a priority queue as a dot-graph. The output can be fed to dot from the
+ * vizgraph suite to create a tree depicting the internal datastructure.
+ * 
+ * (I'm not proud of this function ;-( )
+ */
+static
+VALUE pq_to_dot(VALUE self) {
+  priority_queue* q = get_pq_from_value(self);
+
+  VALUE result_string = rb_str_new2("digraph fibonacci_heap {\n");
+  if (q->rootlist) {
+    priority_node* n1 = q->rootlist;
+    do {    
+      pq_node2dot(result_string, n1, 1);
+      n1 = n1->right;
+    } while(n1 != q->rootlist);
+  }
+  rb_str_cat2(result_string, "}\n");
+  return result_string;
+}
+
+/*
+ * Returns true if the array is empty, false otherwise.
+ */
+static
+VALUE pq_empty(VALUE self) {
+  priority_queue* q = get_pq_from_value(self);
+  return priority_queue_empty(q) ? Qtrue : Qfalse;
+}
+
+static
+void pq_each_helper(priority_queue *q, priority_node *n, void *args) {
+  rb_yield(rb_ary_new3(2, n->object, n->priority));
+};
+
+/*
+ * Call the given block with each [key, priority] pair in the queue
+ *
+ * Beware: Changing the queue in the block may lead to unwanted behaviour and
+ * even infinite loops.
+ */
+static
+VALUE pq_each(VALUE self) {
+  priority_queue* q = get_pq_from_value(self);
+  priority_queue_each(q, &pq_each_helper, NULL);
+  return self;
+}
+
+static
+VALUE pq_insert_node(VALUE node, VALUE queue) {
+  return pq_push(queue, rb_ary_entry(node, 0), rb_ary_entry(node, 1));
+}
+
+static
+VALUE pq_initialize_copy(VALUE copy, VALUE orig) {
+  if (copy == orig)
+    return copy;
+
+  rb_iterate(rb_each, orig, pq_insert_node, copy);
+  
+  return copy;
+}
+
+/*
+ * Returns a string representation of the priority queue.
+ */
+static
+VALUE pq_inspect(VALUE self) {  
+  VALUE result = rb_str_new2("<PriorityQueue: ");
+  rb_str_concat(result,
+      rb_funcall(rb_funcall(self, rb_intern("to_a"), 0),
+	rb_intern("inspect"), 0));
+  rb_str_concat(result, rb_str_new2(">"));
+  return result;
+}
+
+static VALUE cPriorityQueue;
+static VALUE mContainers;
+
+/* 
+ * A Priority Queue implementation
+ *
+ * A priority queue is a queue, where each element (the key) has an assigned
+ * priority.  It is possible to efficently decrease priorities and to
+ * efficently look up and remove the key with the smallest priority.
+ *
+ * This datastructure is used in different algorithms. The standard algorithm
+ * used to introduce priority queues is dijkstra's shortest path algorithm.
+ *
+ * The priority queue includes the Enumerable module.
+ */
+void Init_CPriorityQueue() {
+  id_compare_operator = rb_intern("<=>");
+  id_format = rb_intern("format");
+  id_display = rb_intern("display");
+
+  mContainers = rb_define_module("Containers");
+  cPriorityQueue = rb_define_class_under(mContainers, "CPriorityQueue", rb_cObject);
+
+  rb_define_alloc_func(cPriorityQueue, pq_alloc);
+  rb_define_method(cPriorityQueue, "initialize", pq_init, 0);
+  rb_define_method(cPriorityQueue, "initialize_copy", pq_initialize_copy, 1);
+  rb_define_method(cPriorityQueue, "min", pq_min, 0);
+  rb_define_method(cPriorityQueue, "min_key", pq_min_key, 0);
+  rb_define_method(cPriorityQueue, "min_priority", pq_min_priority, 0);
+  rb_define_method(cPriorityQueue, "delete_min", pq_delete_min, 0);
+  rb_define_method(cPriorityQueue, "delete_min_return_key", pq_delete_min_return_key, 0);
+  rb_define_method(cPriorityQueue, "delete_min_return_priority", pq_delete_min_return_priority, 0);
+  rb_define_method(cPriorityQueue, "push", pq_change_priority, 2);
+  rb_define_method(cPriorityQueue, "change_priority", pq_change_priority, 2);
+  rb_define_method(cPriorityQueue, "[]=", pq_change_priority, 2);
+  rb_define_method(cPriorityQueue, "priority", pq_get_priority, 1);
+  rb_define_method(cPriorityQueue, "[]", pq_get_priority, 1);
+  rb_define_method(cPriorityQueue, "has_key?", pq_has_key, 1);
+  rb_define_method(cPriorityQueue, "length", pq_length, 0);
+  rb_define_method(cPriorityQueue, "to_dot", pq_to_dot, 0);
+  rb_define_method(cPriorityQueue, "empty?", pq_empty, 0);
+  rb_define_method(cPriorityQueue, "delete", pq_delete, 1);
+  rb_define_method(cPriorityQueue, "inspect", pq_inspect, 0);
+  rb_define_method(cPriorityQueue, "each", pq_each, 0);
+  rb_include_module(cPriorityQueue, rb_eval_string("Enumerable"));
+}