stakach-algorithms 1.0.6 → 1.0.7

data/README.markdown

@@ -1,97 +1,99 @@
-# algorithms
-
-* Official homes are here on github, and at [rubyforge](http://rubyforge.org/projects/algorithms/)
-* Documentation: [http://algorithms.rubyforge.org/](http://algorithms.rubyforge.org/)
-
-## DESCRIPTION:
-
-Started as a [Google Summer of Code 2008](http://code.google.com/soc/2008/ruby/about.html) project
-
-Written by [Kanwei Li](http://kanwei.com/), mentored by Austin Ziegler
-
-Original Proposal: 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, 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:
-
-Done so far:
-
-		* Heaps              Algorithms::Containers::Heap, Containers::MaxHeap, Containers::MinHeap
-		* Priority Queue     Algorithms::Containers::PriorityQueue
-		* Deque              Algorithms::Containers::Deque, Containers::CDeque (C extension), Containers::RubyDeque
-		* Stack              Algorithms::Containers::Stack (uses Deque)
-		* Queue              Algorithms::Containers::Queue (uses Deque)
-		* Red-Black Trees    Algorithms::Containers::RBTreeMap, Containers::CRBTreeMap (C extension), Containers::RubyRBTreeMap
-		* Splay Trees        Algorithms::Containers::SplayTreeMap, Containers::CSplayTreeMap (C extension), Containers::RubySplayTreeMap
-		* Tries              Algorithms::Containers::Trie
-		* Suffix Array       Algorithms::Containers::SuffixArray
-		* kd Tree            Algorithms::Containers::KDTree
-
-		* Search algorithms
-		  - Binary Search            Algorithms::Algorithms::Search.binary_search
-		  - Knuth-Morris-Pratt       Algorithms::Algorithms::Search.kmp_search
-		* Sort algorithms           
-		  - Bubble sort              Algorithms::Algorithms::Sort.bubble_sort
-		  - Comb sort                Algorithms::Algorithms::Sort.comb_sort
-		  - Selection sort           Algorithms::Algorithms::Sort.selection_sort
-		  - Heapsort                 Algorithms::Algorithms::Sort.heapsort
-		  - Insertion sort           Algorithms::Algorithms::Sort.insertion_sort
-		  - Shell sort               Algorithms::Algorithms::Sort.shell_sort
-		  - Quicksort                Algorithms::Algorithms::Sort.quicksort
-		  - Mergesort                Algorithms::Algorithms::Sort.mergesort
-
-## SYNOPSIS:
-
-		require 'rubygems'
-		require 'algorithms'
-		max_heap = Algorithms::Containers::MaxHeap.new
-		
-		# To not have to type "Algorithms::" before each class, use:
-		include Algorithms
-		
-		max_heap = Containers::MaxHeap.new
-		
-		# To not have to type "Containers::" before each class, use:
-		include Containers
-		max_heap = MaxHeap.new
-
-
-## REQUIREMENTS:
-
-* Ruby 1.8 compatible Ruby, or Ruby 1.9, should also work with jRuby
-* C compiler for C extensions (optional, but very much recommended for vast performance benefits)
-
-## INSTALL:
-
-* sudo gem install stakach-algorithms
-
-## LICENSE:
-
-(The MIT License)
-
-Algorithms and Containers project is Copyright (c) 2009 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.
+# algorithms
+
+[![build status](https://secure.travis-ci.org/stakach/algorithms.png)](http://travis-ci.org/stakach/algorithms)
+
+* Official homes are here on github, and at [RubyGems](https://rubygems.org/gems/stakach-algorithms)
+* Documentation: [http://algorithms.rubyforge.org/](http://algorithms.rubyforge.org/)
+
+## DESCRIPTION:
+
+Started as a Google Summer of Code 2008 project
+
+Written by [Kanwei Li](http://kanwei.com/), mentored by Austin Ziegler
+
+Original Proposal: 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, 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:
+
+Done so far:
+
+		* Heaps              Algorithms::Containers::Heap, Containers::MaxHeap, Containers::MinHeap
+		* Priority Queue     Algorithms::Containers::PriorityQueue
+		* Deque              Algorithms::Containers::Deque, Containers::CDeque (C extension), Containers::RubyDeque
+		* Stack              Algorithms::Containers::Stack (uses Deque)
+		* Queue              Algorithms::Containers::Queue (uses Deque)
+		* Red-Black Trees    Algorithms::Containers::RBTreeMap, Containers::CRBTreeMap (C extension), Containers::RubyRBTreeMap
+		* Splay Trees        Algorithms::Containers::SplayTreeMap, Containers::CSplayTreeMap (C extension), Containers::RubySplayTreeMap
+		* Tries              Algorithms::Containers::Trie
+		* Suffix Array       Algorithms::Containers::SuffixArray
+		* kd Tree            Algorithms::Containers::KDTree
+
+		* Search algorithms
+		  - Binary Search            Algorithms::Algorithms::Search.binary_search
+		  - Knuth-Morris-Pratt       Algorithms::Algorithms::Search.kmp_search
+		* Sort algorithms           
+		  - Bubble sort              Algorithms::Algorithms::Sort.bubble_sort
+		  - Comb sort                Algorithms::Algorithms::Sort.comb_sort
+		  - Selection sort           Algorithms::Algorithms::Sort.selection_sort
+		  - Heapsort                 Algorithms::Algorithms::Sort.heapsort
+		  - Insertion sort           Algorithms::Algorithms::Sort.insertion_sort
+		  - Shell sort               Algorithms::Algorithms::Sort.shell_sort
+		  - Quicksort                Algorithms::Algorithms::Sort.quicksort
+		  - Mergesort                Algorithms::Algorithms::Sort.mergesort
+
+## SYNOPSIS:
+
+		require 'rubygems'
+		require 'algorithms'
+		max_heap = Algorithms::Containers::MaxHeap.new
+		
+		# To not have to type "Algorithms::" before each class, use:
+		include Algorithms
+		
+		max_heap = Containers::MaxHeap.new
+		
+		# To not have to type "Containers::" before each class, use:
+		include Containers
+		max_heap = MaxHeap.new
+
+
+## REQUIREMENTS:
+
+* Ruby 1.8 compatible Ruby, or Ruby 1.9, should also work with jRuby
+* C compiler for C extensions (optional, but very much recommended for vast performance benefits)
+
+## INSTALL:
+
+* sudo gem install stakach-algorithms
+
+## LICENSE:
+
+(The MIT License)
+
+Algorithms and Containers project is Copyright (c) 2009 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

@@ -1,27 +1,15 @@
-require 'echoe'
-require "rake/clean"
-OBJ = FileList['**/*.rbc']
-CLEAN.include(OBJ)
- 
-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.2.0"
-  p.runtime_dependencies = []
-end
-
-task :push do
-  sh "git push"    # Rubyforge
-  sh "git push --tags"    # Rubyforge
-  sh "git push gh" # Github
-  sh "git push gh --tags" # Github
-end
-
-task :hanna do
-  sh "rm -fr doc"
-  sh "hanna -SN lib/ -m Algorithms"
-  sh "scp -rq doc/* kanwei@rubyforge.org:/var/www/gforge-projects/algorithms"
-end
-
+require "rake/clean"
+require 'rake/extensiontask'
+
+OBJ = FileList['**/*.rbc']
+CLEAN.include(OBJ)
+
+
+Rake::ExtensionTask.new('algorithms/string')
+Rake::ExtensionTask.new('containers/bst')
+Rake::ExtensionTask.new('containers/deque')
+Rake::ExtensionTask.new('containers/rbtree_map')
+Rake::ExtensionTask.new('containers/splaytree_map')
+
+
+

data/ext/algorithms/string/extconf.rb

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

data/ext/algorithms/string/string.c

@@ -1,70 +1,68 @@
-#include "ruby.h"
-
-int get_min(int a, int b, int c) {
-	int min = a;
-	if (b < min)
-		min = b;
-	if( c < min)
-		min = c;
-	return min;
-}
-
-int levenshtein_distance(VALUE str1, VALUE str2) {
-	int i, j, s1_len, s2_len, *d;
-	char * s = RSTRING_PTR(str1);
-	char * t = RSTRING_PTR(str2);
-	s1_len = RSTRING_LEN(str1); 
-	s2_len = RSTRING_LEN(str2);
-	
-	if (s1_len == 0) {
-		return s2_len;
-	} else if (s2_len == 0) {
-		return s1_len;
-	}
-	
-	// We need one extra col and row for the matrix for starting values
-	s1_len++;
-	s2_len++;
-	
-	d = malloc(sizeof(int) * (s1_len) * (s2_len));
-	
-	for (i = 0; i < s1_len; i++) {
-		d[i] = i; // d[i, 0] = i
-	}
-	for (j = 0; j < s2_len; j++) {
-		d[j*s1_len] = j; // d[0, j] = j
-	}
-	
-	for (i = 1; i < s1_len; i++) {
-		for (j = 1; j < s2_len; j++) {
-			if (s[i-1] == t[j-1]) {
-				d[j * s1_len + i] = d[(j-1) * s1_len + (i-1)];
-			} else {
-				d[j * s1_len + i] = get_min(
-					d[j * s1_len + (i-1)],
-					d[(j-1) * s1_len + i],
-					d[(j-1) * s1_len + (i-1)]
-				) + 1;
-			}
-		}
-	}
-	i = d[s1_len * s2_len -1];
-	free(d);
-	return i;
-}
-
-static VALUE lev_dist(VALUE self, VALUE str1, VALUE str2) {
-	return INT2FIX(levenshtein_distance( str1, str2 ));
-}
-
-static VALUE namespace;
-static VALUE mAlgorithms;
-static VALUE mString;
-
-void Init_CString() {	
-	namespace = rb_define_module("Algorithms");
-	mAlgorithms = rb_define_module_under(namespace,"Algorithms");
-	mString = rb_define_module_under(mAlgorithms, "String");
-	rb_define_singleton_method(mString, "levenshtein_dist", lev_dist, 2);
-}
-
+#include "ruby.h"
+
+long min_three(long a, long b, long c) {
+	long min = a;
+	if (b < min)
+		min = b;
+	if( c < min)
+		min = c;
+	return min;
+}
+
+long levenshtein_distance(VALUE str1, VALUE str2) {
+	long i, j, s1_len, s2_len, *d;
+	char * s = RSTRING_PTR(str1);
+	char * t = RSTRING_PTR(str2);
+	s1_len = RSTRING_LEN(str1);
+	s2_len = RSTRING_LEN(str2);
+	
+	if (s1_len == 0) {
+		return s2_len;
+	} else if (s2_len == 0) {
+		return s1_len;
+	}
+	
+	// We need one extra col and row for the matrix for starting values
+	s1_len++;
+	s2_len++;
+	
+	d = malloc(sizeof(typeof(d)) * (s1_len) * (s2_len));
+	
+	for (i = 0; i < s1_len; i++) {
+		d[i] = i; // d[i, 0] = i
+	}
+	for (j = 0; j < s2_len; j++) {
+		d[j*s1_len] = j; // d[0, j] = j
+	}
+	
+	for (i = 1; i < s1_len; i++) {
+		for (j = 1; j < s2_len; j++) {
+			if (s[i-1] == t[j-1]) {
+				d[j * s1_len + i] = d[(j-1) * s1_len + (i-1)];
+			} else {
+				d[j * s1_len + i] = 1 + min_three(
+					d[j * s1_len + (i-1)],
+					d[(j-1) * s1_len + i],
+					d[(j-1) * s1_len + (i-1)]
+				);
+			}
+		}
+	}
+	i = d[s1_len * s2_len -1];
+	free(d);
+	return i;
+}
+
+static VALUE lev_dist(VALUE self, VALUE str1, VALUE str2) {
+	return LONG2FIX(levenshtein_distance( str1, str2 ));
+}
+
+static VALUE mAlgorithms;
+static VALUE mString;
+
+void Init_CString() {	
+	mAlgorithms = rb_define_module("Algorithms");
+	mString = rb_define_module_under(mAlgorithms, "String");
+	rb_define_singleton_method(mString, "levenshtein_dist", lev_dist, 2);
+}
+

data/ext/containers/bst/bst.c

@@ -1,249 +1,249 @@
-#include "ruby.h"
-
-typedef struct struct_bst_node {
-	VALUE key;
-	VALUE value;
-	struct struct_bst_node *left;
-	struct struct_bst_node *right;
-	struct struct_bst_node *parent;
-} bst_node;
-
-typedef struct struct_bst {
-	bst_node *root;
-	int (*compare_function)(VALUE key1, VALUE key2);
-	unsigned int size; 
-} bst;
-
-static VALUE bst_initialize(VALUE self) {
-	return self;
-}
-
-static bst* get_bst_from_self(VALUE self) {
-	bst *tree;
-	Data_Get_Struct(self, bst, tree);
-	return tree;
-}
-
-static bst* bst_each_node(bst *tree, bst_node *node, void (*each)(bst *tree_, bst_node *node_, void* args), void* arguments) {
-	if (!node)
-		return NULL;
-	
-		if (node->left)
-			bst_each_node(tree, node->left, each, arguments);
-		
-		(*each)(tree, node, arguments);
-		
-		if (node->right)
-			bst_each_node(tree, node->right, each, arguments);
-	return tree;
-}
-
-static bst* bst_each(bst *tree, void (*each)(bst *tree, bst_node *node, void *args), void* arguments) {
-	if (tree->root)
-		bst_each_node(tree, tree->root, each, arguments);
-	return tree;
-}
-
-static int id_compare_operator;
-
-static int bst_compare_function(VALUE a, VALUE b) {
-	if (a == b) return 0;
-	if (FIXNUM_P(a) && FIXNUM_P(b)) {
-		long x = FIX2LONG(a), y = FIX2LONG(b);
-		if (x == y) return 0;
-		if (x > y) return 1;
-		return -1;
-	}
-	if (TYPE(a) == T_STRING && rb_obj_is_kind_of(a, rb_cString) &&
-            TYPE(b) == T_STRING && rb_obj_is_kind_of(b, rb_cString)) {
-		return rb_str_cmp(a, b);
-	}
-	return FIX2INT(rb_funcall((VALUE) a, id_compare_operator, 1, (VALUE) b));
-}
-
-static void insert_element(bst *tree, bst_node **t,bst_node *newElement) {
-	int cmp;
-	bst_node *y = NULL;
-	bst_node *x = *t;
-	while (x != NULL) {
-		y = x;
-		cmp = tree->compare_function(newElement->key, x->key);
-		if (cmp < 0) x = x->left;
-		else x = x->right;
-	}
-	newElement->parent = y;
-	if (y == NULL) *t = newElement;
-	else {
-		cmp = tree->compare_function(newElement->key, y->key);
-		if (cmp < 0)
-		 	y->left = newElement;
-		else 
-			y->right = newElement;
-	}
-}
-
-
-static bst_node* create_node(VALUE key_value,VALUE value) {
-	bst_node *new_node = ALLOC(bst_node);
-	new_node->value = value;
-	new_node->key = key_value;
-	new_node->left = NULL;
-	new_node->right = NULL;
-	new_node->parent = NULL;
-	return new_node;	 
-}
-
-static bst_node* tree_minimum (bst_node *tree) {
-	bst_node *x = tree;
-	while (x->left) x = x->left;
-	return x;
-}
-
-static bst_node* tree_maximum (bst_node *tree) {
-	bst_node *x = tree;
-	while (x->right) x = x->right;
-	return x;
-}
-
-static bst_node* node_successor (bst_node *tree,bst_node *x) {
-	if (x->right) return tree_minimum(x->right);
-	bst_node *y = x->parent;
-	while (y && x == y->right) {
-		x = y;
-		y = x->parent;
-	}
-	return y;
-}
-
-
-static bst_node* delete_node (bst_node **tree,bst_node *tobeDeleted) {
-	bst_node *y,*x;
-
-	if ((tobeDeleted->left == NULL) || (tobeDeleted->right == NULL)) y = tobeDeleted;
-	else y = node_successor(*tree,tobeDeleted);
-
-	if (y->left) x = y->left;
-	else x = y->right;
-
-	if (x) x->parent = y->parent;
-
-	if (y->parent == NULL) {
-		*tree = x;
-		return y;
-	} else if (y == y->parent->left) {
-		y->parent->left = x;
-	} else {
-		y->parent->right = x;
-	}
-
-	if (tobeDeleted != y) tobeDeleted->key = y->key;
-	return y;
-}
-
-static bst_node* search_node(bst *tree, bst_node *node, VALUE key) {
-	bst_node *x = node;
-	int cmp;
-	
-	while(x) {
-		cmp = tree->compare_function(key, x->key);
-		if (cmp == 0) return x;
-		else if (cmp < 0) { x = x->left; }
-		else { x = x->right; }
-	}
-	return NULL;
-}
-
-static void recursively_mark_nodes(bst_node *node) {
-	if(node) {
-		rb_gc_mark(node->key);
-		rb_gc_mark(node->value);
-		recursively_mark_nodes(node->left);
-		recursively_mark_nodes(node->right);
-	}
-}
-
-static void bst_mark(bst *tree) {
-	if (tree) {
-		recursively_mark_nodes(tree->root);
-	}
-}
-
-static void recursively_free_nodes(bst_node *node) {
-	if(node) {
-		recursively_free_nodes(node->left);
-		recursively_free_nodes(node->right);
-		free(node);
-	}
-}
-
-static void bst_free(bst *tree) {
-	if (tree) {
-		recursively_free_nodes(tree->root);
-	}
-}
-
-static bst* create_bst(int (*compare_function)(VALUE, VALUE)) {
-	bst *tree = ALLOC(bst);
-	tree->compare_function = compare_function;
-	tree->root = NULL;
-	tree->size = 0;
-	return tree;
-}
-
-static VALUE bst_alloc(VALUE klass) {
-	bst *tree = create_bst(&bst_compare_function);
-	return Data_Wrap_Struct(klass, bst_mark, bst_free, tree);
-}
-
-static VALUE rb_bst_push_value(VALUE self, VALUE key, VALUE value) {
-	bst *tree = get_bst_from_self(self);
-	insert_element(tree, &(tree->root), create_node(key,value));
-	tree->size++;
-	return self;
-}
-
-static void bst_each_helper(bst *tree, bst_node *node, void *args) {
-	rb_yield(rb_ary_new3(2, node->key, node->value));
-};
-
-static VALUE rb_bst_each(VALUE self) {
-	bst *tree = get_bst_from_self(self);
-	bst_each(tree, &bst_each_helper, NULL);
-	return self;
-}
-
-static VALUE rb_bst_delete(VALUE self, VALUE key) {
-	bst *tree = get_bst_from_self(self);
-	bst_node *tobeDeleted = search_node(tree, tree->root, key);
-	if(tobeDeleted) { 
-		tree->size -= 1;
-		bst_node *deletedNode = delete_node(&(tree->root),tobeDeleted);
-		return deletedNode->value;
-	}
-	return Qnil;
-}
-
-static VALUE rb_bst_size(VALUE self) { 
-	bst *tree;
-	Data_Get_Struct(self,bst,tree);
-	return INT2FIX(tree->size);
-}
-
-static VALUE CBst;
-static VALUE mContainers;
-static VALUE namespace;
-
-void Init_CBst() {
-	id_compare_operator = rb_intern("<=>");
-
-	namespace = rb_define_module("Algorithms");
-	mContainers = rb_define_module_under(namespace,"Containers");
-	CBst = rb_define_class_under(mContainers, "CBst", rb_cObject);
-	rb_define_alloc_func(CBst, bst_alloc);
-	rb_define_method(CBst, "initialize", bst_initialize, 0);
-	rb_define_method(CBst, "push", rb_bst_push_value, 2);
-	rb_define_alias(CBst, "[]=", "push");
-	rb_define_method(CBst, "each", rb_bst_each, 0);
-	rb_define_method(CBst, "delete", rb_bst_delete, 1);
-	rb_define_method(CBst, "size", rb_bst_size, 0);
-}
+#include "ruby.h"
+
+typedef struct struct_bst_node {
+	VALUE key;
+	VALUE value;
+	struct struct_bst_node *left;
+	struct struct_bst_node *right;
+	struct struct_bst_node *parent;
+} bst_node;
+
+typedef struct struct_bst {
+	bst_node *root;
+	int (*compare_function)(VALUE key1, VALUE key2);
+	unsigned int size; 
+} bst;
+
+static VALUE bst_initialize(VALUE self) {
+	return self;
+}
+
+static bst* get_bst_from_self(VALUE self) {
+	bst *tree;
+	Data_Get_Struct(self, bst, tree);
+	return tree;
+}
+
+static bst* bst_each_node(bst *tree, bst_node *node, void (*each)(bst *tree_, bst_node *node_, void* args), void* arguments) {
+	if (!node)
+		return NULL;
+	
+		if (node->left)
+			bst_each_node(tree, node->left, each, arguments);
+		
+		(*each)(tree, node, arguments);
+		
+		if (node->right)
+			bst_each_node(tree, node->right, each, arguments);
+	return tree;
+}
+
+static bst* bst_each(bst *tree, void (*each)(bst *tree, bst_node *node, void *args), void* arguments) {
+	if (tree->root)
+		bst_each_node(tree, tree->root, each, arguments);
+	return tree;
+}
+
+static VALUE id_compare_operator;
+
+static int bst_compare_function(VALUE a, VALUE b) {
+	if (a == b) return 0;
+	if (FIXNUM_P(a) && FIXNUM_P(b)) {
+		long x = FIX2LONG(a), y = FIX2LONG(b);
+		if (x == y) return 0;
+		if (x > y) return 1;
+		return -1;
+	}
+	if (TYPE(a) == T_STRING && rb_obj_is_kind_of(a, rb_cString) &&
+            TYPE(b) == T_STRING && rb_obj_is_kind_of(b, rb_cString)) {
+		return rb_str_cmp(a, b);
+	}
+	return FIX2INT(rb_funcall((VALUE) a, id_compare_operator, 1, (VALUE) b));
+}
+
+static void insert_element(bst *tree, bst_node **t,bst_node *newElement) {
+	int cmp;
+	bst_node *y = NULL;
+	bst_node *x = *t;
+	while (x != NULL) {
+		y = x;
+		cmp = tree->compare_function(newElement->key, x->key);
+		if (cmp < 0) x = x->left;
+		else x = x->right;
+	}
+	newElement->parent = y;
+	if (y == NULL) *t = newElement;
+	else {
+		cmp = tree->compare_function(newElement->key, y->key);
+		if (cmp < 0)
+		 	y->left = newElement;
+		else 
+			y->right = newElement;
+	}
+}
+
+
+static bst_node* create_node(VALUE key_value,VALUE value) {
+	bst_node *new_node = ALLOC(bst_node);
+	new_node->value = value;
+	new_node->key = key_value;
+	new_node->left = NULL;
+	new_node->right = NULL;
+	new_node->parent = NULL;
+	return new_node;	 
+}
+
+static bst_node* tree_minimum (bst_node *tree) {
+	bst_node *x = tree;
+	while (x->left) x = x->left;
+	return x;
+}
+
+static bst_node* tree_maximum (bst_node *tree) {
+	bst_node *x = tree;
+	while (x->right) x = x->right;
+	return x;
+}
+
+static bst_node* node_successor (bst_node *tree,bst_node *x) {
+	if (x->right) return tree_minimum(x->right);
+	bst_node *y = x->parent;
+	while (y && x == y->right) {
+		x = y;
+		y = x->parent;
+	}
+	return y;
+}
+
+
+static bst_node* delete_node (bst_node **tree,bst_node *tobeDeleted) {
+	bst_node *y,*x;
+
+	if ((tobeDeleted->left == NULL) || (tobeDeleted->right == NULL)) y = tobeDeleted;
+	else y = node_successor(*tree,tobeDeleted);
+
+	if (y->left) x = y->left;
+	else x = y->right;
+
+	if (x) x->parent = y->parent;
+
+	if (y->parent == NULL) {
+		*tree = x;
+		return y;
+	} else if (y == y->parent->left) {
+		y->parent->left = x;
+	} else {
+		y->parent->right = x;
+	}
+
+	if (tobeDeleted != y) tobeDeleted->key = y->key;
+	return y;
+}
+
+static bst_node* search_node(bst *tree, bst_node *node, VALUE key) {
+	bst_node *x = node;
+	int cmp;
+	
+	while(x) {
+		cmp = tree->compare_function(key, x->key);
+		if (cmp == 0) return x;
+		else if (cmp < 0) { x = x->left; }
+		else { x = x->right; }
+	}
+	return NULL;
+}
+
+static void recursively_mark_nodes(bst_node *node) {
+	if(node) {
+		rb_gc_mark(node->key);
+		rb_gc_mark(node->value);
+		recursively_mark_nodes(node->left);
+		recursively_mark_nodes(node->right);
+	}
+}
+
+static void bst_mark(bst *tree) {
+	if (tree) {
+		recursively_mark_nodes(tree->root);
+	}
+}
+
+static void recursively_free_nodes(bst_node *node) {
+	if(node) {
+		recursively_free_nodes(node->left);
+		recursively_free_nodes(node->right);
+		free(node);
+	}
+}
+
+static void bst_free(bst *tree) {
+	if (tree) {
+		recursively_free_nodes(tree->root);
+	}
+}
+
+static bst* create_bst(int (*compare_function)(VALUE, VALUE)) {
+	bst *tree = ALLOC(bst);
+	tree->compare_function = compare_function;
+	tree->root = NULL;
+	tree->size = 0;
+	return tree;
+}
+
+static VALUE bst_alloc(VALUE klass) {
+	bst *tree = create_bst(&bst_compare_function);
+	return Data_Wrap_Struct(klass, bst_mark, bst_free, tree);
+}
+
+static VALUE rb_bst_push_value(VALUE self, VALUE key, VALUE value) {
+	bst *tree = get_bst_from_self(self);
+	insert_element(tree, &(tree->root), create_node(key,value));
+	tree->size++;
+	return self;
+}
+
+static void bst_each_helper(bst *tree, bst_node *node, void *args) {
+	rb_yield(rb_ary_new3(2, node->key, node->value));
+};
+
+static VALUE rb_bst_each(VALUE self) {
+	bst *tree = get_bst_from_self(self);
+	bst_each(tree, &bst_each_helper, NULL);
+	return self;
+}
+
+static VALUE rb_bst_delete(VALUE self, VALUE key) {
+	bst *tree = get_bst_from_self(self);
+	bst_node *tobeDeleted = search_node(tree, tree->root, key);
+	if(tobeDeleted) { 
+		tree->size -= 1;
+		bst_node *deletedNode = delete_node(&(tree->root),tobeDeleted);
+		return deletedNode->value;
+	}
+	return Qnil;
+}
+
+static VALUE rb_bst_size(VALUE self) { 
+	bst *tree;
+	Data_Get_Struct(self,bst,tree);
+	return INT2FIX(tree->size);
+}
+
+static VALUE CBst;
+static VALUE mContainers;
+static VALUE namespace;
+
+void Init_CBst() {
+	id_compare_operator = rb_intern("<=>");
+
+	namespace = rb_define_module("Algorithms");
+	mContainers = rb_define_module_under(namespace,"Containers");
+	CBst = rb_define_class_under(mContainers, "CBst", rb_cObject);
+	rb_define_alloc_func(CBst, bst_alloc);
+	rb_define_method(CBst, "initialize", bst_initialize, 0);
+	rb_define_method(CBst, "push", rb_bst_push_value, 2);
+	rb_define_alias(CBst, "[]=", "push");
+	rb_define_method(CBst, "each", rb_bst_each, 0);
+	rb_define_method(CBst, "delete", rb_bst_delete, 1);
+	rb_define_method(CBst, "size", rb_bst_size, 0);
+}