二叉树的性质极其二叉树的构建、各种遍历以及深度宽度的求解

学了忘记，忘记了又来翻书。还是mark一下吧。

性质1：二叉树的第i层上至多有2的i-1次方个节点。

性质2：深度为n的二叉树至多有2的n-1次方个节点。

性质3：对于任何一个二叉树，终端节点数为n0，度为2的节点为n2，那么n0=n2+1。

性质4：具有n个节点的完全二叉树的深度为[log n]+1，这里的[ ]表示取整，不大于log n的最大整数。

证明的地址：proof

构建二叉树之前，需要定义相关使用的数据结构：

#include<iostream>
#include<vector>
#include<stack>
#include<queue>
#include<cassert>

using namespace std;

extern "C"
{
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
}
typedef char ELement;

typedef struct Tree{
ELement data;
struct Tree *lchild,*rchild;
}iTree,*bTree;

二叉树的建立，这里利用前序递归的方法进行建立：

void creat_tree(bTree *T)
{
ELement d;

fflush(stdin);
printf("please input data:\n");
scanf("%c",&d);
(*T)=(bTree)malloc(sizeof(iTree));
if((*T)!=NULL)
{
(*T)->data=d;
(*T)->lchild=(*T)->rchild=NULL;
printf("%d\n",(*T)->data);
}

if((*T)->data == '#')
{
*T=NULL;
return;
}
else
{
creat_tree(&(*T)->lchild);
creat_tree(&(*T)->rchild);
}
}

我需要构建的树形如下：



由于采用的是递归的方式产生二叉树，这里输入元素的顺序：ABC##D##DF##G##。

然后我们进行遍历，分为前序、中序、后序、层序。前中后序的遍历利用递归的方式可以简单地实现：

void prereadtree(bTree T)
{
if(T==NULL)
return;
printf("%c\t",T->data);
prereadtree(T->lchild);
prereadtree(T->rchild);
}
void midreadtree(bTree T)
{

if(T==NULL)
return;
midreadtree(T->lchild);
printf("%c\t",T->data);
midreadtree(T->rchild);
}
void backreadtree(bTree T)
{
if(T==NULL)
return;
backreadtree(T->lchild);
backreadtree(T->rchild);
printf("%c\t",T->data);
}

其思想很简单，这里不再讲解。

这里主要说下层序遍历的方式，想到层序遍历的时候，首先想到地是使用队列或者栈的方式进行遍历。这里采用C++里面的队列方式实现，对于C++队列的操作主要需要包含类queue。队列的操作主要有以下几种：

入队：q.push(x); 将x 接到队列的末端。

出队：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。

访问队首元素：q.front()，即最早被压入队列的元素。

访问队尾元素：q.back()，即最后被压入队列的元素。

判断队列空：q.empty()，当队列空时，返回true。

访问队列中的元素个数：q.size()

这里利用C++队列实现层序遍历的思想如下：

首先将根节点压入队列；定义一个数据节点指针指向队列的首元素；队列的首元素出队列；然后查看队列的首元素是否有左右子树，如果有则入队列，其中左子树先入队列；然后判断队列是否为空。第二次循环判断的时候，上一个节点的左子树在队列首位，然后就这样一直循环，直到所有节点均被遍历完。借用上面的思想实现的代码如下：

void layerreadtree(bTree T)
{
if(T==NULL)
return;
queue<bTree> quetree;

quetree.push(T);
while(!quetree.empty())
{
bTree node=quetree.front();
quetree.pop();

printf("%c\t",node->data);

if(node->lchild)
quetree.push(node->lchild);
if(node->rchild)
quetree.push(node->rchild);
}

}

然后再进行树的深度的计算，思想很简单，找到最左节点，每次循环加一，找到最右节点，每次循环加一。比较两次累加的结果，取其中最大的就是树的深度。代码的实现如下：

int depthtree(bTree T)
{
int leftdepth=0,rightdepth=0;
bTree p;

p=T;
do{
leftdepth++;
p=p->lchild;
}while(p!=NULL);

p=T;//回到树根
do{
rightdepth++;
p=p->rchild;
}while(p!=NULL);

if(leftdepth>rightdepth)
return leftdepth;
else
return rightdepth;
}

下面来说有点难度的树的宽度的计算，什么叫做树的宽度呢？树的宽度就是寻找树中元素的节点最多的一层。怎么计算呢？有了上面层序遍历的经验，这次继续采用层序遍历的方式进行计算。考虑到几个因素，计算每一层元素的个数的时候，我们只需要统计当前队列里面有多少元素即可，但是在统计之前，需要等到上一层的元素完全出了队列，统计出来的结果才是当前层的结果。下面是代码的实现：

int getwidth(bTree T)
{
int maxwidth=1;
int currentwidth=0;
int lastwidth;

if(T==NULL)
return 0;

queue<bTree> quetree;

quetree.push(T);
lastwidth=1
while(!quetree.empty())
{
while(lastwidth!=0)
{
bTree node=quetree.front();
quetree.pop();

if(node->lchild)
quetree.push(node->lchild);
if(node->rchild)
quetree.push(node->rchild);
lastwidth--;
}
currentwidth=quetree.size();
maxwidth=currentwidth>maxwidth?currentwidth:maxwidth;
lastwidth=currentwidth;
}
return maxwidth;

}

下面结合代码，讲解下这个算法：

首先树根入队列，初始化上层元素个数为1。

然后进入内层循环，node节点指向队列首位，队列首位元素出队列，树根左右子树入队列，lastwidth减一，结束此次循环。

currenwidth获取当前队列内元素个数，然后判断前元素个数currentwidth是不是最大的，是则赋值给maxwidth，不是则maxwidth保持不变。

然后将本层统计的元素个数值赋值给lastwith，继续进入下一次循环，然后在这次循环中所有的元素出队列，其左右子树均入队列。然后一直循环，按照这样的规则，直到队列中不再有元素停留，则结束。

下面讲树的另一种操作，对树本身进行反转。

未对树进行镜像反转之前，先序遍历的结果是：ABCDDFG，如果对树进行镜像操作，得到的结果应该是ADGFBDC。

怎么实现树的镜像呢？

思路是这样的，先查看树节点存不存在左右子树，如果没有左右子树，镜像反转blabla。。。都是无用的~存在左右子树就交换左右子树，这样就完成了反转。

具体怎么实施呢？

我们先到树根节点，反转与树根连接的左右节点，然后进入左子树反转，然后进入右子树反转。这么一分析，so easy。。。下面是代码实现：

void turnaround(bTree *T)
{
if((*T)==NULL || (*T)->lchild==NULL || (*T)->rchild ==NULL)
return ;
bTree tempnode;

tempnode=(*T)->lchild;
(*T)->lchild=(*T)->rchild;
(*T)->rchild=tempnode;

turnaround(&(*T)->lchild);
turnaround(&(*T)->rchild);
}