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

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

源码实现过程：

#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;

}