algorithms 0.0.1

data/lib/containers/queue.rb

@@ -0,0 +1,29 @@
+module Containers
+  # Use a Ruby array for storage
+  class Queue
+    def initialize(ary=[])
+      @container = ary
+    end
+  
+    def put(object)
+      @container.push(object)
+    end
+  
+    def peek
+      @container[0]
+    end
+    
+    def get
+      @container.shift
+    end
+  
+    def size
+      @container.size
+    end
+  
+    def empty?
+      @container.empty?
+    end
+  
+  end
+end

data/lib/containers/stack.rb

@@ -0,0 +1,29 @@
+module Containers
+  # Use a Ruby array for storage
+  class Stack
+    def initialize(ary=[])
+      @container = ary
+    end
+  
+    def push(object)
+      @container.push(object)
+    end
+  
+    def peek
+      @container.last
+    end
+  
+    def pop
+      @container.pop
+    end
+  
+    def size
+      @container.size
+    end
+  
+    def empty?
+      @container.empty?
+    end
+  
+  end
+end

data/lib/containers/tree_map.rb

@@ -0,0 +1,265 @@
+module Containers
+  # A TreeMap implemented with a self-balancing red-black tree
+  # Adapted from Robert Sedgewick's Left Leaning Red-Black Tree Implementation
+  # http://www.cs.princeton.edu/~rs/talks/LLRB/Java/RedBlackBST.java
+  class RubyTreeMap
+    include Enumerable
+    
+    class Node
+      attr_accessor :color, :key, :value, :left, :right, :num_nodes, :height
+      def initialize(key, value)
+        @key = key
+        @value = value
+        @color = :red
+        @left = nil
+        @right = nil
+        @num_nodes = 1
+        @height = 1
+      end
+    end
+    
+    attr_accessor :height_black
+    
+    def initialize
+      @root = nil
+      @height_black = 0
+    end
+    
+    def put(key, value)
+      @root = insert(@root, key, value)
+      @height_black += 1 if isred(@root)
+      @root.color = :black
+    end
+    alias :[]= :put
+    
+    def size
+      sizeR(@root)
+    end
+    
+    def height
+      heightR(@root)
+    end
+    
+    def contains?(key)
+      !get(key).nil?
+    end
+    
+    def get(key)
+      getR(@root, key)
+    end
+    alias :[] :get
+    
+    def min_key
+      @root.nil? ? nil : minR(@root)
+    end
+    
+    def max_key
+      @root.nil? ? nil : maxR(@root)
+    end
+    
+    def delete(key)
+      result = nil
+      if @root
+        @root, result = deleteR(@root, key)
+        @root.color = :black
+      end
+      result
+    end
+    
+    def each(&block)
+      @root.nil? ? nil : eachR(@root, block)
+    end
+    
+    def to_s
+      return "" if @root.nil?
+      "#{@height_black} #{to_sR(@root)}"
+    end
+    
+    private
+    
+    def eachR(node, block)
+      return if node.nil?
+      
+      eachR(node.left, block)
+      block.call(node.key, node.value)
+      eachR(node.right, block)
+    end
+    
+    def deleteR(node, key)
+      if (key <=> node.key) == -1
+        node = move_red_left(node) if (!isred(node.left) && !isred(node.left.left))
+        node.left, result = deleteR(node.left, key)
+      else
+        node = rotate_right(node) if isred(node.left)
+        if ( ( (key <=> node.key) == 0) && node.right.nil? )
+          return nil, node.value
+        end
+        if (!isred(node.right) && !isred(node.right.left))
+          node = move_red_right(node);
+        end
+        if (key <=> node.key) == 0
+          result = node.value
+          node.value = getR(node.right, minR(node.right))
+          node.key = minR(node.right)
+          node.right = delete_minR(node.right)
+        else
+          node.right, result = deleteR(node.right, key)
+        end
+      end
+      return fixup(node), result
+    end
+    
+    def delete_minR(node)
+      return nil if node.left.nil?
+      if ( !isred(node.left) && !isred(node.left.left) )
+        node = move_red_left(node)
+      end
+      node.left = delete_minR(node.left)
+      
+      fixup(node)
+    end
+    
+    def delete_maxR(node)
+      if (isred(node.left))
+        node = rotate_right(node)
+      end
+      return nil if node.right.nil?
+      if ( !isred(node.right) && !isred(node.right.left) )
+        node = move_red_right(node)
+      end
+      node.right = delete_maxR(node.right)
+      
+      fixup(node)
+    end
+    
+    def getR(node, key)
+      return nil if node.nil?
+      case key <=> node.key
+      when  0 then return node.value;
+      when -1 then return getR(node.left, key)
+      when  1 then return getR(node.right, key)
+      end
+    end
+    
+    def to_sR(x)
+      s = "("
+      x.left.nil? ? s << '(' : s << to_sR(x.left)
+      s << "*" if isred(x)
+      x.right.nil? ? s << ')' : s << to_sR(x.right)
+      s + ')'
+    end    
+    
+    def sizeR(node)
+      return 0 if node.nil?
+      
+      node.num_nodes
+    end
+    
+    def heightR(node)
+      return 0 if node.nil?
+      
+      node.height
+    end
+    
+    def minR(node)
+      return node.key if node.left.nil?
+      
+      minR(node.left)
+    end
+    
+    def maxR(node)
+      return node.key if node.right.nil?
+      
+      maxR(node.right)
+    end
+    
+    def insert(node, key, value)
+      if(node.nil?)
+        return Node.new(key, value)
+      end
+      
+      colorflip(node) if (isred(node.left) && isred(node.right))
+      
+      case key <=> node.key
+      when  0 then node.value = value
+      when -1 then node.left = insert(node.left, key, value)
+      when  1 then node.right = insert(node.right, key, value)
+      end
+      
+      node = rotate_left(node) if isred(node.right)
+      node = rotate_right(node) if (isred(node.left) && isred(node.left.left))
+      
+      set_num_nodes(node)
+    end
+    
+    def isred(h)
+      return false if h.nil?
+      
+      h.color == :red
+    end
+    
+    def rotate_left(h)
+      x = h.right
+      h.right = x.left
+      x.left = set_num_nodes(h)
+      x.color = x.left.color
+      x.left.color = :red
+                         
+      set_num_nodes(x)
+    end
+    
+    def rotate_right(h)
+      x = h.left
+      h.left = x.right
+      x.right = set_num_nodes(h)
+      x.color = x.right.color
+      x.right.color = :red
+      
+      set_num_nodes(x);
+    end
+    
+    def colorflip(h)
+      h.color       = h.color == :red       ? :black : :red
+      h.left.color  = h.left.color == :red  ? :black : :red
+      h.right.color = h.right.color == :red ? :black : :red
+    end
+    
+    def move_red_left(h)
+      colorflip(h)
+      if isred(h.right.left)
+        h.right = rotate_right(h.right)
+        h = rotate_left(h)
+        colorflip(h)
+      end
+      h      
+    end
+    
+    def move_red_right(h)
+      colorflip(h)
+      if isred(h.left.left)
+        h = rotate_right(h)
+        colorflip(h)
+      end
+      h      
+    end
+    
+    def fixup(h)
+      h = rotate_left(h) if isred(h.right)
+      h = rotate_right(h) if (isred(h.left) && isred(h.left.left))
+      colorflip(h) if (isred(h.left) && isred(h.right))
+      
+      set_num_nodes(h)
+    end
+    
+    def set_num_nodes(h)
+      h.num_nodes = sizeR(h.left) + sizeR(h.right) + 1
+      if heightR(h.left) > heightR(h.right)
+        h.height = heightR(h.left) + 1
+      else
+        h.height = heightR(h.right) + 1
+      end
+      h
+    end
+  end
+  
+end

data/spec/heap_spec.rb

@@ -0,0 +1,74 @@
+require 'lib/algorithms'
+
+describe Containers::Heap do
+  before(:each) do
+    @heap = Containers::MaxHeap.new
+  end
+  
+  describe "(empty)" do
+  
+    it "should return nil when getting the maximum" do
+      @heap.get_max!.should eql(nil)
+    end
+    
+    it "should let you insert and remove one item" do
+      @heap.size.should eql(0)
+      
+      @heap.insert(1)
+      @heap.size.should eql(1)
+      
+      @heap.get_max!.should eql(1)
+      @heap.size.should eql(0)
+    end
+    
+    it "should let you initialize with an array" do
+      @heap = Containers::MaxHeap.new([1,2,3])
+      @heap.size.should eql(3)
+    end
+
+  end
+  
+  describe "(non-empty)" do
+    before(:each) do
+      @random_array = []
+      @num_items = 100
+      @num_items.times { |x| @random_array << rand(@num_items) }
+      @heap = Containers::MaxHeap.new(@random_array)
+    end
+    
+    it "should display the correct size" do
+      @heap.size.should eql(@num_items)
+    end
+    
+    it "should be in max->min order" do
+      ordered = []
+      ordered << @heap.get_max! until @heap.size == 0
+      
+      ordered.should eql(@random_array.sort.reverse)
+    end
+    
+    it "should let you merge with another heap" do
+      numbers = [1,3,4,5]
+      otherheap = Containers::MaxHeap.new(numbers)
+      otherheap.size.should eql(4)
+      @heap.merge!(otherheap)
+      
+      ordered = []
+      ordered << @heap.get_max! until @heap.size == 0
+      
+      ordered.should eql( (@random_array + numbers).sort.reverse)
+    end
+    
+    describe "min-heap" do
+      it "should be in min->max order" do
+        @heap = Containers::MinHeap.new(@random_array)
+        ordered = []
+        ordered << @heap.get_min! until @heap.size == 0
+
+        ordered.should eql(@random_array.sort)
+      end
+    end
+    
+  end
+  
+end

data/spec/priority_queue_spec.rb

@@ -0,0 +1,31 @@
+require 'lib/algorithms'
+
+describe Containers::RubyPriorityQueue do
+  before(:each) do
+    @q = Containers::RubyPriorityQueue.new
+  end
+  
+  describe "(empty)" do
+
+  end
+  
+  describe "(non-empty)" do
+    it "should give the correct length/size" do
+      20.times do | i |
+        @q.length.should eql(i)
+        @q[i] = i
+      end
+      10.times do | i |
+        @q.length.should eql(20-i)
+        @q.delete_min
+      end
+      10.times do | i |
+        @q.length.should eql(i+10)
+        @q[i] = i
+      end
+      @q.delete(5)
+      @q.length.should eql(19)
+    end
+  end
+  
+end

data/spec/priority_queue_test.rb

@@ -0,0 +1,371 @@
+#!/usr/bin/ruby
+
+# Priority Queue tests
+
+$:.unshift '../ext/priority_queue/CPriorityQueue'
+$:.unshift '../lib/'
+
+require 'test/unit'
+
+require 'priority_queue/ruby_priority_queue'
+require 'priority_queue/poor_priority_queue'
+begin
+  require 'priority_queue/CPriorityQueue' 
+rescue LoadError
+  require 'CPriorityQueue'
+end
+
+
+module PriorityQueueTest    
+  # Check that the order is maintained
+  def teardown
+    last = @q.min_priority
+    while priority = @q.delete_min_return_priority
+      assert_operator(last, :<=, priority)
+      last = priority
+    end
+  end
+
+  def test_length
+    20.times do | i |
+      assert_equal(i, @q.length)
+      @q[i] = i
+    end
+    10.times do | i |
+      assert_equal(20-i, @q.length)
+      @q.delete_min
+    end
+    10.times do | i |
+      assert_equal(10+i, @q.length)
+      @q[i] = i
+    end
+    @q.delete(5)
+    assert_equal(19, @q.length)
+  end
+
+  def test_merge
+    @q1 = @q.class.new
+    @q2 = @q.class.new
+
+    20.times do | i |
+      @q1[i] = i
+      @q2[i+20] = i+20
+    end
+  end
+
+  # Assure that delete min works
+  def test_delete_min
+    assert_equal(nil, @q.delete_min, "Empty queue should pop nil")
+    @q["n1"] = 0
+    assert_equal(["n1", 0], @q.delete_min)
+    @q["n1"] = 0
+    @q["n2"] = -1
+    assert_equal(["n2", -1], @q.delete_min)
+  end
+
+  def test_delete_min_return_key
+    assert_equal(nil, @q.delete_min_return_key, "Empty queue should pop nil")
+    @q["n1"] = 0
+    assert_equal("n1", @q.delete_min_return_key)
+    @q["n1"] = 0
+    @q["n2"] = -1
+    assert_equal("n2", @q.delete_min_return_key)
+  end
+
+  def test_delete_min_return_priority
+    assert_equal(nil, @q.delete_min_return_priority, "Empty queue should pop nil")
+    @q["n1"] = 0
+    assert_equal(0, @q.delete_min_return_priority)
+    @q["n1"] = 0
+    @q["n2"] = -1
+    assert_equal(-1, @q.delete_min_return_priority)
+  end
+
+  def test_has_key?
+    assert(!@q.has_key?(1))
+    @q[1] = 1
+    assert(@q.has_key?(1))
+  end
+
+  def test_empty?
+    assert_equal(true, @q.empty?, "Empty queue should return true on empty?")
+    @q["node1"] = 10
+    assert_equal(false, @q.empty?, "Filled queue should return false on empty?")
+  end
+
+  def test_push
+    20.times do | i |
+      @q.push i, i+10
+    end
+
+    20.times do | i |
+      @q.push i, i
+    end
+    
+    20.times do | i |
+      assert_equal([i, i], @q.delete_min)
+    end
+
+    assert_equal(nil, @q.delete_min)
+  end
+
+  def test_push_pop
+    20.times do | i |
+      @q.push i, i
+    end
+
+    20.times do | i |
+      assert_equal([i, i], @q.delete_min)
+    end
+
+    assert_equal(nil, @q.delete_min)
+  end
+
+  def test_push_decrease_pop
+    50.times do | i |
+      @q.push i, i
+    end
+
+    10.times do | i |
+      assert_equal([i, i], @q.delete_min)
+    end
+
+    10.times do | i |
+      @q[i+10] = i
+    end
+
+    10.times do | i |
+      assert_equal([i+10, i], @q.delete_min)
+    end
+
+    30.times do | i |
+      assert_equal([i+20, i+20], @q.delete_min)
+    end
+
+    assert_equal(nil, @q.delete_min)
+  end
+
+  def test_min_key
+    assert_equal(nil, @q.min_key)
+    @q["node1"] = 0
+    assert_equal("node1", @q.min_key)
+    @q["node2"] = 1
+    assert_equal("node1", @q.min_key)
+    @q["node3"] = -1
+    assert_equal("node3", @q.min_key)
+  end
+
+  def test_min_priority
+    assert_equal(nil, @q.min_priority)
+    @q["node1"] = 0
+    assert_equal(0, @q.min_priority)
+    @q["node2"] = 1
+    assert_equal(0, @q.min_priority)
+    @q["node3"] = -1
+    assert_equal(-1, @q.min_priority)
+  end
+
+  def test_access
+    assert_equal(0, @q["node1"] = 0)
+    assert_equal(["node1", 0], @q.min)
+    assert_equal(1, @q["node2"] = 1)
+    assert_equal(1, @q["node2"])
+    assert_equal("node1", @q.min_key)
+    assert_equal(2, @q["node3"] = 2)
+    assert_equal(2, @q["node3"])
+    assert_equal("node1", @q.min_key)
+    assert_equal(-1, @q["node3"] = -1)
+    assert_equal(-1, @q["node3"])
+    assert_equal("node3", @q.min_key)
+  end
+
+  def test_min
+    assert_equal(nil, @q.min)
+    @q["node1"] = 10
+    assert_equal(["node1", 10], @q.min)
+    @q["node2"] = 5
+    assert_equal(["node2", 5], @q.min)
+  end
+
+  def test_decrease_priority
+
+    20.times do | i |
+      @q.push i, i / 20.0
+    end
+
+    assert_equal([0, 0], @q.delete_min)
+
+    @q[10] = -1
+    @q[11] = -0.5
+
+    [10, 11, (1..9).to_a, (12..19).to_a, nil].flatten.each do | shall |
+      key, priority = *@q.delete_min
+      assert_equal(shall, key)
+    end
+  end
+
+  def test_increase_priority
+    20.times do | i |
+      @q[i] = i
+    end
+    @q[10] = 5
+    assert_equal([0,0], @q.delete_min)
+    assert_equal(10, @q[10] = 10)
+    assert_equal(20, @q[11] = 20)
+    assert_equal([1,1], @q.delete_min)
+  end
+
+  def test_delete
+    @q[1] = 1
+    @q[2] = 2
+    @q[3] = 3
+    assert_equal(1, @q[1])
+    assert_equal([1,1], @q.min)
+    assert_equal([1,1], @q.delete(1))
+    assert_equal(nil, @q[1])
+    assert_equal([2,2], @q.min)
+    assert_equal(nil, @q.delete(1))
+  end
+
+  def test_example_1
+    assert_equal(0, @q["node1"] = 0)
+    assert_equal(1, @q["node2"] = 1)
+    assert_equal("node1", @q.min_key)
+    assert_equal(0, @q[@q.min_key])
+    assert_equal(0, @q.min_priority)
+
+    @q["node2"] = -1
+    assert_equal(["node2", -1], @q.delete_min)
+    assert_equal(nil, @q["node2"])
+    @q["node3"] = 1
+
+    assert_equal(["node3", 1], @q.delete("node3"))
+    assert_equal(nil, @q.delete("node2"))
+  end
+
+  def test_dup
+    ('a'..'z').each do | n |
+      @q[n] = n[0]
+    end
+    qq = @q.dup
+    until @q.empty?
+      assert_equal(@q.delete_min, qq.delete_min)
+    end
+  end
+
+  def test_each
+    ('a'..'z').each do | n |
+      @q[n] = n[0]
+    end
+    queue = ('a'..'z').inject([]) { | r, n | r << [n, n[0]] }
+    assert_equal(queue.sort, @q.to_a.sort)
+  end
+
+  extend self
+end
+
+class CPriorityQueueTest < Test::Unit::TestCase
+  include PriorityQueueTest
+
+  def setup
+    @q = CPriorityQueue.new
+  end
+
+  def test_to_dot    
+    5.times do | i |
+      @q.push "N#{i}", i
+    end
+    @q.delete_min
+    assert_equal(
+    ['digraph fibonacci_heap {',
+    '  NODE [label="N1 (1)",shape=box];',
+    '    NODE [label="N3 (3)",shape=box];',
+    '      NODE [label="N4 (4)",shape=box];',
+    '    NODE -> NODE;',
+    '  NODE -> NODE;',
+    '    NODE [label="N2 (2)",shape=box];',
+    '  NODE -> NODE;',
+    '}',''].join("\n"),  @q.to_dot.gsub(/NODE[0-9]*/, 'NODE'))
+  end
+
+end
+
+class PoorPriorityQueueTest < Test::Unit::TestCase
+  include PriorityQueueTest
+
+  def setup
+    @q = PoorPriorityQueue.new
+  end
+
+end
+
+class RubyPriorityQueueTest < Test::Unit::TestCase
+  include PriorityQueueTest
+
+  def setup
+    @q = RubyPriorityQueue.new
+  end
+
+  def test_private_link_nodes
+    q = RubyPriorityQueue.new
+    q[0] = 0
+    q[1] = 1
+    tc = self
+    q.instance_eval do
+      n0 = @nodes[0]
+      n1 = @nodes[1]
+      n0.right = n0.left = n0
+      n1.right = n1.left = n1
+      tc.assert_equal(n0, link_nodes(n0, n1))
+      tc.assert_equal(n0.child, n1)
+      tc.assert_equal(n1.child, nil)
+      tc.assert_equal(n0.left, n0)
+      tc.assert_equal(n1.left, n1)
+      tc.assert_equal(n0.right, n0)
+      tc.assert_equal(n1.right, n1)
+    end
+    q = RubyPriorityQueue.new
+    q[0] = 0
+    q[1] = 1
+    q.instance_eval do
+      n0 = @nodes[0]
+      n1 = @nodes[1]
+      n0.right = n0.left = n0
+      n1.right = n1.left = n1
+      tc.assert_equal(n0, link_nodes(n1, n0))
+      tc.assert_equal(n0.child, n1)
+      tc.assert_equal(n1.child, nil)
+      tc.assert_equal(n0.left, n0)
+      tc.assert_equal(n1.left, n1)
+      tc.assert_equal(n0.right, n0)
+      tc.assert_equal(n1.right, n1)
+    end
+  end
+
+
+  def test_private_delete_first
+    q = RubyPriorityQueue.new
+    q[0] = 0
+    q[1] = 1
+    q[2] = 2
+    tc = self
+    q.instance_eval do
+      2.times do
+	r = @rootlist
+	tc.assert_equal(r, delete_first)
+	tc.assert_equal(r.right, r)
+	tc.assert_equal(r.left, r)
+	tc.assert_not_equal(r, @rootlist.left)
+	tc.assert_not_equal(r, @rootlist.right)
+      end
+      r = @rootlist
+      tc.assert_equal(r, delete_first)
+      tc.assert_equal(r.right, r)
+      tc.assert_equal(r.left, r)
+      tc.assert_equal(nil, @rootlist)
+
+      tc.assert_equal(nil, delete_first)
+    end
+  end
+end
+