algorithms 0.0.1 → 0.1.0

data/ext/containers/{priority_queue → bst}/extconf.rb

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

data/ext/containers/deque/deque.c

@@ -0,0 +1,233 @@
+#include "ruby.h"
+
+#define FALSE 0
+#define TRUE 1
+
+typedef struct struct_deque_node {
+	VALUE obj;
+	struct struct_deque_node *left;
+	struct struct_deque_node *right;
+} deque_node;
+
+typedef struct {
+	unsigned int size;
+	deque_node *front;
+	deque_node *back;
+} deque;
+
+void free_nodes(deque_node *node) {
+	deque_node *next;
+	while(node) {
+		next = node->right;
+		free(node);
+		node = next;
+	}
+	return;
+}
+
+void clear_deque(deque *a_deque) {
+	if(a_deque->front)
+		free_nodes(a_deque->front);
+	a_deque->size = 0;
+	a_deque->front = NULL;
+	a_deque->back = NULL;
+	return;
+}
+
+static deque* get_deque_from_self(VALUE self) {
+	deque *a_deque;
+	Data_Get_Struct(self, deque, a_deque);
+	return a_deque;
+}
+
+static deque* create_deque() {
+	deque *a_deque = ALLOC(deque);
+	a_deque->size = 0;
+	a_deque->front = NULL;
+	a_deque->back = NULL;
+	return a_deque;
+}
+
+static deque_node* create_node(VALUE obj) {
+	deque_node *node = ALLOC(deque_node);
+	node->obj = obj;
+	node->left = NULL;
+	node->right = NULL;
+	return node;
+}
+
+static void deque_free(deque *deque) {
+	free_nodes(deque->front);
+	free(deque);
+}
+
+static VALUE deque_alloc(VALUE klass) {
+	deque *deque = create_deque();
+	return Data_Wrap_Struct(klass, NULL, deque_free, deque);
+}
+
+static VALUE deque_push_front(VALUE self, VALUE obj) {
+	deque *deque = get_deque_from_self(self);
+	deque_node *node = create_node(obj);
+	if(deque->front) {
+		node->right = deque->front;
+		deque->front->left = node;
+		deque->front = node; 
+	}
+	else {
+		deque->front = node;
+		deque->back = node;
+	}
+	deque->size++;
+	return obj;
+}
+
+static VALUE deque_push_back(VALUE self, VALUE obj) {
+	deque *deque = get_deque_from_self(self);
+	deque_node *node = create_node(obj);
+	if(deque->back) {
+		node->left = deque->back;
+		deque->back->right = node;
+		deque->back = node; 
+	}
+	else {
+		deque->front = node;
+		deque->back = node;
+	}
+	deque->size++;
+	return obj;
+}
+
+static VALUE deque_pop_front(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	VALUE obj;
+	if(!deque->front)
+		return Qnil;
+	deque_node *node = deque->front;
+	obj = node->obj;
+	if(deque->size == 1) {
+		clear_deque(deque);
+		return obj;
+	}
+	deque->front->right->left = NULL;
+	deque->front = deque->front->right;
+	deque->size--;
+	return obj;
+}
+
+static VALUE deque_front(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	if(deque->front)
+		return deque->front->obj;
+	
+	return Qnil;
+}
+
+static VALUE deque_back(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	if(deque->back)
+		return deque->back->obj;
+	
+	return Qnil;
+}
+
+static VALUE deque_pop_back(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	VALUE obj;
+	if(!deque->back)
+		return Qnil;
+	deque_node *node = deque->back;
+	obj = node->obj;
+	if(deque->size == 1) {
+		clear_deque(deque);
+		return obj;
+	}
+	deque->back->left->right = NULL;
+	deque->back = deque->back->left;
+	deque->size--;
+	return obj;
+}
+
+static VALUE deque_clear(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	clear_deque(deque);
+	return Qnil;
+}
+
+static VALUE deque_size(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	return INT2NUM(deque->size);
+}
+
+static VALUE deque_is_empty(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	return (deque->size == 0) ? Qtrue : Qfalse;
+}
+
+static VALUE deque_each_forward(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	deque_node *node = deque->front;
+	while(node) {
+		rb_yield(node->obj);
+		node = node->right;
+	}
+	return self;
+}
+
+static VALUE deque_each_backward(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	deque_node *node = deque->back;
+	while(node) {
+		rb_yield(node->obj);
+		node = node->left;
+	}
+	return self;
+}
+
+static VALUE deque_init(int argc, VALUE *argv, VALUE self)
+{
+	int len, i;
+	VALUE ary;
+	
+	if(argc == 0) {
+		return self;
+	}
+	else if(argc > 1) {
+		rb_raise(rb_eArgError, "wrong number of arguments");
+	}
+	else {
+		ary = rb_check_array_type(argv[0]);
+		if(!NIL_P(ary)) {
+			len = RARRAY_LEN(ary);
+			for (i = 0; i < len; i++) {
+				deque_push_back(self, RARRAY_PTR(ary)[i]);
+			}
+		}
+	}
+	return self;
+}
+
+static VALUE cDeque;
+static VALUE mContainers;
+
+void Init_CDeque() {
+	mContainers = rb_define_module("Containers");
+	cDeque = rb_define_class_under(mContainers, "CDeque", rb_cObject);
+	rb_define_alloc_func(cDeque, deque_alloc);
+	rb_define_method(cDeque, "initialize", deque_init, -1);
+	rb_define_method(cDeque, "push_front", deque_push_front, 1);
+	rb_define_method(cDeque, "push_back", deque_push_back, 1);
+	rb_define_method(cDeque, "clear", deque_clear, 0);
+	rb_define_method(cDeque, "front", deque_front, 0);
+	rb_define_method(cDeque, "back", deque_back, 0);
+	rb_define_method(cDeque, "pop_front", deque_pop_front, 0);
+	rb_define_method(cDeque, "pop_back", deque_pop_back, 0);
+	rb_define_method(cDeque, "size", deque_size, 0);
+	rb_define_alias(cDeque, "length", "size");
+	rb_define_method(cDeque, "empty?", deque_is_empty, 0);
+	rb_define_method(cDeque, "each_forward", deque_each_forward, 0);
+	rb_define_method(cDeque, "each_backward", deque_each_backward, 0);
+	rb_define_alias(cDeque, "each", "each_forward");
+	rb_define_alias(cDeque, "reverse_each", "each_backward");
+	rb_include_module(cDeque, rb_eval_string("Enumerable"));
+}

data/ext/containers/deque/extconf.rb

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

data/ext/containers/tree_map/extconf.rb

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

data/ext/containers/tree_map/rbtree.c

@@ -122,6 +122,7 @@ static rbtree_node* fixup(rbtree_node *h) {
 		
 	return set_num_nodes(h);
 }
+
 static rbtree* create_rbtree(int (*compare_function)(VALUE, VALUE)) {
 	rbtree *tree = ALLOC(rbtree);
 	tree->black_height = 0;
@@ -146,11 +147,6 @@ static rbtree_node* insert(rbtree *tree, rbtree_node *node, VALUE key, VALUE val
 		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; }
@@ -160,7 +156,9 @@ static rbtree_node* insert(rbtree *tree, rbtree_node *node, VALUE key, VALUE val
 	// 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); }
-	
+	if ( isred(node->left) && isred(node->right) ) {
+		colorflip(node);
+	}
 	return set_num_nodes(node);
 }
 
@@ -191,34 +189,40 @@ static VALUE max_key(rbtree_node *node) {
 	return max_key(node->right);
 }
 
-static rbtree_node* delete_min(rbtree_node *h) { 
-	if ( !(h->left) )
+static rbtree_node* delete_min(rbtree_node *h, VALUE *deleted_value) {
+	if ( !h->left ) {
+		if(deleted_value)
+			*deleted_value = h->value;
+		free(h);
 		return NULL;
+	}
 	
 	if ( !isred(h->left) && !isred(h->left->left) )
 		h = move_red_left(h);
 
-	h->left = delete_min(h->left);
+	h->left = delete_min(h->left, deleted_value);
 
 	return fixup(h);
 }
 
-static rbtree_node* delete_max(rbtree_node *h) {
+static rbtree_node* delete_max(rbtree_node *h, VALUE *deleted_value) {
 	if ( isred(h->left) )
 		h = rotate_right(h);
 
-	if ( !(h->right) )
+	if ( !h->right ) {
+		*deleted_value = h->value;
+		free(h);
 		return NULL;
+	}
 
 	if ( !isred(h->right) && !isred(h->right->left) )
 		h = move_red_right(h);
 
-	h->right = delete_max(h->right);
+	h->right = delete_max(h->right, deleted_value);
 
 	return fixup(h);
 }
 
-
 static rbtree_node* delete(rbtree *tree, rbtree_node *node, VALUE key, VALUE *deleted_value) {
 	int cmp;
 	VALUE minimum_key;
@@ -232,9 +236,11 @@ static rbtree_node* delete(rbtree *tree, rbtree_node *node, VALUE key, VALUE *de
 	else {
 		if ( isred(node->left) )
 			node = rotate_right(node);
-	
-		if ( (cmp == 0) && !(node->right) ) {
+		
+		cmp = tree->compare_function(key, node->key);
+		if ( (cmp == 0) && !node->right ) {
 			*deleted_value = node->value;
+			free(node);
 			return NULL;
 		}
 
@@ -247,7 +253,7 @@ static rbtree_node* delete(rbtree *tree, rbtree_node *node, VALUE key, VALUE *de
 			minimum_key = min_key(node->right);
 			node->value = get(tree, node->right, minimum_key);
 			node->key = minimum_key;
-			node->right = delete_min(node->right);
+			node->right = delete_min(node->right, NULL);
 		}
 		else {
 			node->right = delete(tree, node->right, key, deleted_value);
@@ -273,7 +279,6 @@ static rbtree* rbt_each(rbtree *tree, void (*each)(rbtree *tree, rbtree_node *no
 			rbtree_each_node(tree, tree->root, each, arguments);
 		return tree;
 }
-	
 
 // Methods to be called in Ruby
 
@@ -298,7 +303,7 @@ static VALUE rbtree_alloc(VALUE klass) {
 	return Data_Wrap_Struct(klass, NULL, rbtree_free, tree);
 }
 
-static VALUE rbtree_put(VALUE self, VALUE key, VALUE value) {
+static VALUE rbtree_push(VALUE self, VALUE key, VALUE value) {
 	rbtree *tree = get_tree_from_self(self);
 	tree->root = insert(tree, tree->root, key, value);
 	return value;
@@ -314,13 +319,19 @@ static VALUE rbtree_size(VALUE self) {
 	return INT2NUM(size(tree->root));
 }
 
+static VALUE rbtree_is_empty(VALUE self) {
+	rbtree *tree = get_tree_from_self(self);
+	return (tree->root ? Qfalse : Qtrue);
+}
+
 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) {
+static VALUE rbtree_has_key(VALUE self, VALUE key) {
 	rbtree *tree = get_tree_from_self(self);
+	if(!tree->root) { return Qfalse; }
 	if(get(tree, tree->root, key) == Qnil)
 		return Qfalse;
 	
@@ -350,7 +361,41 @@ static VALUE rbtree_delete(VALUE self, VALUE key) {
 		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 VALUE rbtree_delete_min(VALUE self) {
+	VALUE deleted_value;
+	rbtree *tree = get_tree_from_self(self);
 	if(!tree->root)
+		return Qnil;
+	
+	tree->root = delete_min(tree->root, &deleted_value);
+	if(tree->root)
+		tree->root->color = BLACK;
+	
+	if(deleted_value) {
+		return deleted_value;
+	}
+		
+	return Qnil;
+}
+
+static VALUE rbtree_delete_max(VALUE self) {
+	VALUE deleted_value;
+	rbtree *tree = get_tree_from_self(self);
+	if(!tree->root)
+		return Qnil;
+	
+	tree->root = delete_max(tree->root, &deleted_value);
+	if(tree->root)
 		tree->root->color = BLACK;
 	
 	if(deleted_value) {
@@ -373,23 +418,26 @@ static VALUE rbtree_each(VALUE self) {
 static VALUE cRBTree;
 static VALUE mContainers;
 
-void Init_CTreeMap() {
+void Init_CRBTreeMap() {
 	id_compare_operator = rb_intern("<=>");
 	
 	mContainers = rb_define_module("Containers");
-	cRBTree = rb_define_class_under(mContainers, "CTreeMap", rb_cObject);
+	cRBTree = rb_define_class_under(mContainers, "CRBTreeMap", 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, "push", rbtree_push, 2);
+	rb_define_alias(cRBTree, "[]=", "push");
 	rb_define_method(cRBTree, "size", rbtree_size, 0);
+	rb_define_method(cRBTree, "empty?", rbtree_is_empty, 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, "delete_min", rbtree_delete_min, 0);
+	rb_define_method(cRBTree, "delete_max", rbtree_delete_max, 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, "has_key?", rbtree_has_key, 1);
 	rb_define_method(cRBTree, "delete", rbtree_delete, 1);
 	rb_include_module(cRBTree, rb_eval_string("Enumerable"));
-}
+}