二叉树创建、遍历（递归和非递归）、深度及求取二叉树中和为某一值的所有路径

1、建立一棵二叉树

思路：从键盘输入数据，将数据插入树，用#代表子树为空。按照深度优先的方法进行插入，示意图如下：



其中3、2、5、4、6是二叉树的结点，红色虚线表示建立二叉树的顺序。

代码：

//二叉树结点
struct BiTNode
{
char data;
struct BiTNode *lChild,*rChild;
};

//创建二叉树
BiTNode* CreateBinaryTree(BiTNode* &T)
{
char ch;
if ((ch=getchar())=='#')
{
T=NULL;
}
else
{
T=(struct BiTNode*)malloc(sizeof(struct BiTNode));
if (NULL==T)
{
std::cout<<"Error! Over flow!"<<std::endl;
return NULL;
}
T->data=ch;
CreateBinaryTree(T->lChild);
CreateBinaryTree(T->rChild);
}
return T;
}

2、二叉树遍历——递归

//先序遍历
void PreOrderTraverse(BiTNode* &T)
{
if (T)
{
std::cout<<T->data<<" ";
PreOrderTraverse(T->lChild);
PreOrderTraverse(T->rChild);
}
else
{
std::cout<<"";
}
}

//中序遍历
void InOrderTraverse(BiTNode* &T)
{
if (T)
{
InOrderTraverse(T->lChild);
std::cout<<T->data<<" ";
InOrderTraverse(T->rChild);
}
else
{
std::cout<<"";
}
}

//后序遍历
void PostOrderTraverse(BiTNode* &T)
{
if (T)
{
PostOrderTraverse(T->lChild);
PostOrderTraverse(T->rChild);
std::cout<<T->data<<" ";
}
else
{
std::cout<<"";
}
}

3、二叉树遍历——非递归

//先序遍历，非递归方法1
void PreOrderNonTvs(BiTNode* &T)
{
std::stack<BiTNode*> ss;
BiTNode* p=T;

while (p!=NULL || !ss.empty())
{
while (p!=NULL)
{
std::cout<<p->data<<" ";
ss.push(p);
p=p->lChild;
}
if (!ss.empty())
{
p=ss.top();
ss.pop();
p=p->rChild;
}

}
}

//先序遍历，非递归方法2
void PreOrderNonRecur(BiTNode* &T)
{
BiTNode* p=T;
std::stack<BiTNode*> ss;
ss.push(p);
while (!ss.empty())
{
BiTNode* q=ss.top();
std::cout<<q->data<<" ";
ss.pop();

if (q->rChild!=NULL)
{
ss.push(q->rChild);
}
if (q->lChild!=NULL)
{
ss.push(q->lChild);
}
}
}

//中序遍历，非递归
void InOrderNonRecur(BiTNode* &T)
{
BiTNode* p=T;
std::stack<BiTNode*> ss;

while (p!=NULL || !ss.empty())
{
while (p!=NULL)
{
ss.push(p);
p=p->lChild;
}
if (!ss.empty())
{
p=ss.top();
std::cout<<p->data<<" ";
ss.pop();
p=p->rChild;
}
}
}

//为后续遍历构造结构体
struct BiTPos
{
BiTNode* tree;
bool isFirst;
};
//后序遍历，非递归方法1
void PosOrderNonTvs(BiTNode* &T)
{
BiTNode* p=T;
std::stack<BiTPos*> ss;
BiTPos* q;

while(p!=NULL || !ss.empty())
{
while (p!=NULL)
{
q=new BiTPos;
q->tree=p;
q->isFirst=true;
ss.push(q);

p=p->lChild;
}
if (!ss.empty())
{
q=ss.top();
ss.pop();
if (q->isFirst==true)
{
q->isFirst=false;
ss.push(q);
p=q->tree->rChild;
}
else
{
std::cout<<q->tree->data<<" ";
p=NULL;
}
}
}
}

//后序遍历，非递归方法2
void PosOrderNonRecur(BiTNode* &T)
{
BiTNode* p=T;
std::stack<BiTNode*> ss;
ss.push(p);
BiTNode* cur;
BiTNode* pre=NULL;

while (!ss.empty())
{
cur=ss.top();

if (((cur->lChild==NULL)&&(cur->rChild==NULL)) || ((pre!=NULL)&&(pre==cur->lChild || pre==cur->rChild)))
{
std::cout<<cur->data<<" ";
ss.pop();
pre=cur;
}
else
{
if (cur->rChild!=NULL)
{
ss.push(cur->rChild);
}
if (cur->lChild!=NULL)
{
ss.push(cur->lChild);
}
}
}
}

4、层次遍历（非递归）

//层次遍历
void LevelOrderTraverse(BiTNode* &T)
{
std::queue<BiTNode*> sq;
BiTNode* p=T;
sq.push(p);

while(sq.size()!=0)
{
p=sq.front();
sq.pop();
std::cout<<p->data<<" ";
if (p->lChild!=NULL)
{
sq.push(p->lChild);
}
if (p->rChild!=NULL)
{
sq.push(p->rChild);
}
}
}

5、二叉树的深度

思路：若一棵二叉树为空，则其深度为0，否则其深度等于左子树和右子树的最大深度加1。上图中的深度为3。

//计算一棵二叉树的深度
int depth(BiTNode* &T)
{
if (!T)
{
return 0;
}
int d1=depth(T->lChild);
int d2=depth(T->rChild);
return ((d1>d2)?d1:d2)+1;
}

6、求二叉树中和为某一值的所有路径

思路：a>“和为某一值“——需要一个值来记录路径中遇到的值，该值可在递归中被修改，所以用static

b>”求取路径“——需要记录符合条件的路径，遍历的过程就是在通过各种路径，问题在于如何求取多条路径。采用栈来进行结点的压入和弹出，以完成路径的回溯。

c>栈用来记录路径信息——涉及到”路径栈“的初始化、压入、输出和弹出等操作,而栈的操作元素为二叉树结点。

d>递归——涉及到递归何时停止，一是路径信息和超出给定范围，二是当前结点为叶子结点

e>叶子结点——需要判断当前结点是否为叶子结点

代码：

//记录当前路径信息值
static int record=0;

//路径结点，存取的是从根结点开始的路径
struct BiTPath
{
BiTNode* tree;
struct BiTPath *next;
};

//初始化结点栈，或者说结点路径信息
void InitPath(BiTPath* &p)
{
p=(BiTPath*)malloc(sizeof(BiTPath));
p->next=NULL;
}

//结点入栈
void Push_backPath(BiTPath* &H,BiTNode* &T)
{
BiTPath* p=H->next;
BiTPath* q=H;

while (NULL!=p)
{
q=p;
p=p->next;
}
p=(BiTPath*)malloc(sizeof(BiTPath));
p->tree=T;
p->next=NULL;

q->next=p;
}

//打印结点，或打印路径信息
void PrintPath(BiTPath* &p)
{
BiTPath* L=p->next;
if (NULL==L)
{
std::cout<<"栈为空！"<<std::endl;
return;
}
while (NULL!=L)
{
std::cout<<L->tree->data<<" ";
L=L->next;
}
std::cout<<std::endl;
}

//结点出栈
void PopPath(BiTPath* &H)
{
BiTPath* p=H->next;
BiTPath* q=H;

if (NULL==p)
{
std::cout<<"栈为空！"<<std::endl;
return;
}
while (NULL!=p->next)
{
q=p;
p=p->next;
}
free(p);
q->next=NULL;

}

//判断结点是否为叶子结点
bool IsLeaf(BiTNode* &T)
{
return (T->lChild==NULL)&&(T->rChild==NULL);
}

//查找符合条件的路径
int Find_Path(BiTNode* &T,int sum,BiTPath* &p)
{
Push_backPath(p,T);
record+=(T->data)-'0';

if ((record==sum)&&(IsLeaf(T)))
{
std::cout<<"one of the path is: ";
PrintPath(p);
}
if (T->lChild!=NULL)
{
Find_Path(T->lChild,sum,p);
}
if (T->rChild!=NULL)
{
Find_Path(T->rChild,sum,p);
}
record-=(T->data)-'0';
PopPath(p);
return 0;
}<pre class="cpp" name="code">

//是否平衡二叉树
bool IsBalance(BiTNode* &T)
{
BiTNode* p=T;
if (p==NULL)
{
return true;
}
else
{
int lHeight=depth(p->lChild);
int rHeight=depth(p->rChild);
int diff=lHeight-rHeight;
if (diff>1 || diff<-1)
{
return false;
}
else
{
return IsBalance(p->lChild) && IsBalance(p->rChild);
}
}

}

7、主函数及测试结果

int main()
{
std::cout<<std::endl;
std::cout<<"Create Binary Tree('#' represent Null)"<<std::endl;
BiTNode* BiT;
CreateBinaryTree(BiT);

std::cout<<std::endl;
std::cout<<"(Recursive method)"<<std::endl;
std::cout<<"pre order traverse Binary Tree: ";
PreOrderTraverse(BiT);
std::cout<<std::endl;
std::cout<<"in order traverse Binary Tree: ";
InOrderTraverse(BiT);
std::cout<<std::endl;
std::cout<<"post order traverse Binary Tree: ";
PostOrderTraverse(BiT);
std::cout<<std::endl;

std::cout<<std::endl;
std::cout<<"(Non-Recursive method)"<<std::endl;
std::cout<<"pre order traverse Binary Tree Non-Rec Method 1: ";
PreOrderNonTvs(BiT);
std::cout<<std::endl;
std::cout<<"pre order traverse Binary Tree Non-Rec Method 2: ";
PreOrderNonRecur(BiT);
std::cout<<std::endl;
std::cout<<"in order traverse Binary Tree Non-Rec Method: ";
InOrderNonRecur(BiT);
std::cout<<std::endl;
std::cout<<"pos order traverse Binary Tree Non-Rec Method1: ";
PosOrderNonTvs(BiT);
std::cout<<std::endl;
std::cout<<"pos order traverse Binary Tree Non-Rec Method2: ";
PosOrderNonRecur(BiT);
std::cout<<std::endl;

std::cout<<std::endl;
std::cout<<"level order traverse Binary Tree Non-Rec Method: ";
LevelOrderTraverse(BiT);
std::cout<<std::endl;

std::cout<<std::endl;
std::cout<<"the height of Binary Tree: "<<depth(BiT)<<std::endl;

std::cout<<std::endl;
if (IsBalance(BiT))
{
std::cout<<"the Binary Tree is balance~ "<<std::endl;
}
else if (!IsBalance(BiT))
{
std::cout<<"the Binary Tree is not balance~ "<<std::endl;
}

//计算二叉树中和为某一值得所有路径
BiTPath* p=new BiTPath;
p->next=NULL;
InitPath(p);
std::cout<<"please enter the sum you want: "<<std::endl;
int sum;
std::cin>>sum;
Find_Path(BiT,sum,p);
return 0;
}