二叉树(Binary Tree)相关算法的实现

写在前面：

二叉树是比较简单的一种数据结构，理解并熟练掌握其相关算法对于复杂数据结构的学习大有裨益

一.二叉树的创建

[不喜欢理论的点我跳过>>]

所谓的创建二叉树，其实就是让计算机去存储这个特殊的数据结构（特殊在哪里？特殊在它是我们自定义的）

首先，计算机内部存储都是线性的，而我们的树形结构是一种层级的，计算机显然无法理解，计算机能够接受的原始数据类型并不能满足我们的需求

所以，只好自定义一种数据结构来表示层级关系

实际上是要定义结构 + 操作，结构是为操作服务的，举个例子，我们要模拟买票的过程，现有的数据结构无法满足我们的需求（不要提数组...），我们需要的操作可能是:

1.获取站在买票队伍最前面的人

2.把买好票的人踢出队伍

3.第一个人买完票后，他后面的所有人都要“自觉”地向前移动

明确了这三个操作，再根据操作来定义结构，最后我们得到了队列（数组/链表 + 对应的函数）

二叉树也是这样，计算机看到的只是结构 + 操作，结构是Node集合（二叉链表），操作是创建、遍历、查找等等函数

结点：

struct bt
{
	char data;
	struct bt *left;
	struct bt *right;
};

结点就是一个桶，两只手（桶里装数据，两只手伸出去抓左右两个孩子）

操作：

//createBT();
//printBT();
//deleteNode(Node node);
//...

-------上面是对二叉树的理解，下面是创建二叉树具体实现-------

二叉树的创建过程其实就是遍历过程（此处指递归方式），我们知道二叉树的任何一种遍历方式都可以把树形结构线性化（简单的说就是一组遍历结果可以唯一的表示一颗二叉树），因此可以根据遍历结果来还原一颗二叉树

先序遍历递归建树的具体思路：

1.读入当前根结点的数据

2.如果是空格，则将当前根置为空，否则申请一个新结点，存入数据

3.用当前根结点的左指针和右指针进行递归调用，创建左右子树

语言描述可能不太好懂，代码如下：

struct bt
{
	char data;
	struct bt *left;
	struct bt *right;
};

void createBT(struct bt ** root)
{
	char c;
	c=getchar();
	if(c == ' ')*root=NULL;//若为空格则置空
	else
	{
		*root=(struct bt *)malloc(sizeof(struct bt));//申请新结点
		(*root)->data=c;//存入数据
		createBT(&((*root)->left));//建立当前结点的左子树
		createBT(&((*root)->right));//建立当前结点的右子树
	}
}

例如，如果我们要建立一个二叉树a(b, c)，只要输入它的先序遍历结果ab××c××即可（×表示空格），其余两种建树方式于此类似，不再详述，至于非递归的建树方法参见下面的非递归遍历，非常相似

二.遍历

遍历在实现方式上有递归与非递归两种方式，所谓的非递归其实是由递归转化而来的（手动维护一个栈），开销（内存/时间）上可能非递归的更好一些，毕竟操作系统的栈中维护的信息更多，现场的保存与恢复开销都要更大一些

在遍历顺序上有3种方式：

1.先序遍历（根-左-右）

2.中序遍历（左-根-右）

3.后序遍历（左-右-根）

举个例子，二叉树a(b, c(d, e))的三种遍历结果分别是：

1.abcde

2.badce

3.bdeca

-------下面看看后序遍历的递归与非递归实现，其余的与之类似-------

后序遍历递归：

void postOrder(struct bt * root)
{
	if(root == NULL)return;
	else
	{
		postOrder(root->left);
		postOrder(root->right);
		putchar(root->data);
	}
}

后序遍历非递归：

void postOrder(struct st* root)
{
	struct st* stack[100];//声明结点栈
	int top=-1;//栈顶索引
	struct bt* p=root;//当前结点（present）
	struct bt* q=NULL;//上一次处理的结点
	while(p!=NULL||top!=-1)
	{
		for(;p!=NULL;p=p->left)stack[++top]=p;//遍历左子树
		if(top!=-1)
		{
			p=stack[top];
			if(p->right==NULL||p->right==q)//无右孩子，或右孩子已经遍历过
			{
				putchar(p->data);//输出根结点
				q=p;
				p=stack[top];
				top--;
				p=NULL;
			}
			else p=p->right;//遍历右子树
		}
	}
}

为了描述地更清晰，上面直接实现了栈的操作，当然，更规范的做法是将栈作为一个独立的数据结构封装起来，在我们的函数中调用栈提供的操作函数来进行相关操作

三.输出叶结点

检索特定结点的一系列操作都是建立在遍历的基础上的，输出叶结点就是一个例子，叶结点满足的条件是左右孩子都为空，我们只要在遍历中添加这样的判断条件就可以了

//此处采用先序遍历
void printLeaves(struct bt* root)
{
	if(root == NULL)return;
	else
	{
		if(root->left == NULL&&root->right == NULL)putchar(root->data);
		else
		{
			printLeaves(root->left);
			printLeaves(root->right);
		}
	}
}

于此类似的操作有，输出二叉树中满足一定条件的结点，删除指定结点，在指定位置添加结点（子树）...都是在遍历的基础上做一些额外的操作

四.计算树的深度

计算树深有多种方式，例如：

1.分别计算根下左右子树的高度，二者中的较大的为树深

2.最大递归深度为树深

...

我们采用第一种方式，更清晰一些

int btDepth(struct bt* root)
{
	int rd,ld;
	if(root==NULL)return 0;//空树深度为0
	else
	{
		ld=1+btDepth(root->left);//递归进层，深度加1
		rd=1+btDepth(root->right);//递归进层，深度加1
		return ld > rd ? ld : rd;//返回最大值
	}
}

五.树形输出

所谓树形输出，即对自然表示的二叉树逆时针旋转90度，其实仍然是在遍历的过程中记录递归层数，以此确定输出结果

//depth表示递归深度，初始值为0
void btOutput(struct bt* root,int depth)
{
	int k;
	if(root==NULL)return;
	else
	{
		btOutput(root->right,depth+1);//遍历右子树
		for(k=0;k<depth;k++)
			printf(" ");//递归层数为几，就输出几个空格（缩进几位）
		putchar(root->data);printf("\n");
		btOutput(root->left,depth+1);//遍历左子树
	}
}
//“右-中-左”的遍历顺序被称为“逆中序”遍历，采用这种顺序是为了符合输出规则（逆时针90度）

六.按层缩进输出

按层缩进输出就像代码编辑器中的自动缩进，从根结点开始逐层缩进，只需要对上面的代码稍作改动就可以实现

//k仍然表示递归深度，初始值为0
void indOutput(struct bt* root,int k)
{
	int i;
	if(root!=NULL)
	{
		for(i=1;i<=k;i++)
			putchar(' ');
		putchar(root->data);putchar('\n');
		indOutput(root->left,k+1);
		indOutput(root->right,k+1);
	}
	else return;
}
//按层缩进输出与树形输出的唯一区别就是遍历方式不同，前者是先序遍历，后者是逆中序遍历

七.按层顺序输出

按层顺序输出与前面提及的两种输出方式看似相似，实则有着很大不同，至少，我们无法简单地套用任何一种遍历过程来完成这个目标

所以，只能维护一个队列来控制遍历顺序

void layerPrint(struct bt* root)
{
	struct bt* queue[100];//声明结点队列
	struct bt* p;//当前结点
	int amount=0,head,tail,j,k;//队列相关属性（元素总数，对头、队尾索引）
	queue[0]=root;
	head=0;
	tail=1;
	amount++;
	while(1)
	{
		j=0;
		for(k=0;k<amount;k++)
		{
			p=queue[head++];//取对头元素
			if(p->left!=NULL)
			{
				queue[tail++]=p->left;//如果有则记录左孩子
				j++;
			}
			if(p->right!=NULL)
			{
				queue[tail++]=p->right;//如果有则记录右孩子
				j++;
			}
			putchar(p->data);//输出当前结点值
		}
		amount=j;//更新计数器
		if(amount==0)break;
	}
}

八.计算从根到指定结点的路径

要记录路径，当然不宜用递归的方式，这里采用后序遍历的非递归实现

为什么选择后序遍历？

因为在这种遍历方式中，某一时刻栈中现有的结点恰恰就是从根结点到当前结点的路径（从栈底到栈顶）。严格地说，此时应该用队列来保存路径，因为栈不支持从栈底到栈顶的出栈操作（这样的小细节就把它忽略好了...）

//参数c为指定结点值
void printPath(struct bt* root,char c)
{
	struct st* stack[100];//声明结点栈
	int top=-1;//栈顶索引
	int i;
	struct bt* p=root;//当前结点
	struct bt* q=NULL;//上一次处理的结点
	while(p!=NULL||top!=-1)
	{
		for(;p!=NULL;p=p->left)stack[++top]=p;//遍历左子树
		if(top!=-1)
		{
			p=stack[top];//获取栈顶元素
			if(p->right==NULL||p->right==q)//如果当前结点没有右孩子或者右孩子刚被访问过
			{
				if(p->data==c)//如果找到则输出路径
				{
					for(i=0;i<=top;i++)
					{
						p=stack[i];
						putchar(p->data);
					}
					printf("\n");
					//此处不跳出循环，因为可能存在不唯一的结点值，遍历整个树，找出所有路径
				}
				q=p;
				p=stack[top];
				top--;
				p=NULL;
			}
			else p=p->right;//遍历右子树
		}
	}
}

九.完整源码与截图示例

源码：

#include<stdio.h>

struct bt
{
	char data;
	struct bt *left;
	struct bt *right;
};

void createBT(struct bt ** root)
{
	char c;
	c=getchar();
	if(c == ' ')*root=NULL;
	else
	{
		*root=(struct bt *)malloc(sizeof(struct bt));
		(*root)->data=c;
		createBT(&((*root)->left));
		createBT(&((*root)->right));
	}
}

void preOrder(struct bt * root)
{
	if(root == NULL)return;
	else
	{
		putchar(root->data);
		preOrder(root->left);
		preOrder(root->right);
	}
}

void inOrder(struct bt * root)
{
	if(root == NULL)return;
	else
	{
		inOrder(root->left);
		putchar(root->data);
		inOrder(root->right);
	}
}

void printLeaves(struct bt* root)
{
	if(root == NULL)return;
	else
	{
		if(root->left == NULL&&root->right == NULL)putchar(root->data);
		else
		{
			printLeaves(root->left);
			printLeaves(root->right);
		}
	}
}

int btDepth(struct bt* root)
{
	int rd,ld;
	if(root==NULL)return 0;
	else
	{
		ld=1+btDepth(root->left);
		rd=1+btDepth(root->right);
		return ld > rd ? ld : rd;
	}
}

void btOutput(struct bt* root,int depth)
{
	int k;
	if(root==NULL)return;
	else
	{
		btOutput(root->right,depth+1);
		for(k=0;k<depth;k++)
			printf(" ");
		putchar(root->data);printf("\n");
		btOutput(root->left,depth+1);
	}
}

void postOrder(struct st* root)
{
	struct st* stack[100];
	int top=-1;
	struct bt* p=root;
	struct bt* q=NULL;
	while(p!=NULL||top!=-1)
	{
		for(;p!=NULL;p=p->left)stack[++top]=p;
		if(top!=-1)
		{
			p=stack[top];
			if(p->right==NULL||p->right==q)
			{
				putchar(p->data);
				q=p;
				p=stack[top];
				top--;
				p=NULL;
			}
			else p=p->right;
		}
	}
}

void printPath(struct bt* root,char c)
{
	struct st* stack[100];
	int top=-1;
	int i;
	struct bt* p=root;
	struct bt* q=NULL;
	while(p!=NULL||top!=-1)
	{
		for(;p!=NULL;p=p->left)stack[++top]=p;
		if(top!=-1)
		{
			p=stack[top];
			if(p->right==NULL||p->right==q)
			{
				if(p->data==c)
				{
					for(i=0;i<=top;i++)
					{
						p=stack[i];
						putchar(p->data);
					}
					printf("\n");
				}
				q=p;
				p=stack[top];
				top--;
				p=NULL;
			}
			else p=p->right;
		}
	}
}

void layerPrint(struct bt* root)
{
	struct bt* queue[100];
	struct bt* p;
	int amount=0,head,tail,j,k;
	queue[0]=root;
	head=0;
	tail=1;
	amount++;
	while(1)
	{
		j=0;
		for(k=0;k<amount;k++)
		{
			p=queue[head++];
			if(p->left!=NULL)
			{
				queue[tail++]=p->left;
				j++;
			}
			if(p->right!=NULL)
			{
				queue[tail++]=p->right;
				j++;
			}
			putchar(p->data);
		}
		amount=j;
		if(amount==0)break;
	}
}

void indOutput(struct bt* root,int k)
{
	int i;
	if(root!=NULL)
	{
		for(i=1;i<=k;i++)
			putchar(' ');
		putchar(root->data);putchar('\n');
		indOutput(root->left,k+1);
		indOutput(root->right,k+1);
	}
	else return;
}

void main()
{
	char c;
	struct bt * root;
	printf("请输入先序遍历结果: ");
	createBT(&root);
	printf("先序遍历(preOrder)[递归]: \n");
	preOrder(root);
	printf("\n中序遍历(inOrder)[递归]: \n");
	inOrder(root);
	printf("\n后序遍历(postOrder)[非递归]: \n");
	postOrder(root);
	printf("\n叶结点(leaves): \n");
	printLeaves(root);
	printf("\n深度(depth): \n");
	printf("%d\n",btDepth(root));
	printf("树形输出(tree output): \n");
	btOutput(root,0);
	printf("缩进输出(indentation output): \n");
	indOutput(root,0);
	printf("请输入目标结点(target node): ");
	getchar();
	c=getchar();
	printf("路径(path): \n");
	printPath(root,c);
	printf("按层输出(layerPrint): \n");
	layerPrint(root);
	printf("\n");
}

截图示例：

一颗较为复杂的二叉树：

其先序遍历结果为：ABD××EG×××C×FH××I××（×表示空，输入的时候要把×换成空格）

把D改成H再试一次（存在重复元素了，因该有两条到H的路径）