浅谈数据结构-二叉排序树

构造二叉排序树目的是为了提高查找、插入和删除的效率。其实在构建二叉排序树的时候已经暗藏着排序。因此二叉排序树具有以下几个特点：

如根节点有左子树，则左子树的所有结点都比根节点小。
如根节点有右子树，则右子树所有结点都比根节点大。
根节点的左、右子树也分别为二叉排序树。



二叉树的存储结构

typedef struct BiTree

{

int data;

struct BitTree *lChild,*rChild;

}BitTree,*pBitTree;

二叉排序树算法

二叉排序树的算法分为查找、插入和删除工作，当然在创建树的过程也是查找和插入工作。

一、查找算法

二叉排序树的查找算法，在之前二叉树遍历将结果，原理一样的，就是迭代输出，在遍历时，按照中序遍历，可以将二叉排序树中的数据按递增的顺序将数据输出。

1、代码

/* 二叉树的二叉链表结点结构定义 */
typedef  struct BiTNode    /* 结点结构 */
{
int data;    /* 结点数据 */
struct BiTNode *lchild, *rchild;    /* 左右孩子指针 */
} BiTNode, *BiTree; /**BiTree等价于typedef BiTNode *BiTree*/

/*查找二叉排序树T中是否存在key(递归查找)*/
Status Search(BiTree T, int key, BiTree f, BiTree *p)
{
if (!T)    /*  查找不成功 */
{
*p = f;
return FALSE;
}
else if (key==T->data) /*  查找成功 */
{
*p = T;
return TRUE;
}
else if (key<T->data)
return Search(T->lchild, key, T, p);  /*  在左子树中继续查找 */
else
return Search(T->rchild, key, T, p);  /*  在右子树中继续查找 */
}

2、分析

上述代码中BiTree f 起到了获取在查找过程中获取Bitree中结点为NUll的父节点，当不成功时，传递给P，然后由p传出，最后获取到查找失败的父节点，为了后续的插入操作中，插入结点。

二、插入算法

1、算法思想

思路：比如我们要插入数字20到这棵二叉排序树中。那么步骤如下：

1) 首先将20与根节点进行比较，发现比根节点小，所以继续与根节点的左子树30比较。

2) 发现20比30也要小，所以继续与30的左子树10进行比较。

3) 发现20比10要大，所以就将20插入到10的右子树中。

此时二叉排序树效果如图：

2、代码

/*  当二叉排序树T中不存在关键字等于key的数据元素时， */
/*  插入key并返回TRUE，否则返回FALSE */
Status Insert(BiTree *T, int key)
{
BiTree p,s;
if (!Search(*T, key, NULL, &p)) /* 查找不成功 */
{
s = (BiTree)malloc(sizeof(BiTNode));
s->data = key;
s->lchild = s->rchild = NULL;
if (!p)
*T = s;            /*  插入s为新的根结点 */
else if (key<p->data)
p->lchild = s;    /*  插入s为左孩子 */
else
p->rchild = s;  /*  插入s为右孩子 */
return TRUE;
}
else
return FALSE;  /*  树中已有关键字相同的结点，不再插入 */
}

上述代码充分利用的二叉排序树的查找，在插入前，先查找，如果不成功，进行插入工作。

三、删除结点

1、算法思想

1) 删除的是叶节点(即没有孩子节点的)。比如20，删除它不会破坏原来树的结构，最简单。如图所示。



2) 删除的是单孩子节点。比如90，删除它后需要将它的孩子节点与自己的父节点相连。情形比第一种复杂一些。



3 删除的是有左右孩子的节点。比如根节点50，这里有一个问题就是删除它后将谁做为根节点的问题？利用二叉树的中序遍历，就是右节点的左子树的最左孩子。





分析完了，有了思路之后，下面就开始写代码来实现这些功能了。

2、代码

/* 从二叉排序树中删除结点p，并重接它的左或右子树。 */
Status DeleteBST(BiTree *p)
{
BiTree q,s;
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;
}
(*p)->data=s->data; /*  s指向被删结点的直接前驱（将被删结点前驱的值取代被删结点的值） */
if(q!=*p)
q->rchild=s->lchild; /*  重接q的右子树 */
else
q->lchild=s->lchild; /*  重接q的左子树 */
free(s);
}
return TRUE;
}

/* 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点, */
/* 并返回TRUE；否则返回FALSE。 */
Status Delete(BiTree *T,int key)
{
if(!*T) /* 不存在关键字等于key的数据元素 */
return FALSE;
else
{
if (key==(*T)->data) /* 找到关键字等于key的数据元素 */
return DeleteBST(T);
else if (key<(*T)->data)
return Delete(&(*T)->lchild,key);
else
return Delete(&(*T)->rchild,key);

}
}

3、代码分析

删除结点分为两个个阶段：

1、查找结点位置，就是结点查找的变形，将输出变为删除操作。

2、删除结点，根据结点位置进行不同操作。

四、二叉排序树算法代码

/*包含头文件*/
#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20

typedef int Status;

/* 二叉树的二叉链表结点结构定义 */
typedef  struct BiTNode    /* 结点结构 */
{
int data;    /* 结点数据 */
struct BiTNode *lchild, *rchild;    /* 左右孩子指针 */
} BiTNode, *BiTree; /**BiTree等价于typedef BiTNode *BiTree*/

/*查找二叉排序树T中是否存在key(递归查找)*/
Status Search(BiTree T, int key, BiTree f, BiTree *p)
{
if (!T)    /*  查找不成功 */
{
*p = f;
return FALSE;
}
else if (key==T->data) /*  查找成功 */
{
*p = T;
return TRUE;
}
else if (key<T->data)
return Search(T->lchild, key, T, p);  /*  在左子树中继续查找 */
else
return Search(T->rchild, key, T, p);  /*  在右子树中继续查找 */
}

/*  当二叉排序树T中不存在关键字等于key的数据元素时， */
/*  插入key并返回TRUE，否则返回FALSE */
Status Insert(BiTree *T, int key)
{
BiTree p,s;
if (!Search(*T, key, NULL, &p)) /* 查找不成功 */
{
s = (BiTree)malloc(sizeof(BiTNode));
s->data = key;
s->lchild = s->rchild = NULL;
if (!p)
*T = s;            /*  插入s为新的根结点 */
else if (key<p->data)
p->lchild = s;    /*  插入s为左孩子 */
else
p->rchild = s;  /*  插入s为右孩子 */
return TRUE;
}
else
return FALSE;  /*  树中已有关键字相同的结点，不再插入 */
}

/* 从二叉排序树中删除结点p，并重接它的左或右子树。 */
Status DeleteBST(BiTree *p)
{
BiTree q,s;
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;
}
(*p)->data=s->data; /*  s指向被删结点的直接前驱（将被删结点前驱的值取代被删结点的值） */
if(q!=*p)
q->rchild=s->lchild; /*  重接q的右子树 */
else
q->lchild=s->lchild; /*  重接q的左子树 */
free(s);
}
return TRUE;
}

/* 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点, */
/* 并返回TRUE；否则返回FALSE。 */
Status Delete(BiTree *T,int key)
{
if(!*T) /* 不存在关键字等于key的数据元素 */
return FALSE;
else
{
if (key==(*T)->data) /* 找到关键字等于key的数据元素 */
return DeleteBST(T);
else if (key<(*T)->data)
return Delete(&(*T)->lchild,key);
else
return Delete(&(*T)->rchild,key);

}
}

/*二叉树中序遍历*/
void LDR(BiTree T)
{
if (T!=NULL)
{
LDR(T->lchild);
printf("%d ",T->data);
LDR(T->rchild);
}
}

#define N 10
void main()
{
int i,j;
BiTree T=NULL;

//定义数组和初始化SeqList
int d
={62,88,58,47,35,73,51,99,37,93};

for (i=0;i<N;i++)
{
Insert(&T,d[i]);
}

printf("***************二叉排序树查找(C版)***************\n");
printf("初始化二叉排序树\n中序遍历数据：");
LDR(T);

printf("\n***************删除节点1***************\n");
Delete(&T,93);
printf("删除叶节点93\n中序遍历后：");
LDR(T);

printf("\n***************删除节点2***************\n");
Delete(&T,47);
printf("删除双孩子节点47\n中序遍历后：");
LDR(T);

getchar();
}