algorithms 0.2.0 → 1.0.0

data/ext/containers/bst/bst.c

@@ -0,0 +1,247 @@
+#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);
+		xfree(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;
+
+void Init_CBst() {
+	id_compare_operator = rb_intern("<=>");
+
+	mContainers = rb_define_module("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);
+}

data/ext/containers/bst/extconf.rb

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

data/ext/containers/deque/deque.c

@@ -19,7 +19,7 @@ void free_nodes(deque_node *node) {
 	deque_node *next;
 	while(node) {
 		next = node->right;
-		free(node);
+		xfree(node);
 		node = next;
 	}
 	return;
@@ -71,7 +71,7 @@ static void deque_free(void *ptr) {
 	if (ptr) {
 		deque *deque = ptr;
 		free_nodes(deque->front);
-		free(deque);
+		xfree(deque);
 	}
 }
 
@@ -200,7 +200,7 @@ static VALUE deque_each_backward(VALUE self) {
 
 static VALUE deque_init(int argc, VALUE *argv, VALUE self)
 {
-	int len, i;
+	long len, i;
 	VALUE ary;
 	
 	if(argc == 0) {

data/ext/containers/rbtree_map/rbtree.c

@@ -22,11 +22,16 @@ typedef struct {
 	rbtree_node *root;
 } rbtree;
 
+typedef struct struct_ll_node {
+	rbtree_node *node;
+	struct struct_ll_node *next;
+} ll_node;
+
 static void recursively_free_nodes(rbtree_node *node) {
 	if(node) {
 		recursively_free_nodes(node->left);
 		recursively_free_nodes(node->right);
-		free(node);
+		xfree(node);
 	}
 	return;
 }
@@ -193,7 +198,7 @@ static rbtree_node* delete_min(rbtree_node *h, VALUE *deleted_value) {
 	if ( !h->left ) {
 		if(deleted_value)
 			*deleted_value = h->value;
-		free(h);
+		xfree(h);
 		return NULL;
 	}
 	
@@ -211,7 +216,7 @@ static rbtree_node* delete_max(rbtree_node *h, VALUE *deleted_value) {
 
 	if ( !h->right ) {
 		*deleted_value = h->value;
-		free(h);
+		xfree(h);
 		return NULL;
 	}
 
@@ -240,7 +245,7 @@ static rbtree_node* delete(rbtree *tree, rbtree_node *node, VALUE key, VALUE *de
 		cmp = tree->compare_function(key, node->key);
 		if ( (cmp == 0) && !node->right ) {
 			*deleted_value = node->value;
-			free(node);
+			xfree(node);
 			return NULL;
 		}
 
@@ -282,7 +287,7 @@ static rbtree* rbt_each(rbtree *tree, void (*each)(rbtree *tree, rbtree_node *no
 
 // Methods to be called in Ruby
 
-static int id_compare_operator;
+static VALUE id_compare_operator;
 
 static int rbtree_compare_function(VALUE a, VALUE b) {
 	if (a == b) return 0;
@@ -292,8 +297,8 @@ static int rbtree_compare_function(VALUE a, VALUE b) {
 		if (x > y) return 1;
 		return -1;
 	}
-	if (TYPE(a) == T_STRING && RBASIC(a)->klass == rb_cString &&
-			TYPE(b) == T_STRING && RBASIC(b)->klass == rb_cString) {
+	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));
@@ -304,19 +309,39 @@ static VALUE rbtree_init(VALUE self)
 	return self;
 }
 
-static void recursively_mark_nodes(rbtree_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 rbtree_mark(void *ptr) {
+	ll_node *current, *new, *last, *old;
 	if (ptr) {
 		rbtree *tree = ptr;
-		recursively_mark_nodes(tree->root);
+		
+		if (tree->root) {
+			current = ALLOC(ll_node);
+			last = current;
+			current->node = tree->root;
+			current->next = NULL;
+
+			while(current) {
+				rb_gc_mark(current->node->key);
+				rb_gc_mark(current->node->value);
+				if (current->node->left) {
+					new = ALLOC(ll_node);
+					new->node = current->node->left;
+					new->next = NULL;
+					last->next = new;
+					last = new;
+				} 
+				if (current->node->right) {
+					new = ALLOC(ll_node);
+					new->node = current->node->right;
+					new->next = NULL;
+					last->next = new;
+					last = new;
+				}
+				old = current;
+				current = current->next;
+				xfree(old);
+			}
+		}
 	}
 }
 
@@ -324,7 +349,7 @@ static void rbtree_free(void *ptr) {
 	if (ptr) {
 		rbtree *tree = ptr;
 		recursively_free_nodes(tree->root);
-		free(tree);
+		xfree(tree);
 	}
 }
 

data/ext/containers/splaytree_map/splaytree.c

@@ -1,24 +1,34 @@
 #include "ruby.h"
 
+#define node_size(x) (((x)==NULL) ? 0 : ((x)->size))
+
+/* 	Using http://www.link.cs.cmu.edu/link/ftp-site/splaying/top-down-size-splay.c as reference,
+	written by D. Sleator <sleator@cs.cmu.edu>, January 1994.
+*/
+
 typedef struct struct_splaytree_node {
 	VALUE key;
 	VALUE value;
+	int size;
 	struct struct_splaytree_node *left;
 	struct struct_splaytree_node *right;
 } splaytree_node;
 
 typedef struct {
 	int (*compare_function)(VALUE key1, VALUE key2);
-	int size;
 	splaytree_node *root;
-	splaytree_node *header;
 } splaytree;
 
+typedef struct struct_ll_node {
+	splaytree_node *node;
+	struct struct_ll_node *next;
+} ll_node;
+
 static void recursively_free_nodes(splaytree_node *node) {
 	if(node) {
 		recursively_free_nodes(node->left);
 		recursively_free_nodes(node->right);
-		free(node);
+		xfree(node);
 	}
 	return;
 }
@@ -29,55 +39,75 @@ static splaytree* get_tree_from_self(VALUE self) {
 	return tree;
 }
 
-static void splay(splaytree *tree, VALUE key) {
-	int cmp, cmp2;
-	splaytree_node *l, *r, *t, *y;
+static splaytree_node* splay(splaytree *tree, splaytree_node *n, VALUE key) {
+	int cmp, cmp2, root_size, l_size, r_size;
+	splaytree_node N;
+	splaytree_node *l, *r, *y;
 	
-	l = tree->header;
-	r = tree->header;
-	t = tree->root;
+	if (!n) return n;
 	
-	tree->header->left = NULL;
-	tree->header->right = NULL;
+	N.left = N.right = NULL;
+	l = r = &N;
+	root_size = node_size(n);
+	l_size = r_size = 0;
 	
 	while(1) {
-		cmp = tree->compare_function(key, t->key);
+		cmp = tree->compare_function(key, n->key);
 		if (cmp == -1) {
-			if (!(t->left)) break;
-			cmp2 = tree->compare_function(key, t->left->key);
+			if (!n->left) break;
+			cmp2 = tree->compare_function(key, n->left->key);
 			if (cmp2 == -1) {
-				y = t->left;
-				t->left = y->right;
-				y->right = t;
-				t = y;
-          		if (!(t->left)) break;
+				y = n->left;
+				n->left = y->right;
+				y->right = n;
+				n->size = node_size(n->left) + node_size(n->right) + 1;
+				n = y;
+          		if (!n->left) break;
 			}
-			r->left = t;
-			r = t;
-			t = t->left;
-		}
-		else if (cmp == 1) {
-			if (!(t->right)) break;
-			cmp2 = tree->compare_function(key, t->right->key);
+			r->left = n;
+			r = n;
+			n = n->left;
+			r_size += 1 + node_size(r->right);
+		} else if (cmp == 1) {
+			if (!n->right) break;
+			cmp2 = tree->compare_function(key, n->right->key);
 			if (cmp2 == 1) {
-				y = t->right;
-				t->right = y->left;
-				y->left = t;
-				t = y;
-          		if (!(t->right)) break;
+				y = n->right;
+				n->right = y->left;
+				y->left = n;
+				n->size = node_size(n->left) + node_size(n->right) + 1;
+				n = y;
+          		if (!n->right) break;
 			}
-			l->right = t;
-			l = t;
-			t = t->right;
+			l->right = n;
+			l = n;
+			n = n->right;
+			l_size += 1 + node_size(l->left);
 		} else {
 			break;
 		}
 	}
-	l->right = t->left;
-	r->left = t->right;
-	t->left = tree->header->right;
-    t->right = tree->header->left;
-	tree->root = t;
+	
+	l_size += node_size(n->left);
+    r_size += node_size(n->right);
+    n->size = l_size + r_size + 1;
+    l->right = r->left = NULL;
+
+	for (y = N.right; y != NULL; y = y->right) {
+		y->size = l_size;
+		l_size -= 1 + node_size(y->left);
+	}
+	for (y = N.left; y != NULL; y = y->left) {
+		y->size = r_size;
+		r_size -= 1 + node_size(y->right);
+	}
+	
+	l->right = n->left;
+	r->left = n->right;
+	n->left = N.right;
+    n->right = N.left;
+	
+	return n;
 }
 
 static int height(splaytree_node *h) {
@@ -95,8 +125,6 @@ static splaytree* create_splaytree(int (*compare_function)(VALUE, VALUE)) {
 	splaytree *tree = ALLOC(splaytree);
 	tree->compare_function = compare_function;
 	tree->root = NULL;
-	tree->size = 0;
-	tree->header = ALLOC(splaytree_node);
 	return tree;
 }
 
@@ -109,44 +137,46 @@ static splaytree_node* create_node(VALUE key, VALUE value) {
 	return new_node;
 }
 
-static void insert(splaytree *tree, VALUE key, VALUE value) {
+static splaytree_node* insert(splaytree *tree, splaytree_node *n, VALUE key, VALUE value) {
 	int cmp;
 	splaytree_node *new_node;
 	
-	if (!(tree->root)) {
-		new_node = create_node(key, value);
-		tree->root = new_node;
-		tree->size += 1;
-		return;
+	if (n) {
+		n = splay(tree, n, key);
+		cmp = tree->compare_function(key, n->key);
+		if (cmp == 0) {
+			n->value = value;
+			return n;
+		}
 	}
-	
-	splay(tree, key);
-	cmp = tree->compare_function(key, tree->root->key);
-	if (cmp == 0) {
-		tree->root->value = value;
-		return;
+	new_node = create_node(key, value);
+	if (!n) {
+		new_node->left = new_node->right = NULL;
 	} else {
-		new_node = create_node(key, value);
-		if (cmp == -1) { 
-			new_node->left = tree->root->left;
-			new_node->right = tree->root;
-			tree->root->left = NULL;
-		} else { /* cmp == 1 */
-			new_node->right = tree->root->right;
-			new_node->left = tree->root;
-			tree->root->right = NULL;
+		cmp = tree->compare_function(key, n->key);
+		if (cmp < 0) {
+			new_node->left = n->left;
+			new_node->right = n;
+			n->left = NULL;
+			n->size = 1 + node_size(n->right);
+		} else {
+			new_node->right = n->right;
+			new_node->left = n;
+			n->right = NULL;
+			n->size = 1 + node_size(n->left);
 		}
-		tree->root = new_node;
-		tree->size += 1;
 	}
+	new_node->size = 1 + node_size(new_node->left) + node_size(new_node->right);
+	return new_node;
 }
 
 static VALUE get(splaytree *tree, VALUE key) {
 	int cmp;
+	
 	if (!tree->root)
 		return Qnil;
-	
-	splay(tree, key);
+		
+	tree->root = splay(tree, tree->root, key);
 	cmp = tree->compare_function(key, tree->root->key);
 	if (cmp == 0) {
 		return tree->root->value;
@@ -154,29 +184,28 @@ static VALUE get(splaytree *tree, VALUE key) {
 	return Qnil;
 }
 
-static VALUE delete(splaytree *tree, VALUE key) {
-	int cmp;
-	splaytree_node *x, *deleted_root;
-	VALUE deleted;
-
-	splay(tree, key);
-	cmp = tree->compare_function(key, tree->root->key);
+static splaytree_node* delete(splaytree *tree, splaytree_node *n, VALUE key, VALUE *deleted) {
+	int cmp, tsize;
+	splaytree_node *x;
+	
+	tsize = n->size;
+	n = splay(tree, n, key);
+	cmp = tree->compare_function(key, n->key);
 	if (cmp == 0) {
-		deleted = tree->root->value;
-		deleted_root = tree->root;
-		if (!(tree->root->left)) {
-			tree->root = tree->root->right;
+		*deleted = n->value;
+		if (!n->left) {
+			x = n->right;
 		} else {
-			x = tree->root->right;
-			tree->root = tree->root->left;
-			splay(tree, key);
-			tree->root->right = x;
+			x = splay(tree, n->left, key);
+			x->right = n->right;
 		}
-		free(deleted_root);
-		tree->size -= 1;
-		return deleted;
+		xfree(n);
+		if (x) {
+			x->size = tsize-1;
+		}
+		return x;
 	}
-	return Qnil;
+	return n;
 }
 
 static splaytree* splaytree_each_node(splaytree *tree, splaytree_node *node, void (*each)(splaytree *tree_, splaytree_node *node_, void* args), void* arguments) {
@@ -201,7 +230,7 @@ static splaytree* splay_each(splaytree *tree, void (*each)(splaytree *tree, spla
 
 // Methods to be called in Ruby
 
-static int id_compare_operator;
+static VALUE id_compare_operator;
 
 static int splaytree_compare_function(VALUE a, VALUE b) {
 	if (a == b) return 0;
@@ -211,8 +240,8 @@ static int splaytree_compare_function(VALUE a, VALUE b) {
 		if (x > y) return 1;
 		return -1;
 	}
-	if (TYPE(a) == T_STRING && RBASIC(a)->klass == rb_cString &&
-			TYPE(b) == T_STRING && RBASIC(b)->klass == rb_cString) {
+	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));
@@ -223,19 +252,39 @@ static VALUE splaytree_init(VALUE self)
 	return self;
 }
 
-static void recursively_mark_nodes(splaytree_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 splaytree_mark(void *ptr) {
+	ll_node *current, *new, *last, *old;
 	if (ptr) {
 		splaytree *tree = ptr;
-		recursively_mark_nodes(tree->root);
+		
+		if (tree->root) {
+			current = ALLOC(ll_node);
+			last = current;
+			current->node = tree->root;
+			current->next = NULL;
+
+			while(current) {
+				rb_gc_mark(current->node->key);
+				rb_gc_mark(current->node->value);
+				if (current->node->left) {
+					new = ALLOC(ll_node);
+					new->node = current->node->left;
+					new->next = NULL;
+					last->next = new;
+					last = new;
+				} 
+				if (current->node->right) {
+					new = ALLOC(ll_node);
+					new->node = current->node->right;
+					new->next = NULL;
+					last->next = new;
+					last = new;
+				}
+				old = current;
+				current = current->next;
+				xfree(old);
+			}
+		}
 	}
 }
 
@@ -243,8 +292,7 @@ static void splaytree_free(void *ptr) {
 	if (ptr) {
 		splaytree *tree = ptr;
 		recursively_free_nodes(tree->root);
-		free(tree->header);
-		free(tree);
+		xfree(tree);
 	}
 }
 
@@ -255,7 +303,7 @@ static VALUE splaytree_alloc(VALUE klass) {
 
 static VALUE splaytree_push(VALUE self, VALUE key, VALUE value) {
 	splaytree *tree = get_tree_from_self(self);
-	insert(tree, key, value);
+	tree->root = insert(tree, tree->root, key, value);
 	return value;
 }
 
@@ -266,7 +314,8 @@ static VALUE splaytree_get(VALUE self, VALUE key) {
 
 static VALUE splaytree_size(VALUE self) {
 	splaytree *tree = get_tree_from_self(self);
-	return INT2NUM(tree->size);
+	if(!tree->root) { return INT2NUM(0); }
+	return INT2NUM(tree->root->size);
 }
 
 static VALUE splaytree_is_empty(VALUE self) {
@@ -317,19 +366,19 @@ static VALUE splaytree_max_key(VALUE self) {
 }
 
 static VALUE splaytree_delete(VALUE self, VALUE key) {
+	VALUE deleted = Qnil;
 	splaytree *tree = get_tree_from_self(self);
 	if(!tree->root)
 		return Qnil;
 	
-	return delete(tree, key);
+	tree->root = delete(tree, tree->root, key, &deleted);
+	return deleted;
 }
 
 static VALUE splaytree_clear(VALUE self) {
 	splaytree *tree = get_tree_from_self(self);
 	recursively_free_nodes(tree->root);
 	tree->root = NULL;
-	tree->size = 0;
-	
 	return Qnil;
 }