algorithms 0.0.1

data/ext/containers/tree_map/Rakefile

@@ -0,0 +1,4 @@
+task :default do
+	sh "make"
+	sh "ruby -e 'require \"c_tree_map\"; puts a = CTreeMap.new; 100.times { |x| a.put(x,x) }; p a.size; p a.get(13); p a.contains?(200)'"
+end

data/ext/containers/tree_map/extconf.rb

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

data/ext/containers/tree_map/rbtree.c

@@ -0,0 +1,395 @@
+#include "ruby.h"
+
+#define RED 1
+#define BLACK 0
+
+#define FALSE 0
+#define TRUE 1
+
+typedef struct struct_rbtree_node {
+	int color;
+	VALUE key;
+	VALUE value;
+	struct struct_rbtree_node *left;
+	struct struct_rbtree_node *right;
+	unsigned int height;
+	unsigned int num_nodes;
+} rbtree_node;
+
+typedef struct {
+	unsigned int black_height;
+	int (*compare_function)(VALUE key1, VALUE key2);
+	rbtree_node *root;
+} rbtree;
+
+void recursively_free_nodes(rbtree_node *node) {
+	if(node) {
+		recursively_free_nodes(node->left);
+		recursively_free_nodes(node->right);
+		free(node);
+	}
+	return;
+}
+
+static rbtree* get_tree_from_self(VALUE self) {
+	rbtree *tree;
+	Data_Get_Struct(self, rbtree, tree);
+	return tree;
+}
+
+int isred(rbtree_node *node) {
+	if(!node) { return FALSE; }
+	
+	if(node->color == RED) { return TRUE; }
+	else return FALSE;
+}
+
+static void colorflip(rbtree_node *node) {
+	node->color = !node->color;
+	node->left->color = !node->left->color;
+	node->right->color = !node->right->color;
+}
+
+static int size(rbtree_node *h) {
+	if(!h) {
+		return 0;
+	}
+	else return h->num_nodes;
+}
+
+static int height(rbtree_node *h) {
+	if(!h) { return 0; }
+	else return h->height;
+}
+
+static rbtree_node* set_num_nodes(rbtree_node *h) {
+	h->num_nodes = size(h->left) + size(h->right) + 1;
+	if ( height(h->left) > height(h->right) ) {
+		h->height = height(h->left) +1;
+	}
+	else {
+		h->height = height(h->right) +1;
+	}
+	return h;
+}
+
+static rbtree_node* rotate_left(rbtree_node *h) {
+	rbtree_node *x = h->right;
+	h->right = x->left;
+	x->left = set_num_nodes(h);
+	x->color = x->left->color;
+	x->left->color = RED;
+	return set_num_nodes(x);	
+}
+
+static rbtree_node* rotate_right(rbtree_node *h) {
+	rbtree_node *x = h->left;
+	h->left = x->right;
+	x->right = set_num_nodes(h);
+	x->color = x->right->color;
+	x->right->color = RED;
+	return set_num_nodes(x);	
+}
+
+static rbtree_node* move_red_left(rbtree_node *h) {
+	colorflip(h);
+	if ( isred(h->right->left) ) {
+		h->right = rotate_right(h->right);
+		h = rotate_left(h);
+		colorflip(h);
+	}
+	return h;
+}
+
+static rbtree_node* move_red_right(rbtree_node *h) {
+	colorflip(h);
+	if ( isred(h->left->left) ) {
+		h = rotate_right(h);
+		colorflip(h);
+	}
+	return h;
+}
+
+static rbtree_node* fixup(rbtree_node *h) {
+	if ( isred(h->right) )
+		h = rotate_left(h);
+	
+	if ( isred(h->left) && isred(h->left->left) )
+		h = rotate_right(h);
+	
+	if ( isred(h->left) && isred(h->right) )
+		colorflip(h);
+		
+	return set_num_nodes(h);
+}
+static rbtree* create_rbtree(int (*compare_function)(VALUE, VALUE)) {
+	rbtree *tree = ALLOC(rbtree);
+	tree->black_height = 0;
+	tree->compare_function = compare_function;
+	tree->root = NULL;
+	return tree;
+}
+
+static rbtree_node* insert(rbtree *tree, rbtree_node *node, VALUE key, VALUE value) {
+	int cmp;
+	
+	// This slot is empty, so we insert our new node
+	if(!node) {
+		rbtree_node *new_node = ALLOC(rbtree_node);
+		new_node->key		= key;
+		new_node->value		= value;
+		new_node->color		= RED;
+		new_node->height	= 1;
+		new_node->num_nodes = 1;
+		new_node->left		= NULL;
+		new_node->right		= NULL;
+		return new_node;
+	}
+	
+	// Do a top-down breaking of 4-nodes
+	if ( isred(node->left) && isred(node->right) ) {
+		colorflip(node);
+	}
+	
+	// Insert left or right, recursively
+	cmp = tree->compare_function(key, node->key);
+	if		(cmp == 0)	{ node->value = value; }
+	else if (cmp == -1) { node->left	= insert(tree, node->left, key, value); }
+	else				{ node->right = insert(tree, node->right, key, value); }
+	
+	// Fix our tree to keep left-lean
+	if (isred(node->right)) { node = rotate_left(node); }
+	if (isred(node->left) && isred(node->left->left)) { node = rotate_right(node); }
+	
+	return set_num_nodes(node);
+}
+
+static VALUE get(rbtree *tree, rbtree_node *node, VALUE key) {
+	int cmp;
+	if (!node) {
+		return Qnil;
+	}
+	
+	cmp = tree->compare_function(key, node->key);
+	if		(cmp == 0)	{ return node->value; }
+	else if (cmp == -1) { return get(tree, node->left, key); }
+	else				{ return get(tree, node->right, key); }
+	
+}
+
+static VALUE min_key(rbtree_node *node) {
+	if (!node->left)
+		return node->key;
+		
+	return min_key(node->left);
+}
+
+static VALUE max_key(rbtree_node *node) {
+	if (!node->right)
+		return node->key;
+	
+	return max_key(node->right);
+}
+
+static rbtree_node* delete_min(rbtree_node *h) { 
+	if ( !(h->left) )
+		return NULL;
+	
+	if ( !isred(h->left) && !isred(h->left->left) )
+		h = move_red_left(h);
+
+	h->left = delete_min(h->left);
+
+	return fixup(h);
+}
+
+static rbtree_node* delete_max(rbtree_node *h) {
+	if ( isred(h->left) )
+		h = rotate_right(h);
+
+	if ( !(h->right) )
+		return NULL;
+
+	if ( !isred(h->right) && !isred(h->right->left) )
+		h = move_red_right(h);
+
+	h->right = delete_max(h->right);
+
+	return fixup(h);
+}
+
+
+static rbtree_node* delete(rbtree *tree, rbtree_node *node, VALUE key, VALUE *deleted_value) {
+	int cmp;
+	VALUE minimum_key;
+	cmp = tree->compare_function(key, node->key);
+	if (cmp == -1) {
+		if ( !isred(node->left) && !isred(node->left->left) )
+			node = move_red_left(node);
+		
+		node->left = delete(tree, node->left, key, deleted_value);
+	}
+	else {
+		if ( isred(node->left) )
+			node = rotate_right(node);
+	
+		if ( (cmp == 0) && !(node->right) ) {
+			*deleted_value = node->value;
+			return NULL;
+		}
+
+		if ( !isred(node->right) && !isred(node->right->left) )
+			node = move_red_right(node);
+		
+		cmp = tree->compare_function(key, node->key);
+		if (cmp == 0) {
+			*deleted_value = node->value;
+			minimum_key = min_key(node->right);
+			node->value = get(tree, node->right, minimum_key);
+			node->key = minimum_key;
+			node->right = delete_min(node->right);
+		}
+		else {
+			node->right = delete(tree, node->right, key, deleted_value);
+		}
+	}
+	return fixup(node);
+}
+
+static rbtree* rbtree_each_node(rbtree *tree, rbtree_node *node, void (*each)(rbtree *tree_, rbtree_node *node_, void* args), void* arguments) {
+	if (!node)
+		return NULL;
+	
+		if (node->left)
+			rbtree_each_node(tree, node->left, each, arguments);
+	(*each)(tree, node, arguments);
+		if (node->right)
+			rbtree_each_node(tree, node->right, each, arguments);
+	return tree;
+}
+
+static rbtree* rbt_each(rbtree *tree, void (*each)(rbtree *tree, rbtree_node *node, void *args), void* arguments) {
+	if (tree->root)
+			rbtree_each_node(tree, tree->root, each, arguments);
+		return tree;
+}
+	
+
+// Methods to be called in Ruby
+
+static int id_compare_operator;
+
+static int rbtree_compare_function(VALUE a, VALUE b) {
+	return FIX2INT(rb_funcall((VALUE) a, id_compare_operator, 1, (VALUE) b));
+}
+
+static VALUE rbtree_init(VALUE self)
+{
+	return self;
+}
+
+static void rbtree_free(rbtree *tree) {
+	recursively_free_nodes(tree->root);
+	free(tree);
+}
+
+static VALUE rbtree_alloc(VALUE klass) {
+	rbtree *tree = create_rbtree(&rbtree_compare_function);
+	return Data_Wrap_Struct(klass, NULL, rbtree_free, tree);
+}
+
+static VALUE rbtree_put(VALUE self, VALUE key, VALUE value) {
+	rbtree *tree = get_tree_from_self(self);
+	tree->root = insert(tree, tree->root, key, value);
+	return value;
+}
+
+static VALUE rbtree_get(VALUE self, VALUE key) {
+	rbtree *tree = get_tree_from_self(self);
+	return get(tree, tree->root, key);
+}
+
+static VALUE rbtree_size(VALUE self) {
+	rbtree *tree = get_tree_from_self(self);
+	return INT2NUM(size(tree->root));
+}
+
+static VALUE rbtree_height(VALUE self) {
+	rbtree *tree = get_tree_from_self(self);
+	return INT2NUM(height(tree->root));
+}
+
+static VALUE rbtree_contains(VALUE self, VALUE key) {
+	rbtree *tree = get_tree_from_self(self);
+	if(get(tree, tree->root, key) == Qnil)
+		return Qfalse;
+	
+	return Qtrue;
+}
+
+static VALUE rbtree_min_key(VALUE self) {
+	rbtree *tree = get_tree_from_self(self);
+	if(!tree->root)
+		return Qnil;
+	
+	return min_key(tree->root);
+}
+
+static VALUE rbtree_max_key(VALUE self) {
+	rbtree *tree = get_tree_from_self(self);
+	if(!tree->root)
+		return Qnil;
+	
+	return max_key(tree->root);
+}
+
+static VALUE rbtree_delete(VALUE self, VALUE key) {
+	VALUE deleted_value;
+	rbtree *tree = get_tree_from_self(self);
+	if(!tree->root)
+		return Qnil;
+	
+	tree->root = delete(tree, tree->root, key, &deleted_value);
+	if(!tree->root)
+		tree->root->color = BLACK;
+	
+	if(deleted_value) {
+		return deleted_value;
+	}
+		
+	return Qnil;
+}
+
+static void rbtree_each_helper(rbtree *tree, rbtree_node *node, void *args) {
+	rb_yield(rb_ary_new3(2, node->key, node->value));
+};
+
+static VALUE rbtree_each(VALUE self) {
+	rbtree *tree = get_tree_from_self(self);
+	rbt_each(tree, &rbtree_each_helper, NULL);
+	return self;
+}
+
+static VALUE cRBTree;
+static VALUE mContainers;
+
+void Init_CTreeMap() {
+	id_compare_operator = rb_intern("<=>");
+	
+	mContainers = rb_define_module("Containers");
+	cRBTree = rb_define_class_under(mContainers, "CTreeMap", rb_cObject);
+	rb_define_alloc_func(cRBTree, rbtree_alloc);
+	rb_define_method(cRBTree, "initialize", rbtree_init, 0);
+	rb_define_method(cRBTree, "put", rbtree_put, 2);
+	rb_define_alias(cRBTree, "[]=", "put");
+	rb_define_method(cRBTree, "size", rbtree_size, 0);
+	rb_define_method(cRBTree, "height", rbtree_height, 0);
+	rb_define_method(cRBTree, "min_key", rbtree_min_key, 0);
+	rb_define_method(cRBTree, "max_key", rbtree_max_key, 0);
+	rb_define_method(cRBTree, "each", rbtree_each, 0);
+	rb_define_method(cRBTree, "get", rbtree_get, 1);
+	rb_define_alias(cRBTree, "[]", "get");
+	rb_define_method(cRBTree, "contains?", rbtree_contains, 1);
+	rb_define_method(cRBTree, "delete", rbtree_delete, 1);
+	rb_include_module(cRBTree, rb_eval_string("Enumerable"));
+}

data/lib/algorithms.rb

@@ -0,0 +1,7 @@
+%w(heap stack queue priority_queue tree_map).each { |file| require "#{File.dirname(__FILE__)}/containers/#{file}" }
+begin
+  require 'CTreeMap'
+  Containers::TreeMap = Containers::CTreeMap
+rescue LoadError # C Version could not be found, try ruby version
+  Containers::TreeMap = Containers::RubyTreeMap
+end

data/lib/containers/heap.rb

@@ -0,0 +1,146 @@
+module Containers
+  # Implemented as a Binomial heap  
+  class Heap
+    class Node
+      attr_accessor :object, :left, :right
+      def initialize(object)
+        @left = nil
+        @right = nil
+        @object = object
+      end
+      
+    end
+    
+    attr_reader :root_array
+    
+    def initialize(ary=[], &block)
+      @compare_function = block_given? ? block : lambda { |x, y| (x <=> y) == -1 }
+      @root_array = []
+      @size = 0
+      if !ary.empty?
+        ary.each { |n| insert(n) }
+      end
+    end
+    
+    def size
+      @size
+    end
+  
+    def peek
+      return nil if @size < 1
+      next_index, next_object = -1, nil
+      
+      @root_array.size.times do |i|
+        unless @root_array[i].nil?
+          if ((next_index == -1) || @compare_function.call(next_object, @root_array[i].object))
+            next_index, next_object = i, @root_array[i].object
+          end
+        end
+      end
+      return next_object
+    end
+  
+    def get_next!
+      return nil if @size < 1
+      next_index, next_object = -1, nil
+      
+      # Remove the root node containing the maximum from its power-of-2 heap
+      @root_array.size.times do |i|
+        unless @root_array[i].nil?
+          if ((next_index == -1) || @compare_function.call(next_object, @root_array[i].object))
+            next_index, next_object = i, @root_array[i].object
+          end
+        end
+      end
+      
+      # Temporarily build a binomial queue containing the remaining parts of the power-of-2 heap, and merge this back into the original
+      temp = []
+      x = @root_array[next_index].left
+      (next_index-1).downto(0) do |i|
+        temp[i] = x
+        x = x.right
+        temp[i].right = nil
+      end
+
+      @root_array[next_index] = nil
+      merge!(temp)
+      @size -= 1
+      return next_object
+    end
+  
+    def insert(object)
+      c = Node.new(object)
+      (0..@root_array.size+1).each do |i|
+        break if c.nil?
+        if @root_array[i].nil?            # The spot is empty, so we use it
+          @root_array[i] = c
+          break
+        end
+        c = pair(c, @root_array[i])       # Otherwise, join the two and proceed
+        @root_array[i] = nil
+      end
+      @size += 1
+      return object
+    end
+  
+    def merge!(otherheap)
+      if (otherheap.class == Containers::Heap || otherheap.class == Containers::MinHeap || otherheap.class == Containers::MaxHeap)
+        othersize = otherheap.size
+        otherheap = otherheap.root_array
+      end
+      a, b, c = @root_array, otherheap, nil
+      if(a.size < b.size) # Make sure 'a' is always bigger
+        a, b = b, a
+      end
+      
+      (0..b.size).each do |i|
+        case bits(c, b[i], a[i])
+        when 2 then a[i] = b[i]
+        when 3 then c = pair(a[i], b[i]); a[i] = nil
+        when 4 then a[i] = c; c = nil
+        when 5 then c = pair(c, a[i]); a[i] = nil
+        when 6..7 then c = pair(c, b[i])
+        end
+      end
+      @root_array = a
+      @size += othersize if othersize
+    end
+    
+    private
+    def bits(c, b, a)
+      4*(c.nil? ? 0 : 1) + 2*(b.nil? ? 0 : 1) + (a.nil? ? 0 : 1)
+    end
+    
+    def pair(p, q)
+      if @compare_function.call(p.object, q.object)
+        p.right = q.left
+        q.left = p
+        return q
+      else
+        q.right = p.left
+        p.left = q
+        return p
+      end
+    end
+  end
+  
+  class MaxHeap < Heap
+    def initialize(ary=[])
+      super(ary) { |x, y| (x <=> y) == -1 }
+    end
+    
+    def get_max!
+      get_next!
+    end
+  end
+  
+  class MinHeap < Heap
+    def initialize(ary=[])
+      super(ary) { |x, y| (x <=> y) == 1 }
+    end
+    
+    def get_min!
+      get_next!
+    end
+  end
+end