二叉树的基本操作

定义声明

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

typedef char TElemType;

typedef struct BiTNode
{
	TElemType data;
	struct BiTNode *lchild, *rchild;//左右孩子指针 
}BiTNode, *BiTree;
 
bool InitBiTree(BiTree &T);//初始化二叉树
bool CreateBiTree(BiTree &T);//按先序序列建立二叉树的二叉链表
bool BiTreeEmpty(BiTree &T);//树判空
int BiTreeDepth(BiTree T);//求二叉树的深度
void BiTreeWidth(BiTree T, int k, int a[], int &max);//求二叉树的宽度
int BiTreeCount(BiTree T);//输出二叉树总结点个数
bool LeafPrintf(BiTree T);//输出所有叶子结点
void PreOrderTraverse(BiTree T);//输出二叉树的先序遍历序列
void InOrderTraverse(BiTree T);//输出二叉树的中序遍历序列
void PostOrderTraverse(BiTree T);//输出二叉树的后序遍历序列
void SwapTree(BiTree &T);//交换每一个结点的左右子树
bool BiTreeSimilar(BiTree B1, BiTree B2);//判断二叉树是否相似

主函数

int main()
{
	BiTree T;
	if(InitBiTree(T))
		printf("二叉树T初始化成功！\n");
		
	printf("构造二叉树（空格表示空树）\n");
	CreateBiTree(T);
	
	if(BiTreeEmpty(T))
		printf("二叉树为空！\n");
	else
		printf("二叉树不为空！\n");
		
	printf("二叉树的深度为：%d\n", BiTreeDepth(T));
	
	int a[MAXWIDTH];
	memset(a, 0, sizeof(a));
	int k = 1;
	int max;
	BiTreeWidth(T, k, a, max);
	printf("二叉树的宽度为：%d\n", max);
	
	printf("二叉树的总结点个数为：%d\n", BiTreeCount(T));
	
	LeafPrintf(T);
	
	printf("二叉树的先序遍历序列是：");
	PreOrderTraverse(T);
	printf("\n");
	printf("二叉树的中序遍历序列是：");
	InOrderTraverse(T);
	printf("\n");
	printf("二叉树的后序遍历序列是：");
	PostOrderTraverse(T);
	printf("\n");
	
	SwapTree(T);
	printf("每个结点的左右子树交换之后先序遍历序列是：");
	PreOrderTraverse(T);
	
	BiTree B1, B2;
	if(InitBiTree(B1))
		printf("二叉树B1初始化成功！\n");
	printf("构造二叉树B1（空格表示空树）\n");
	CreateBiTree(B1);
	getchar();//吸收Enter 
	if(InitBiTree(B2))
		printf("二叉树B2初始化成功！\n");
	printf("构造二叉树B2（空格表示空树）\n");
	CreateBiTree(B2);
	if(BiTreeSimilar(B1, B2))
		printf("二叉树B1和二叉树B2相似！\n");
	else
		printf("二叉树B1和二叉树B2不相似！\n");
	return 0;
}

初始化

bool InitBiTree(BiTree &T)
{
	T = (BiTree)malloc(sizeof(BiTNode));
	if(T == NULL)return false;
	T->lchild = NULL;
	T->rchild = NULL;
	return true;
}

先序序列建立二叉树

bool CreateBiTree(BiTree &T)
{
	//按先序次序输入二叉树中结点的值（一个字符），空格字符表示空树，构造二叉链表表示的二叉树T
	TElemType ch;
	/*printf("请输入二叉树中的元素：");*/
	scanf("%c", &ch);
	if(ch == ' ')
		T = NULL;
	else
	{
		T = (BiTree)malloc(sizeof(BiTNode));
		if(!T)return false;
		T->data = ch;//生成根节点
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
	return true;
}

树判空

bool BiTreeEmpty(BiTree &T)
{
	if(T == NULL)
		return true;
	else
		return false;
}

求二叉树的宽度

void BiTreeWidth(BiTree T, int k, int a[], int &max)
{
	if(T == NULL)
		return;
	max = a[k]; 
	a[k] ++;
	if(a[k] > max)
		max = a[k];
	BiTreeWidth(T->lchild, k + 1, a, max);
	BiTreeWidth(T->rchild, k + 1, a, max);
}

求二叉树的深度

int BiTreeDepth(BiTree T)
{
	int depthval, depthleft, depthright;
	if(!T)
		depthval = 0;
	else
	{
		depthleft = BiTreeDepth(T->lchild);
		depthright = BiTreeDepth(T->rchild);
		depthval = 1 + (depthleft > depthright ? depthleft : depthright);
	}
	return depthval;
}

求二叉树总结点个数

int BiTreeCount(BiTree T)
{
	int m, n;
	if(!T)
		return 0;
	if(!T->lchild && T->rchild)
		return 1;
	else
	{
		m = BiTreeCount(T->lchild);
		n = BiTreeCount(T->rchild);
		return (m + n + 1);
	}
}

输出所有叶子结点

bool LeafPrintf(BiTree T)
{
	if(!T)
		return false;
	if(T)
	{
		if((!T->lchild) && (!T->rchild))
		{
			printf("二叉树的叶子结点有：");
			printf("%c\n", T->data);
		}
		LeafPrintf(T->lchild);
		LeafPrintf(T->rchild);
	}
}

先序遍历（递归）

void PreOrderTraverse(BiTree T)//输出二叉树的先序遍历序列
{
	if(T == NULL)
		return;
	printf("%c ", T->data);
	PreOrderTraverse(T->lchild);
	PreOrderTraverse(T->rchild);
}

中序遍历（递归）

void InOrderTraverse(BiTree T)//输出二叉树的中序遍历序列
{
	if(T == NULL)
		return;
	InOrderTraverse(T->lchild);
	printf("%c ", T->data);
	InOrderTraverse(T->rchild);
}

后序遍历（递归）

void PostOrderTraverse(BiTree T)//输出二叉树的后序遍历序列
{
	if(T == NULL)
		return;
	PostOrderTraverse(T->lchild);
	PostOrderTraverse(T->rchild);
	printf("%c ", T->data);
}

判断二叉树是否相似

bool BiTreeSimilar(BiTree B1, BiTree B2)
{
	if(B1 == NULL && B2 == NULL)
		return true;
	else
		if(B1 == NULL || B2 == NULL)
			return false;
	BiTreeSimilar(B1->lchild, B2->lchild);
	BiTreeSimilar(B1->rchild, B2->rchild);
}

交换每一个结点的左右子树

void SwapTree(BiTree &T)
{
	BiTree tmp;
	if(T == NULL)
		return;
	tmp = T->lchild;
	T->lchild = T->rchild;
	T->rchild = tmp;
	SwapTree(T->lchild);
	SwapTree(T->rchild);
}