算法导论代码 第12章 二叉查找树

第12章 二叉查找树

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct binary_search_tree_type *tree;
struct tree_node {
	void *key;
	struct tree_node *parent;
	struct tree_node *left;
	struct tree_node *right;
};
struct binary_search_tree_type {
	int (*comp) (const void *, const void *);
	struct tree_node *root;
};
void tree_node_ini(struct tree_node *p, void *key)
{
	p->key = key;
	p->parent = NULL;
	p->left = NULL;
	p->right = NULL;
}

tree tree_create(int (*comp) (const void *, const void *))
{
	tree t = malloc(sizeof(struct binary_search_tree_type));
	t->comp = comp;
	t->root = NULL;
	return t;
}

void tree_delete_node(tree t, struct tree_node *x, void (*free_key) (void *))
{
	if (x != NULL) {
		tree_delete_node(t, x->left, free_key);
		tree_delete_node(t, x->right, free_key);
		free_key(x->key);
		free(x);
	}
}

void tree_destroy(tree t, void (*free_key) (void *))
{
	tree_delete_node(t, t->root, free_key);
	free(t);
}

void tree_inorder_tree_walk(struct tree_node *x, void (*handle) (const void *))
{
	if (x != NULL) {
		tree_inorder_tree_walk(x->left, handle);
		handle(x->key);
		tree_inorder_tree_walk(x->right, handle);
	}
}

struct tree_node *tree_search(tree t, struct tree_node *x, void *key)
{
	if (x == NULL || t->comp(key, x->key) == 0) {
		return x;
	}
	if (t->comp(key, x->key) < 0) {
		return tree_search(t, x->left, key);
	} else {
		return tree_search(t, x->right, key);
	}
}

struct tree_node *tree_search_iterative(tree t, struct tree_node *x, void *key)
{
	while (x != NULL && t->comp(key, x->key) != 0) {
		if (t->comp(key, x->key) < 0) {
			x = x->left;
		} else {
			x = x->right;
		}
	}
	return x;
}

struct tree_node *tree_minimum(struct tree_node *x)
{
	while (x != NULL && x->left != NULL) {
		x = x->left;
	}
	return x;
}

struct tree_node *tree_maximum(struct tree_node *x)
{
	while (x != NULL && x->right != NULL) {
		x = x->right;
	}
	return x;
}

struct tree_node *tree_successor(struct tree_node *x)
{
	if (x->right != NULL) {
		return tree_minimum(x->right);
	}
	struct tree_node *y = x->parent;
	while (y != NULL && x == y->right) {
		x = y;
		y = y->parent;
	}
	return y;
}

struct tree_node *tree_predecessor(struct tree_node *x)
{
	if (x->left != NULL) {
		return tree_maximum(x->left);
	}
	struct tree_node *y = x->parent;
	while (y != NULL && x == y->left) {
		x = y;
		y = y->parent;
	}
	return y;
}

void tree_insert(tree t, struct tree_node *z)
{
	struct tree_node *y = NULL;
	struct tree_node *x = t->root;
	while (x != NULL) {
		y = x;
		if (t->comp(z->key, x->key) < 0) {
			x = x->left;
		} else {
			x = x->right;
		}
	}
	z->parent = y;
	if (y == NULL) {
		t->root = z;
	} else {
		if (t->comp(z->key, y->key) < 0) {
			y->left = z;
		} else {
			y->right = z;
		}
	}
}

void swap(void *a, void *b, size_t elem_size)
{
	if (a == NULL || b == NULL || a == b)
		return;
	char temp[elem_size];	/*变长数组 */
	memcpy(temp, a, elem_size);
	memcpy(a, b, elem_size);
	memcpy(b, temp, elem_size);
}

struct tree_node *tree_delete(tree t, struct tree_node *z)
{
	struct tree_node *y;
	struct tree_node *x;
	if (z->left == NULL || z->right == NULL) {
		y = z;
	} else {
		y = tree_successor(z);
	}
	if (y->left != NULL) {
		x = y->left;
	} else {
		x = y->right;
	}
	if (x != NULL) {
		x->parent = y->parent;
	}
	if (y->parent == NULL) {
		t->root = x;
	} else {
		if (y == y->parent->left) {
			y->parent->left = x;
		} else {
			y->parent->right = x;
		}
	}
	if (y != z) {
		/*要删除的结点y是z的后继,交换z和y结点的内容 */
		swap(&z->key, &y->key, sizeof(void *));
	}
	return y;
}

int cmp_int(const void *p1, const void *p2)
{
	const int *pa = p1;
	const int *pb = p2;
	if (*pa < *pb)
		return -1;
	if (*pa == *pb)
		return 0;
	return 1;
}
void print_key(const void *key)
{
	const int *p = key;
	printf("%d ", *p);
}

int main()
{
	tree t = tree_create(cmp_int);
	for (int i = 0; i < 10; i++) {
		struct tree_node *node = malloc(sizeof(struct tree_node));
		int *ip = malloc(sizeof(int));
		*ip = i;
		tree_node_ini(node, ip);
		tree_insert(t, node);
	}
	printf("中序遍历结果:\n");
	tree_inorder_tree_walk(t->root, print_key);
	printf("\n");
	struct tree_node *max = tree_maximum(t->root);
	printf("max:%d\n", *(int *)max->key);
	struct tree_node *min = tree_minimum(t->root);
	printf("min:%d\n", *(int *)min->key);
	struct tree_node *success = tree_successor(min);
	printf("%d的后继:%d\n", *(int *)min->key, *(int *)success->key);
	struct tree_node *predecessor = tree_predecessor(max);
	printf("%d的前趋:%d\n", *(int *)max->key, *(int *)predecessor->key);
	int k = 0;
	struct tree_node *result = tree_search(t, t->root, &k);
	printf("查找关键字:%d的结果:%s\n", k,
	       result != NULL ? "成功" : "失败");
	struct tree_node *del_node = tree_delete(t, result);
	free(del_node->key);
	free(del_node);
	result = tree_search(t, t->root, &k);
	printf("删除关键字:%d的结果:%s\n", k,
	       result == NULL ? "成功" : "失败");
	printf("中序遍历结果:\n");
	tree_inorder_tree_walk(t->root, print_key);
	printf("\n");
	tree_destroy(t, free);
	return 0;
}