二叉搜索树的创建、插入、删除和查找的C语言实现

二叉搜索树（BST）

1.二叉搜索树的概念

二叉搜索树又称二叉排序树，它或者是一棵空数，或者是具有以下性质的二叉树：
1. 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值.
2. 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值.
3. 它的左右子树也分别为二叉搜索树

int a[] = {5,3,4,1,7,8,2,6,0,9};

2.二叉搜索树的操作

查找

插入

在二叉搜索树中插入新元素时，必须先检测该元素是否已经存在。若果已存在，则不进行插入；否则将新元素加入到搜索停止的地方。



删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回，否则要删除的结点可能分下面四种情况：

a.要删除的结点无孩子结点

b.要删除的结点只有左孩子结点

c.要删除的结点只有右孩子结点

d.要删除的结点有左、右孩子结点

BSTree.h

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

#define DataType int

typedef struct BSTreeNode //创建二叉树结点的数据结构
{
struct BSTreeNode* _left;
struct BSTreeNode* _right;
DataType _data;
}BSTreeNode;

BSTreeNode* BuyBSTreeNode(DataType x) //函数创建一个新结点
{
BSTreeNode* tree = (BSTreeNode *)malloc(sizeof(BSTreeNode));
tree->_data = x;
tree->_left = NULL;
tree->_right = NULL;
return tree;
}

int BSTreeInsert(BSTreeNode** ppTree, DataType x) //插入
{
//向二叉搜索树中插入一个新元素，返回0表示成功，-1表示失败
BSTreeNode* cur = *ppTree;
BSTreeNode* cur_pa = NULL;

if (*ppTree == NULL)
{
*ppTree = BuyBSTreeNode(x);
return 0;
}
while (cur)
{
if (x < cur->_data)
{
cur_pa = cur;
cur = cur->_left;
}
else if (x > cur->_data)
{
cur_pa = cur;
cur = cur->_right;
}
else
return -1;
}
if (x < cur_pa->_data)
cur_pa->_left = BuyBSTreeNode(x);
if (x > cur_pa->_data)
cur_pa->_right = BuyBSTreeNode(x);
return 0;
}

const BSTreeNode* BSTreeFind(BSTreeNode** ppTree, DataType x)  //查找
{
BSTreeNode* cur = *ppTree;
if (*ppTree == NULL)
return NULL;
while (cur)
{
if (x < cur->_data)
cur = cur->_left;
else if (x > cur->_data)
cur = cur->_right;
else
return cur;
}
return cur;
}

int BSTreeRemove(BSTreeNode** ppTree, DataType x)  //删除
{
BSTreeNode* cur = *ppTree;
BSTreeNode* cur_pa = cur;
if (*ppTree == NULL)
{
return -1;
}
while (cur)
{
if (x < cur->_data)
{
cur_pa = cur;
cur = cur->_left;
}
else if (x > cur->_data)
{
cur_pa = cur;
cur = cur->_right;
}
else
{
BSTreeNode* del = cur;
//左为空，右为空，左右都不为空
if (cur->_left == NULL)
{
if (cur == cur_pa->_left)
cur_pa->_left = cur->_right;
else if (cur == cur_pa->_right)
cur_pa->_right = cur->_right;
else
*ppTree = cur->_right;
}
else if (cur->_right == NULL)
{
if (cur == cur_pa->_left)
cur_pa->_left = cur->_left;
else if (cur == cur_pa->_right)
cur_pa->_right = cur->_left;
else
*ppTree = cur->_left;
}
else
{
BSTreeNode* sub_pa = cur;
BSTreeNode* sub = cur->_right;
while (sub->_left)
{
sub_pa = sub;
sub = sub->_left;
}
cur->_data = sub->_data;
del = sub;
if (sub_pa->_left == sub)
sub_pa->_left = sub->_right;
else
sub_pa->_right = sub->_right;
}
free(del);
del = NULL;
return 0;
}
}
return -1;
}

//返回0表示成功，-1表示失败
int BSTreeInsertR(BSTreeNode** ppTree, DataType x)//插入（递归写法）
{
if (*ppTree == NULL)
{
*ppTree = BuyBSTreeNode(x);
return 0;
}
if ((*ppTree)->_d
4000
ata > x)
BSTreeInsertR(&(*ppTree)->_left,x);
if ((*ppTree)->_data < x)
BSTreeInsertR(&(*ppTree)->_right, x);
else
return -1;
}

const BSTreeNode* BSTreeFindR(BSTreeNode* tree, DataType x) //递归式查找
{
if (tree == NULL)
return NULL;
if (x < tree->_data)
BSTreeFindR(tree->_left,x);
else if (x > tree->_data)
BSTreeFindR(tree->_right, x);
else
return tree;
}

void BSTreeInOrder(BSTreeNode* tree) //中序遍历二叉树
{//一棵正确的二叉搜索树的中序遍历是符合升序有序排列的
if (tree == NULL)
return;
else
{
BSTreeInOrder(tree->_left);
printf("%d ", tree->_data);
BSTreeInOrder(tree->_right);
}
}
void TestBSTree()
{
//BSTreeNode* tree = NULL;
//BSTreeInsert(&tree, 4);
//BSTreeInsert(&tree, 2);
//BSTreeInsert(&tree, 1);
//BSTreeInsert(&tree, 3);
//BSTreeInsert(&tree, 2);

int a[] = {5,3,4,1,7,8,2,6,0,9};
BSTreeNode* tree = NULL;

for (int i = 0; i < sizeof(a)/sizeof(a[0]); ++i)
{
BSTreeInsert(&tree, a[i]);
}

BSTreeInOrder(tree);
printf("\n");

const BSTreeNode* node = BSTreeFindR(tree, 2);
printf("Find 2? %d\n", node->_data);

//BSTreeRemove(&tree, 4);
//BSTreeRemove(&tree, 8);
//BSTreeRemove(&tree, 3);
//BSTreeRemove(&tree, 7);
//BSTreeRemove(&tree, 5);

////BSTreeInOrder(tree);
////printf("\n");

////BSTreeRemove(&tree, 0);
//BSTreeRemove(&tree, 1);
//BSTreeRemove(&tree, 2);
//BSTreeRemove(&tree, 3);
//BSTreeRemove(&tree, 4);
//BSTreeRemove(&tree, 5);
//BSTreeRemove(&tree, 6);
//BSTreeRemove(&tree, 7);
//BSTreeRemove(&tree, 8);
//BSTreeRemove(&tree, 9);

//BSTreeInOrder(tree);
//printf("\n");
};

Test.c

#include <windows.h>
#include "BinarySearchTree.h"

int main(void)
{
TestBSTree();
system("pause");
return 0;
}