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);
}