【数据结构】二叉搜索树的插入删除查找

BST.h

#pragma once

#include<stdio.h>

typedef char BTreeType;

/*创建一个二叉搜索树的结构*/
typedef struct BTreeNode{
BTreeType data;
struct BTreeNode* left;
struct BTreeNode* right;
}BTreeNode;

/*初始化一个二叉搜索树*/
void BTreeInit(BTreeNode** btree);

/*在二叉搜索树中插入一个元素*/
void BTreeInsert1(BTreeNode** btree, BTreeType value);
/*使用迭代的方法插入*/
void BTreeInsert2(BTreeNode** btree, BTreeType value);

/*在二叉搜索树中删除一个元素*/
void RemoveBST(BTreeNode** btree, BTreeType del_value);
void DeleteNode(BTreeNode** pnode);

/*在二叉搜索树中查找一个元素*/
BTreeNode* BTreeFind1(BTreeNode* btree, BTreeType sel_value);
BTreeNode* BTreeFind2(BTreeNode* btree, BTreeType sel_value);


BST.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"BinaryTree.h"

/*初始化一个二叉搜索树*/
void BTreeInit(BTreeNode** btree) {
if (btree == NULL) {
return;
}
/*初始化，把根结点初始化为空*/
(*btree) = NULL;
}
/*创建一个二叉树结点*/
BTreeNode* CreateNode(BTreeType value) {

BTreeNode* ptr = (BTreeNode*)malloc(sizeof(BTreeNode));
if (ptr != NULL) {
ptr->data = value;
ptr->left = NULL;
ptr->right = NULL;
}
return ptr;
}
/*在二叉搜索树中插入一个元素*/
void BTreeInsert1(BTreeNode** btree, BTreeType value) {
if (btree == NULL) {
return;
}
/*
**若树为空，则把插入节点作为根结点插入空树
**若树不为空
**1.若插入结点的数据小于根节点的数据，则将其插入左子树
**2.若插入结点的数据大于根节点的数据，则将其插入右子树
*/
if (*btree == NULL) {
BTreeNode* insert = CreateNode(value);
(*btree) = insert;
}
else {
if (value < (*btree)->data) {
BTreeInsert1(&((*btree)->left), value);
}
else {
/*判断是不是相等*/
if (value == (*btree)->data) {
return;
}
BTreeInsert1(&((*btree)->right), value);
}
}
}
/*使用迭代的方法插入*/
void BTreeInsert2(BTreeNode** btree, BTreeType value) {
if (btree == NULL) {
return;
}
/*
**创建两个指针，curr用于检查树中的结点，link用于插入结点
**因为不能改变树根，所以用了两个指针
**cur是查找当前结点的插入位置，*link是指向cur指针的指针
*/
BTreeNode* cur;
BTreeNode** link = btree;

while ((cur = *link)) {
if (value < cur->data) {
link = &cur->left;
}
else {
if (value == cur->data) {
return;
}
link = &cur->right;
}
}

/*如果正常循环，到了这里，*cur已经是叶结点的某个子树了*/
BTreeNode* insert = CreateNode(value);
*link = insert;
}

/*在二叉搜索树中查找一个元素*/
BTreeNode* BTreeFind1(BTreeNode* btree, BTreeType sel_value) {
if (btree == NULL) {
return;
}
BTreeNode* cur = btree;
while (cur != NULL && sel_value != cur->data) {
if (sel_value < cur->data) {
/*查找的值在左子树*/
cur = cur->left;
}
else {
cur = cur->left;
}
}
if (cur != NULL) {
return cur;
}
else {
return NULL;
}
}
BTreeNode* BTreeFind2(BTreeNode* btree, BTreeType sel_value) {
if (btree == NULL) {
return NULL;
}
else if (sel_value == btree->data) {
return btree;
}
else if (sel_value < btree->data) {
BTreeFind2(btree->left, sel_value);
}
else if (sel_value > btree->data) {
BTreeFind2(btree->right, sel_value);
}
}

/*在二叉搜索树中删除一个元素*/
/*
**三种情况
**1.删除的元素结点为叶节点，直接删除
**2.删除的元素结点只有一个左子树结点或者右子树结点，直接删除然后链接删除元素结点的双亲结点
**3.删除的元素结点有两个子结点
** 方法1：找出需要删除的元素结点的左子树中最大的元素结点，并用这个值代替被删除的结点
** 方法2：暂时还不会
*/
void RemoveBST(BTreeNode** btree, BTreeType value) {
if (btree == NULL) {
return;
}
if (*btree == NULL) {
return;
}
else {
if (value == (*btree)->data) {
DeleteNode(btree);
printf("删除成功!");
}
else if (value < (*btree)->data) {
RemoveBST(&(*btree)->left, value);
}
else if (value >(*btree)->data) {
RemoveBST(&(*btree)->right, value);
}
}
}

/*销毁某个结点*/
void DestoryNode(BTreeNode* del_node) {
if (del_node == NULL) {
return;
}
free(del_node);
}

/*删除某个结点*/
void DeleteNode(BTreeNode** pnode) {
if (pnode == NULL) {
return;
}
if (*pnode == NULL) {
return;
}
BTreeNode* qnode, *snode;
if (!(*pnode)->left && !(*pnode)->right) {
/*当前结点为叶节点*/
(*pnode) = NULL;
}
else if (!(*pnode)->left) {
/*
**当前结点左子树为空
**直接删除把右子树的结点链接到当前结点的双亲结点上
*/
//传值删除
qnode = (*pnode)->right;
(*pnode)->data = qnode->data;
(*pnode)->left = qnode->left;
(*pnode)->right = qnode->right;

DestoryNode(qnode);
}
else if (!(*pnode)->right) {
/*当前结点右子树为空*/
qnode = (*pnode)->left;
(*pnode)->data = qnode->data;
(*pnode)->left = qnode->left;
(*pnode)->right = qnode->right;

DestoryNode(qnode);
}
else {
/*
**当前结点左右子树都不为空
**找出当前结点的左子树中最大的结点
*/
qnode = *pnode;
snode = (*pnode)->left;
while (snode->right) {
qnode = snode;
snode = snode->right;
}
(*pnode)->data = snode->data;
/*
**如果执行循环，表示需要删除的结点的左子树没有右孩子，此时需要接左子树
**如果未执行循环，此时需要接右子树
*/
if (qnode == (*pnode)) {
/*此时表示未进入循环*/
qnode->left = snode->left;
DestoryNode(snode);
}
else {
qnode->right = snode->left;
DestoryNode(snode);
}
}
}


test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"BinaryTree.h"
#include<stdlib.h>

#define TESTHEAD printf("------------------%s------------------\n\n",__FUNCTION__)

void TestInsert() {
BTreeNode* btree;
BTreeInit(&btree);
TESTHEAD;
BTreeInsert1(&btree, 'd');
BTreeInsert1(&btree, 'b');
BTreeInsert1(&btree, 'e');
BTreeInsert1(&btree, 'a');
BTreeInsert1(&btree, 'g');
BTreeInsert1(&btree, 'f');

BTreeInsert2(&btree, 'c');
BTreeInsert2(&btree, 'h');
BTreeInsert2(&btree, 'i');
}

void TestFind() {
BTreeNode* btree;
BTreeInit(&btree);
TESTHEAD;
BTreeInsert1(&btree, 'd');
BTreeInsert1(&btree, 'b');
BTreeInsert1(&btree, 'e');
BTreeInsert1(&btree, 'a');
BTreeInsert1(&btree, 'g');
BTreeInsert1(&btree, 'f');

BTreeNode* value;
value = BTreeFind1(btree, 'a');
printf("expect 'a', actual %c\n", value->data);
value = BTreeFind2(btree, 'e');
printf("expect 'e', actual %c \n", value->data);
}

void TestDelete() {
BTreeNode* btree;
BTreeInit(&btree);
TESTHEAD;
BTreeInsert1(&btree, 'g');
BTreeInsert1(&btree, 'd');
BTreeInsert1(&btree, 'b');
BTreeInsert1(&btree, 'a');
BTreeInsert1(&btree, 'c');
BTreeInsert1(&btree, 'e');
BTreeInsert1(&btree, 'f');
BTreeInsert1(&btree, 'h');
BTreeInsert1(&btree, 'j');
BTreeInsert1(&btree, 'i');
BTreeInsert1(&btree, 'k');

RemoveBST(&btree, 'b');
}

int main() {
TestInsert();
TestFind();
TestDelete();
system("pause");
return 0;
}