（广度、深度）遍历二叉树

#include
using namespace std;
typedef int ElemType;
//二叉树的节点
typedef struct BiTNode
{
ElemType value;
struct BiTNode *left,*right;
}BiTNode,*BiTree;
//一个队列节点
typedef struct QueNode
{
BiTNode bNode;
struct  QueNode *next;
}QueNode;
//队列的指针（头指针，尾指针）
typedef struct
{
QueNode *front;
QueNode *rear;
}QuePtr;
void initQue(QuePtr &q)
{
q.front=q.rear=NULL;
}
//判断队列数是否为空
bool isEmpty(QuePtr &q)
{
return q.front==NULL;
}
void pushQueue(QuePtr &q,BiTNode e)
{
//首先创建一个节点
QueNode *qNode=(QueNode*)malloc(sizeof(QueNode));
qNode->bNode=e;
//每次创建一个必须设置为NULL
qNode->next=NULL;
//如果为空
if (isEmpty(q))
{   //队列的头指针和尾指针指向新建的节点
q.front=q.rear=qNode;
}else{
q.rear->next=qNode;
//让队尾指针始终指向新建的节点
q.rear=qNode;
}
}
void popQueue(QuePtr &q)
{
if (!isEmpty(q))
{
QueNode *temp=q.front;
q.front=temp->next;
//将队列中第一个元素删除
free(temp);
}
}

//访问队列节点
void visitQueNode(QueNode *e)
{ //输出二叉树中的元素
cout<bNode.value<<",";
}
//手动创建二叉树
BiTNode *create_1(BiTNode *head)
{
char a;
a=getchar();
//scanf("%c",&a);
if (a=='#')
{
return NULL;
}else
{
if(!(head=(BiTNode *)malloc(sizeof(BiTNode))))
exit(0);
head->value=a;
head->left=create_1(head->left);
head->right=create_1(head->right);
}
return head;
}

//自动创建一颗二叉树
/*              1
2       3
4     5     6    7
8 9  10 11 12 13 14 15

**/
BiTNode *create_2(BiTNode *head)
{
if (head->value<8)
{
BiTNode *left=(BiTNode *)malloc(sizeof(BiTNode));
BiTNode *right=(BiTNode *)malloc(sizeof(BiTNode));
if (!left||!right)
{
exit(0);
}
head->left=left;
left->value=head->value*2;
head->right=right;
right->value=head->value*2+1;
create_2(left);
create_2(right);
}else
{
head->left=NULL;
head->right=NULL;
}
}
//广度优先遍历二叉树(通常是加入到一个队列中去的)
void breadthTraversal(BiTNode *head)
{
//首先初始化一个队列
QuePtr q;
initQue(q);
//将头节点入队
pushQueue(q,*head);
//循环的条件是队列不能为空，每次加入到队列中，后面最后进入队列下一个指针域为NULL
// while (!isEmpty(q))
//在这里q.front指针不断的往后移动
while(q.front)
{
//访问这个头节点
visitQueNode(q.front);
if (q.front->bNode.left!=NULL)
{ //如果左节点存在，那么加入到队列中去
pushQueue(q,*(q.front->bNode.left));
}
if (q.front->bNode.right!=NULL)
{//如果右节点存在，那么加入到队列中去
pushQueue(q,*(q.front->bNode.right));
}
//将位于队列中第一个元素出队
popQueue(q);
}
}
//深度优先遍历一个二叉树，通常是采用的栈的结构
//************************
///*********** 栈 *************
///************************
///************************
//栈的节点
typedef struct StackNode{
BiTNode bNode;
struct StackNode *next;
}StackNode;
//栈指针
typedef struct
{
StackNode *top,*bottom;
}StackPtr;
//初始化一个栈（顶，低）指针
void initStatck(StackPtr &stack)
{
stack.bottom=stack.top=NULL;
}
//将二叉树入栈
void pushStack(StackPtr &stack,BiTNode bNode)
{
StackNode *staNode=(StackNode*)malloc(sizeof(StackNode));
staNode->bNode=bNode;
staNode->next=NULL;
//如果栈为空,
if (stack.bottom==NULL)
{
stack.bottom=stack.top=staNode;
}else{
//这里是将新建的节点指向栈顶
staNode->next=stack.top;
//栈顶指向新建的节点
stack.top=staNode;
}
}
//访问栈中的节点
void visitStaNode(StackNode *e)
{ //输出二叉树中的元素
cout<bNode.value<<",";
}
//当左右孩子都判断完了，那么出栈
void popStack(StackPtr &stack)
{   //首先判断栈顶不为空
if (stack.top)
{
StackNode *temp=stack.top;
stack.top=temp->next;
//说明满足出栈的要求,开始输出节点
visitStaNode(temp);
free(temp);
}
}
//深度优先遍历二叉树
void depthTraversal(StackPtr &stack,BiTNode *head)
{
if(head)
{  //此节点存在入栈
pushStack(stack,*head);
//开始判断左孩子是否存在
depthTraversal(stack,head->left);
//右孩子是否存在
depthTraversal(stack,head->right);
//运行到这一步，分为两种情况：
//1、左右孩子不存在
//2、左右孩子，已经遍历了，并出栈了
popStack(stack);
}
}
//求一个数的深度(depth)，节点数(nCount)，叶子数(leaf)
int depth,nCount,leaf;
int TreeLength(BiTNode *head)
{
//首先判断这个节点是否存在，不存在还回0
if(head)
{
int lDepth=TreeLength(head->left);
int rDepth=TreeLength(head->right);
//当对一个左孩子，右孩子访问完之后，及可判断这个节点
nCount++;
//在两个左右深度之间判断那个大
int max=lDepth>rDepth?lDepth:rDepth;
//判断叶子：即左右深度为0
if (lDepth==0&&rDepth==0)
{
leaf++;
}
return max+1;
}else{
return 0;
}

}
int main(int arg,const char *argv[])
{
BiTNode *head=(BiTNode *)malloc(sizeof(BiTNode));
//12#4##35###
//head=create_1(head);
head->value=1;
create_2(head);
StackPtr stack;
initStatck(stack);
cout<<"深度优先遍历二叉树:"<