1. 引言
本文主要二叉排序树和平衡二叉树。
2. 二叉排序树
#include "ds.h"
#define N 10 // 数据元素个数
typedef int KeyType; // 设关键字域为整型
struct ElemType // 数据元素类型
{
KeyType key;
int others;
};
typedef ElemType TElemType;
typedef struct BiTNode
{
TElemType data;
BiTNode *lchild, *rchild;
}BiTNode, *BiTree;
#define EQ(a, b) ((a) == (b))
#define LT(a, b) ((a) < (b))
#define LQ(a, b) ((a) <= (b))
#define InitDSTable InitBiTree // 与初始化二叉树的操作同
#define DestroyDSTable DestroyBiTree // 与销毁二叉树的操作同
#define TraverseDSTable InOrderTraverse // 与中序遍历二叉树的操作同
/****************************************************************************************/
Status InitBiTree(BiTree &T)
{
T = NULL;
return OK;
}
void DestroyBiTree(BiTree &T)
{
if (T)
{
if (T->lchild)
DestroyBiTree(T->lchild);
if (T->rchild)
DestroyBiTree(T->rchild);
free(T);
T = NULL;
}
}
Status BiTreeEmpty(BiTree T)
{
if (T)
return FALSE;
else
return TRUE;
}
// 采用二叉链表存储结构，Visit是对数据元素操作的应用函数。算法6.3，有改动
// 中序遍历二叉树T的非递归算法(利用栈)，对每个数据元素调用函数Visit
void InOrderTraverse(BiTree T, void(*Visit)(TElemType))
{
if(T) // T不空
{
InOrderTraverse(T->lchild,Visit); // 先中序遍历左子树
Visit(T->data); // 再中序访问根结点
InOrderTraverse(T->rchild,Visit); // 最后中序遍历右子树
}
printf("\n");
}
// 初始条件：二叉树T存在，Visit是对结点操作的应用函数
// 操作结果：后序递归遍历T，对每个结点调用函数Visit一次且仅一次
void PostOrderTraverse(BiTree T,void(*Visit)(TElemType))
{
if(T) // T不空
{
PostOrderTraverse(T->lchild,Visit); // 先后序遍历左子树
PostOrderTraverse(T->rchild,Visit); // 再后序遍历右子树
Visit(T->data); // 最后访问根结点
}
}
// 初始条件：二叉树T存在，Visit是对结点操作的应用函数
// 操作结果：先序递归遍历T，对每个结点调用函数Visit一次且仅一次
void PreOrderTraverse(BiTree T,void(*Visit)(TElemType))
{
if(T) // T不空
{
Visit(T->data); // 先访问根结点
PreOrderTraverse(T->lchild,Visit); // 再先序遍历左子树
PreOrderTraverse(T->rchild,Visit); // 最后先序遍历右子树
}
}
/*****************************************************************************************************************************/
// 在根指针T所指二叉排序树中递归地查找某关键字等于key的数据元素，
// 若查找成功，则返回指向该数据元素结点的指针，否则返回空指针。算法9.5(a)
BiTree SearchBST(BiTree T, KeyType key)
{
if (!T || EQ(T->data.key, key))
return T;
else if (LT(key, T->data.key))
return SearchBST(T->lchild, key);
else
return SearchBST(T->rchild, key);
}
// 在根指针T所指二叉排序树中递归地查找其关键字等于key的数据元素，若查找
// 成功，则指针p指向该数据元素结点，并返回TRUE，否则指针p指向查找路径上
// 访问的最后一个结点并返回FALSE，指针f指向T的双亲，其初始调用值为NULL
Status SearchBST(BiTree &T, KeyType key, BiTree f, BiTree &p)
{
if (!T) // 查找不成功
{
p = f;
return FALSE;
}
else if EQ(key, T->data.key) // 查找成功
{
p = T;
return TRUE;
}
else if (LT(key, T->data.key))
return SearchBST(T->lchild, key, T, p); // 在左子树中继续查找
else
return SearchBST(T->rchild, key, T, p); // 在右子树中继续查找
}
// 当二叉排序树T中不存在关键字等于e.key的元素时，插入e并返回TRUE，否则返回FALSE。算法9.6
Status InsertBST(BiTree &T, ElemType e)
{
BiTree p, s;
if (!SearchBST(T, e.key, NULL, p)) // 查找不成功
{
s = (BiTree)malloc(sizeof(BiTNode));
s->data = e;
s->lchild = s->rchild = NULL;
if (!p)
T = s; // 被插结点*s为新的根结点
else if (LT(e.key, p->data.key))
p->lchild = s; // 被插结点*s为左孩子
else
p->rchild = s; // 被插结点*s为右孩子
return TRUE;
}
else
return FALSE; // 树中已有关键字相同的结点，不再插入
}
// 从二叉排序树中删除结点p，并重接它的左或右子树。算法9.8
void Delete(BiTree &p)
{
BiTree q, s;
if (!p->rchild) // p的右子树空则只需重接它的左子树(待删结点是叶子也走此分支)
{
q = p;
p = p->lchild;
free(q);
}
else if (!p->lchild) // p的左子树空，只需重接它的右子树
{
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) // 情况1
q->rchild = s->lchild; // 重接*q的右子树
else
q->lchild = s->lchild; // 重接*q的左子树
free(s);
}
}
// 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点，
// 并返回TRUE；否则返回FALSE。算法9.7
Status DeleteBST(BiTree &T, KeyType key)
{
if (!T) // 不存在关键字等于key的数据元素
return FALSE;
else
{
if EQ(key, T->data.key) // 找到关键字等于key的数据元素
Delete(T);
else if LT(key, T->data.key)
DeleteBST(T->lchild, key);
else
DeleteBST(T->rchild, key);
return TRUE;
}
}
void print(ElemType c)
{
printf("(%d,%d) ",c.key,c.others);
}
int main()
{
BiTree dt,p;
int i;
KeyType j;
ElemType r[N]={{45,1},{12,2},{53,3},{3,4},{37,5},{24,6},{100,7},{61,8},{90,9},{78,10}};
// 以教科书图9.7(a)为例，另加除关键字之外的其他信息
InitDSTable(dt); // 构造空表
for(i=0;i<N;i++)
InsertBST(dt,r[i]); // 依次插入数据元素
TraverseDSTable(dt,print);
printf("\n请输入待查找的值: ");
scanf("%d",&j);
p=SearchBST(dt,j);
if(p)
{
printf("表中存在此值。");
DeleteBST(dt,j);
printf("删除此值后:\n");
TraverseDSTable(dt,print);
printf("\n");
}
else
printf("表中不存在此值\n");
DestroyDSTable(dt);
}
3. 平衡二叉树
#include "ds.h"
#define N 5 // 数据元素个数
typedef char KeyType; // 设关键字域为字符型
struct ElemType // 数据元素类型
{
KeyType key;
int order;
};
typedef ElemType TElemType;
typedef struct BSTNode
{
ElemType data;
int bf;
BSTNode *lchild, *rchild;
}BSTNode, *BSTree;
typedef BSTree BiTree;
#define EQ(a, b) ((a) == (b))
#define LT(a, b) ((a) < (b))
#define LQ(a, b) ((a) <= (b))
#define InitDSTable InitBiTree // 与初始化二叉树的操作同
#define DestroyDSTable DestroyBiTree // 与销毁二叉树的操作同
#define TraverseDSTable InOrderTraverse // 与中序遍历二叉树的操作同
// 对以*p为根的二叉排序树作右旋处理，处理之后p指向新的树
// 根结点，即旋转处理之前的左子树的根结点。算法9.9
void R_Rotate(BSTree &p)
{
BSTree lc;
lc = p->lchild; // lc指向p的左子树根结点
p->lchild = lc->rchild; // lc的右子树挂接为p的左子树
lc->rchild = p;
p = lc; // p指向新的根结点
}
// 对以*p为根的二叉排序树作左旋处理，处理之后p指向新的树
// 根结点，即旋转处理之前的右子树的根结点。算法9.10
void L_Rotate(BSTree &p)
{
BSTree rc;
rc = p->rchild; // rc指向p的右子树根结点
p->rchild = rc->lchild; // rc的左子树挂接为p的右子树
rc->lchild = p;
p = rc; // p指向新的根结点
}
#define LH +1 // 左高
#define EH 0 // 等高
#define RH -1 // 右高
// 对以指针T所指结点为根的二叉树作左平衡旋转处理，本算法结束时，
// 指针T指向新的根结点。算法9.12
void LeftBalance(BSTree &T)
{
BSTree lc, rd;
lc = T->lchild;
// 检查*T的左子树的平衡度，并作相应平衡处理
switch (lc->bf)
{
case LH: // 新结点插入在*T的左孩子的左子树上，要作单右旋处理
T->bf = lc->bf = EH;
R_Rotate(T);
break;
case RH: // 新结点插入在*T的左孩子的右子树上，要作双旋处理
rd = lc->rchild;
switch (rd->bf)
{
// 修改*T及其左孩子的平衡因子
case LH: T->bf=RH;
lc->bf=EH;
break;
case EH: T->bf=lc->bf=EH;
break;
case RH: T->bf=EH;
lc->bf=LH;
}
rd->bf=EH;
L_Rotate(T->lchild); // 对*T的左子树作左旋平衡处理
R_Rotate(T); // 对*T作右旋平衡处理
}
}
// 对以指针T所指结点为根的二叉树作右平衡旋转处理，本算法结束时，
// 指针T指向新的根结点
void RightBalance(BSTree &T)
{
BSTree rc, rd;
rc = T->rchild;
// 检查*T的右子树的平衡度，并作相应平衡处理
switch (rc->bf)
{
case RH: // 新结点插入在*T的右孩子的右子树上，要作单左旋处理
T->bf = rc->bf = EH;
L_Rotate(T);
break;
case LH: // 新结点插入在*T的右孩子的左子树上，要作双旋处理
rd = rc->lchild; // rd指向*T的右孩子的左子树根
switch (rd->bf)
{
// 修改*T及其右孩子的平衡因子
case RH: T->bf=LH;
rc->bf=EH;
break;
case EH: T->bf=rc->bf=EH;
break;
case LH: T->bf=EH;
rc->bf=RH;
}
rd->bf=EH;
R_Rotate(T->rchild); // 对*T的右子树作右旋平衡处理
L_Rotate(T); // 对*T作左旋平衡处理
}
}
// 若在平衡的二叉排序树T中不存在和e有相同关键字的结点，则插入一个
// 数据元素为e的新结点，并返回1，否则返回0。若因插入而使二叉排序树
// 失去平衡，则作平衡旋转处理，布尔变量taller反映T长高与否。算法9.11
Status InsertAVL(BSTree &T, ElemType e, Status &taller)
{
if(!T) // 插入新结点，树“长高”，置taller为TRUE
{
T = (BSTree)malloc(sizeof(BSTNode));
T->data = e;
T->lchild = T->rchild = NULL;
T->bf = EH;
taller = TRUE;
}
else
{
// 树中已存在和e有相同关键字的结点则不再插入
if EQ(e.key, T->data.key)
{
taller = FALSE;
return FALSE;
}
// 应继续在*T的左子树中进行搜索
if LT(e.key, T->data.key)
{
if (!InsertAVL(T->lchild, e, taller)) // 未插入
return FALSE;
if (taller) // 已插入到*T的左子树中且左子树“长高”
{
switch (T->bf) // 检查*T的平衡度
{
case LH: // 原本左子树比右子树高，需要作左平衡处理
LeftBalance(T);
taller=FALSE;
break;
case EH: // 原本左、右子树等高，现因左子树增高而使树增高
T->bf=LH;
taller=TRUE;
break;
case RH: T->bf=EH; // 原本右子树比左子树高，现左、右子树等高
taller=FALSE;
}
}
}
// 应继续在*T的右子树中进行搜索
else
{
if (!InsertAVL(T->rchild, e, taller)) // 未插入
return FALSE;
if (taller) // 已插入到T的右子树且右子树“长高”
{
switch (T->bf)
{
case LH: // 原本左子树比右子树高，现左、右子树等高
T->bf = EH;
taller = FALSE;
break;
case EH: // 原本左、右子树等高，现因右子树增高而使树增高
T->bf = RH;
taller = TRUE;
break;
case RH: // 原本右子树比左子树高，需要作右平衡处理
RightBalance(T);
taller = FALSE;
}
}
}
}
return TRUE;
}
/****************************************************************************************/
Status InitBiTree(BiTree &T)
{
T = NULL;
return OK;
}
void DestroyBiTree(BiTree &T)
{
if (T)
{
if (T->lchild)
DestroyBiTree(T->lchild);
if (T->rchild)
DestroyBiTree(T->rchild);
free(T);
T = NULL;
}
}
Status BiTreeEmpty(BiTree T)
{
if (T)
return FALSE;
else
return TRUE;
}
// 采用二叉链表存储结构，Visit是对数据元素操作的应用函数。算法6.3，有改动
// 中序遍历二叉树T的非递归算法(利用栈)，对每个数据元素调用函数Visit
void InOrderTraverse(BiTree T, void(*Visit)(TElemType))
{
if(T) // T不空
{
InOrderTraverse(T->lchild,Visit); // 先中序遍历左子树
Visit(T->data); // 再中序访问根结点
InOrderTraverse(T->rchild,Visit); // 最后中序遍历右子树
}
printf("\n");
}
// 初始条件：二叉树T存在，Visit是对结点操作的应用函数
// 操作结果：后序递归遍历T，对每个结点调用函数Visit一次且仅一次
void PostOrderTraverse(BiTree T,void(*Visit)(TElemType))
{
if(T) // T不空
{
PostOrderTraverse(T->lchild,Visit); // 先后序遍历左子树
PostOrderTraverse(T->rchild,Visit); // 再后序遍历右子树
Visit(T->data); // 最后访问根结点
}
}
// 初始条件：二叉树T存在，Visit是对结点操作的应用函数
// 操作结果：先序递归遍历T，对每个结点调用函数Visit一次且仅一次
void PreOrderTraverse(BiTree T,void(*Visit)(TElemType))
{
if(T) // T不空
{
Visit(T->data); // 先访问根结点
PreOrderTraverse(T->lchild,Visit); // 再先序遍历左子树
PreOrderTraverse(T->rchild,Visit); // 最后先序遍历右子树
}
}
/*****************************************************************************************************************************/
// 在根指针T所指二叉排序树中递归地查找某关键字等于key的数据元素，
// 若查找成功，则返回指向该数据元素结点的指针，否则返回空指针。算法9.5(a)
BiTree SearchBST(BiTree T, KeyType key)
{
if (!T || EQ(T->data.key, key))
return T;
else if (LT(key, T->data.key))
return SearchBST(T->lchild, key);
else
return SearchBST(T->rchild, key);
}
// 在根指针T所指二叉排序树中递归地查找其关键字等于key的数据元素，若查找
// 成功，则指针p指向该数据元素结点，并返回TRUE，否则指针p指向查找路径上
// 访问的最后一个结点并返回FALSE，指针f指向T的双亲，其初始调用值为NULL
Status SearchBST(BiTree &T, KeyType key, BiTree f, BiTree &p)
{
if (!T) // 查找不成功
{
p = f;
return FALSE;
}
else if EQ(key, T->data.key) // 查找成功
{
p = T;
return TRUE;
}
else if (LT(key, T->data.key))
return SearchBST(T->lchild, key, T, p); // 在左子树中继续查找
else
return SearchBST(T->rchild, key, T, p); // 在右子树中继续查找
}
// 从二叉排序树中删除结点p，并重接它的左或右子树。算法9.8
void Delete(BiTree &p)
{
BiTree q, s;
if (!p->rchild) // p的右子树空则只需重接它的左子树(待删结点是叶子也走此分支)
{
q = p;
p = p->lchild;
free(q);
}
else if (!p->lchild) // p的左子树空，只需重接它的右子树
{
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) // 情况1
q->rchild = s->lchild; // 重接*q的右子树
else
q->lchild = s->lchild; // 重接*q的左子树
free(s);
}
}
// 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点，
// 并返回TRUE；否则返回FALSE。算法9.7
Status DeleteBST(BiTree &T, KeyType key)
{
if (!T) // 不存在关键字等于key的数据元素
return FALSE;
else
{
if EQ(key, T->data.key) // 找到关键字等于key的数据元素
Delete(T);
else if LT(key, T->data.key)
DeleteBST(T->lchild, key);
else
DeleteBST(T->rchild, key);
return TRUE;
}
}
void print(ElemType c)
{
printf("(%d,%d)",c.key,c.order);
}
int main()
{
BSTree dt,p;
Status k;
int i;
KeyType j;
ElemType r[N]={{13,1},{24,2},{37,3},{90,4},{53,5}}; // (以教科书图9.12为例)
InitDSTable(dt); // 初始化空树
for(i=0;i<N;i++)
InsertAVL(dt,r[i],k); // 建平衡二叉树
PreOrderTraverse(dt,print); // 先序遍历平衡二叉树
printf("先序遍历平衡二叉树\n");
TraverseDSTable(dt,print); // 按关键字顺序遍历二叉树
printf("\n请输入待查找的关键字: ");
scanf("%d",&j);
p=SearchBST(dt,j); // 查找给定关键字的记录
if(p)
print(p->data);
else
printf("表中不存在此值");
printf("\n");
DestroyDSTable(dt);
}