二叉排序树代码实现

参照《大话数据结构》 313 ~328页

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

using namespace std;

/* 二叉树存储结构定义*/
typedef int TypeData;
typedef struct BiTreeNode
{
TypeData data;
struct BiTreeNode *lchild, *rchild;
}BITREENODE;

void preOrderBiTree(BITREENODE* T); /* 前序遍历该二叉树 */
void inOrderBiTree(BITREENODE* T); /* 中序遍历该二叉树 */
bool searchBST(BITREENODE* T, TypeData key, BITREENODE* f, BITREENODE** p); /* 在二叉树中查找key是否存在 */
int insertBST(BITREENODE** T, TypeData key); /* 在二叉排序树中插入key */

/* 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素节点
并返回 TRUE， 否则返回FALSE */
bool deleteBST(BITREENODE** T, TypeData key);

/* 从二叉排序树助攻删除节点p，并重接它的左或右子树 */
bool deleteKey(BITREENODE** p);

int main(void)
{
BITREENODE* pRoot = NULL;
int a[10] = {23,56,3,1,100,24,67,77,102,5};
int i = 0;

for(i = 0; i < 10; i++)
{
insertBST(&pRoot,a[i]);
}

/* 中序遍历该二叉排序树 */
inOrderBiTree(pRoot);
cout << endl;

/* 删除节点3 */
deleteBST(&pRoot,3);

/* 中序遍历该二叉排序树 */
inOrderBiTree(pRoot);
cout << endl;

return 0;
}

/* 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素节点
并返回 TRUE， 否则返回FALSE */
bool deleteBST(BITREENODE** T, TypeData key)
{
/* 没有找到 */
if((*T) == NULL)
{
return false;
}
else
{
/* 如果找到，则删除 */
if((*T)->data == key)
{
return deleteKey(T);
}
else if (key < (*T)->data)
{
return deleteBST(&(*T)->lchild,key);
}
else
{
return deleteBST(&(*T)->rchild,key);
}
}
}

/* 从二叉排序树助攻删除节点p，并重接它的左或右子树 */
bool deleteKey(BITREENODE** p)
{
BITREENODE* q = NULL, *s = NULL;

/* 如果右子树为空 */
if ((*p)->rchild == NULL)
{
q = *p;
*p = (*p)->lchild;
free(q);
}
else if((*p)->lchild == NULL) //如果左子树为空
{
q = *p;
*p = (*p)->rchild;
free(q);
}
else //左右子树都不为空
{
q = *p;

/* 转左，然后往右走到尽头，找到待删除的前驱 */
s = (*p)->lchild;
while(s->rchild)
{
q = s;
s = s->rchild;
}

/* s节点指向被删除节点的前驱，把数据直接赋值过来 */
(*p)->data = s->data;

if (q != (*p))
{
/* 重接q的右子树 */
q->rchild = s->lchild;
}
else
{
/* 重接q的左子树 */
q->lchild = s->lchild;
}

free(s);
}
return true;
}

/* 当二排序树不存在关键字等于key的数据元素时，
插入key并返回TRUE，否则返回false */
int insertBST(BITREENODE** T, TypeData key)
{
BITREENODE* p = NULL;
BITREENODE* pNode = NULL;

/* 如果没有查找成功，则把该节点插入 */
if(searchBST(*T,key,NULL,&p) == false)
{

pNode = (BITREENODE*)malloc(sizeof(BITREENODE));
pNode->data = key;
pNode->lchild = pNode->rchild = NULL;

/* 插入pNode为新的节点 */
if(p == NULL)
{
*T = pNode;
}
else if(key < p->data) //插入的为左孩子
{
p->lchild = pNode;
}
else
{
p->rchild = pNode; //插入的为右孩子
}

return true;
}

return false;
}

/* 前序遍历该二叉树 */
void preOrderBiTree(BITREENODE* T)
{
if(T)
{
cout << T->data << " ";
preOrderBiTree(T->lchild);
preOrderBiTree(T->rchild);
}
}

/* 中序遍历该二叉树 */
void inOrderBiTree(BITREENODE* T)
{
if(T)
{
inOrderBiTree(T->lchild);
cout << T->data << " ";
inOrderBiTree(T->rchild);
}
}

/* 递归查找二叉排序树T中是否存在key，
指针f指向T的双亲，其初始调用值为NULL
若查找成功，则指针p指向该数据元素节点，并返回 TRUE
否则指针p指向查找路径上访问最后一个节点并返回 FALSE
*/
bool searchBST(BITREENODE* T, TypeData key, BITREENODE* f, BITREENODE** p)
{
if(NULL == T)
{
*p = f;
return false;
}
else if(T->data == key)
{
*p = T;
return true;
}
else if(key < T->data)
{
/* 递归查找左子树 */
return searchBST(T->lchild, key, T, p);
}
else
{
/* 递归查找右子树 */
return searchBST(T->rchild, key, T, p);
}
}