二叉查找树

#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node *parent;
struct node *left;
struct node *right;
};

struct tree
{
struct node *root;
};

/* 创建一个结点 */
struct node *node_alloc(int val)
{
struct node *ret = (struct node *) malloc(sizeof(struct node));
ret->data        = val;
ret->parent      = NULL;
ret->left        = NULL;
ret->right       = NULL;
return ret;
}

/* 销毁一个结点 */
void node_dealloc(struct node *n)
{
n->parent = NULL;
n->left   = NULL;
n->right  = NULL;
free(n);
}

/* 销毁整个子树 */
void node_destroy(struct node *n)
{
if (n->left != NULL)
{
node_destroy(n->left);
}
if (n->right != NULL)
{
node_destroy(n->right);
}
node_dealloc(n);
}

/* 返回子树中最小的元素 */
struct node *node_minimum(struct node *n)
{
while (n->left != NULL)
{
n = n->left;
}
return n;
}

/* 返回子树中最大的元素 */
struct node *node_maximum(struct node *n)
{
while (n->right != NULL)
{
n = n->right;
}
return n;
}

/* 查找结点在中序遍历序列中的前趋 */
struct node *node_predecessor(struct node *n)
{
struct node *ret;

if (n->left != NULL)
{
return node_maximum(n->left);
}
else
{
ret = n->parent;
while (ret != NULL && ret->left == n)
{
n   = ret;
ret = n->parent;
}
}
return ret;
}

/* 查找结点在中序遍历序列中的后继 */
struct node *node_successor(struct node *n)
{
struct node *ret;

if (n->right != NULL)
{
return node_minimum(n->right);
}
else
{
ret = n->parent;
while (ret != NULL && ret->right == n)
{
n   = ret;
ret = n->parent;
}
}
return ret;
}

/* 输出子树的中序遍历序列 */
void node_inorder_traversal(struct node *n)
{
if (n->left != NULL)
{
node_inorder_traversal(n->left);
}
printf("%d ", n->data);
if (n->right != NULL)
{
node_inorder_traversal(n->right);
}
}

/* 插入 */
void tree_insert(struct tree *t, int val)
{
struct node *parent = NULL;
struct node *child  = t->root;

/* 查找应该插入的位置parent */
while (child != NULL)
{
parent = child;
if (val < child->data)
{
child = child->left;
}
else
{
child = child->right;
}
}

/* 如果parent == NULL说明为空树 */
if (parent == NULL)
{
t->root = node_alloc(val);
}
else
{
child = node_alloc(val);
child->parent = parent;
if (val < parent->data)
{
parent->left = child;
}
else
{
parent->right = child;
}
}
}

/* 删除 */
void tree_erase(struct tree *t, struct node *n)
{
struct node *del;
struct node *child;

if (n == NULL)
{
return;
}

/* 查找应该删除的结点del，del最多只有一个子结点 */
if (n->left == NULL || n->right == NULL)
{
del = n;
}
else
{
del = node_successor(n);
/* 若待删除的结点不为n，将待删除结点的数据赋给n */
n->data = del->data;
}

/* 调整子节点的父结点指针 */
if (del->left != NULL)
{
child = del->left;
}
else
{
child = del->right;
}
if (child != NULL)
{
child->parent = del->parent;
}

/* 若父结点为NULL，说明待删除的结点为树的根结点，此时需要重新调整树的根结点 */
if (del->parent == NULL)
{
t->root = child;
}
/* 调整父结点的子结点指针 */
else if (del->parent->left == del)
{
del->parent->left = child;
}
else
{
del->parent->right = child;
}

/* 销毁结点 */
node_dealloc(del);
}

/* 查找，返回中序遍历序列中第一个匹配的 */
struct node *tree_search(struct tree *t, int val)
{
struct node *ret = t->root;

while (ret != NULL)
{
if (val == ret->data)
{
break;
}
else if (val < ret->data)
{
ret = ret->left;
}
else
{
ret = ret->right;
}
}
return ret;
}

/* 树结构初始化 */
void tree_init(struct tree *t)
{
t->root = NULL;
}

/* 销毁整棵树 */
void tree_destroy(struct tree *t)
{
if (t->root != NULL)
{
node_destroy(t->root);
t->root = NULL;
}
}

/* 输出树的中序遍历序列 */
void tree_inorder_traversal(struct tree *t)
{
if (t->root != NULL)
{
node_inorder_traversal(t->root);
printf("\n");
}
}

int main(void)
{
struct tree t;
struct node *n;

tree_init(&t);

tree_insert(&t, 1);
tree_insert(&t, 2);
tree_insert(&t, 3);
tree_insert(&t, 4);
tree_insert(&t, 5);
tree_inorder_traversal(&t);

n = tree_search(&t, 1);
tree_erase(&t, n);
tree_inorder_traversal(&t);
n = tree_search(&t, 3);
tree_erase(&t, n);
tree_inorder_traversal(&t);
n = tree_search(&t, 4);
tree_erase(&t, n);
tree_inorder_traversal(&t);

tree_destroy(&t);

return 0;
}