二叉树层次遍历和深度遍历

二叉树层次遍历和深度遍历

源码实现过程：

#include <stdio.h>
#include <QUEUE> //必须使用的是QUEUE，和using namespace std,缺一不可;
#include <STACK>
using namespace std;


typedef  char DataType;
typedef struct Node {
DataType elem;
Node * rChild;
Node * lChild;
}NODE,*pNode;


queue<pNode> Q;
bool creat(pNode &root){
DataType temp;
scanf("%c",&temp);
if (temp==EOF)
{
return false;
}else if(temp=='#')
{
root = NULL;
}else{
root = (pNode )malloc(sizeof(Node));
root->elem=temp;
creat(root->lChild);
creat(root->rChild);
}
return true;
}




void preOrder(pNode root){
if (root!=NULL)
{
printf("%c ",root->elem);
if (root->lChild)
{
preOrder(root->lChild);
}
if (root->rChild)
{
preOrder(root->rChild);
}
}
}




void inOrder(pNode root){
if (root!=NULL)
{
if (root->lChild)
{
inOrder(root->lChild);
}




printf("%c ",root->elem);


if (root->rChild)
{
inOrder(root->rChild);
}
}
}


//这是错误的，原因是使用了递归，将所有节点都加入到了队列中，再开始出队。造成了有重复的节点加入。
void level_print(pNode &root){
if (root != NULL)
{
// printf("%c",root->elem);
if (Q.empty())//放入第一个节点
{
Q.push(root);
}

if (root->lChild)
{
Q.push(root->lChild);
}


if (root->rChild)
{
Q.push(root->rChild);
}





if (root->lChild)
{
level_print(root->lChild);
}
if (root->rChild)
{
level_print(root->rChild);
}
}




while(!Q.empty())
{
pNode temp = Q.front();
printf("%c ",temp->elem);
Q.pop();
}
}


//这个算法是成功的实现了树的层次遍历
void level_print2(pNode root){
while (!Q.empty())//清空队列
{
Q.pop();
}
if (root)//先使根节点入队
{
Q.push(root);
}
do 
{
pNode temp; 
temp = Q.front();
printf("%c ",temp->elem);
Q.pop();
if (temp->lChild)//如果左子树不为空，将左子树入队
{
Q.push(temp->lChild);
}
if (temp->rChild)//如果右子树不为空，将右子树入队
{
Q.push(temp->rChild);
}
}while (!Q.empty());
}




// 如果要实现按层打印数的话，还是修改树的层次遍历，注意的是要统计树中每层的个数
void level_print3(pNode root){
int parentSize=1;
int childSize=0;
// 1.清空树；
while (!Q.empty())
{
Q.pop();
}


// 2.将树分层次加入到队列中
Q.push(root);
do 
{
pNode temp = Q.front();
printf("%c ",temp->elem);
Q.pop();
parentSize--;


if (temp->lChild)
{
Q.push(temp->lChild);
childSize++;


}


if (temp->rChild)
{
Q.push(temp->rChild);
childSize++;
}


if (parentSize==0)
{
parentSize=childSize;
childSize=0;
printf("\n");
}
} while (!Q.empty());
}




// 因为深度优先遍历，遍历了根节点后，就开始遍历左子树，
// 所以右子树肯定最后遍历。我们利用栈的性质，先将右子
// 树压栈，然后在对左子树压栈。此时，左子树节点是在top上的，
// 所以可以先去遍历左子树。


void DepthFirstTravel(pNode root){
stack<pNode> S;
if (root)
{
S.push(root);
}
while (!S.empty())
{
pNode temp = S.top();
printf("%c ",temp->elem);
S.pop();
if (temp->rChild)
{
S.push(temp->rChild);
}
if (temp->lChild)
{
S.push(temp->lChild);
}
}






}


int main(){
pNode T;
creat(T);
printf("preOrder:");
preOrder(T);
printf("\n");




printf("inOrder:");
inOrder(T);
printf("\n");


printf("level_travel is :\n");
  level_print2(T);
printf("\n");




printf("level_travel is :\n");
level_print3(T);
printf("\n");






printf("DepthFirstTravel is :\n");
DepthFirstTravel(T);
printf("\n");




// queue<int> q;
// q.push(1);
// q.push(2);
// q.push(3);
// q.push(4);
// while(!q.empty()){
// printf("%d ",q.front());
// q.pop();
// }
// printf("\n");
return 0;
}