二叉树的深度（前序 中序 后序 递归非递归搜素）、广度、搜索 C++

/*
描述：二叉树的深度（前序 中序 后序 递归非递归搜素）、广度、搜索
作者：jz
日期：20140819
*/
#include<stdio.h>
#include<malloc.h>
#include<process.h> /* exit() */
#include<iostream>
using namespace  std;
#include<stack>
#include<queue>

#define OK 1
#define  TElemType  int
#define Status int
#define  Nil  (-1)
//结束符
#define TRUE  1
#define FALSE 0
#define ERROR 0

typedef struct BiTNode   /* 二叉树的二叉链表存储表示 */
{
TElemType  data;
struct BiTNode *lchild,*rchild; /* 左右孩子指针 */
}BiTNode,*BiTree;

enum enum_tag {L=1,R=2};//后序遍历使用作为标记
typedef struct StackNode
{//后序遍历使用
enum_tag tag;
BiTNode* ptr;
}StackNode;

Status InitBiTree(BiTree *T)
{ /* 操作结果: 构造空二叉树T */
*T=NULL;
return OK;
}

void DestroyBiTree(BiTree *T)
{ /* 初始条件: 二叉树T存在。操作结果: 销毁二叉树T */
if(*T) /* 非空树 */
{
if((*T)->lchild) /* 有左孩子 */
DestroyBiTree(&(*T)->lchild); /* 销毁左孩子子树 */
if((*T)->rchild) /* 有右孩子 */
DestroyBiTree(&(*T)->rchild); /* 销毁右孩子子树 */
free(*T); /* 释放根结点 */
*T=NULL; /* 空指针赋0 */
}
}

void CreateBiTree(BiTree *T)
{ /*按先序次序输入二叉树中结点的值（可为字符型或整型，在主程中 */
/* 定义），构造二叉链表表示的二叉树T。变量Nil表示空（子）树。有改动 */
TElemType ch;
scanf("%d",&ch);
if(ch==Nil) /* 空 */
*T=NULL;
else
{
*T=(BiTree)malloc(sizeof(BiTNode));
if(!*T)
exit(-1);
(*T)->data=ch; /* 生成根结点 */
CreateBiTree(&(*T)->lchild); /* 构造左子树 */
CreateBiTree(&(*T)->rchild); /* 构造右子树 */
}
}

void PreOrderTraverse(BiTree T,Status(*Visit)(TElemType))
{ /* 初始条件: 二叉树T存在,Visit是对结点操作的应用函数。算法6.1，有改动 */
/* 操作结果: 先序递归遍历T,对每个结点调用函数Visit一次且仅一次 */
if(T) /* T不空 */
{
Visit(T->data); /* 先访问根结点 */
PreOrderTraverse(T->lchild,Visit); /* 再先序遍历左子树 */
PreOrderTraverse(T->rchild,Visit); /* 最后先序遍历右子树 */
}
}

void InOrderTraverse(BiTree T,Status(*Visit)(TElemType))
{ /* 初始条件: 二叉树T存在,Visit是对结点操作的应用函数 */
/* 操作结果: 中序递归遍历T,对每个结点调用函数Visit一次且仅一次 */
if(T)
{
InOrderTraverse(T->lchild,Visit); /* 先中序遍历左子树 */
Visit(T->data); /* 再访问根结点 */
InOrderTraverse(T->rchild,Visit); /* 最后中序遍历右子树 */
}
}

void PostOrderTraverse(BiTree T,Status(*Visit)(TElemType))
{ /* 初始条件: 二叉树T存在,Visit是对结点操作的应用函数 */
/* 操作结果: 后序递归遍历T,对每个结点调用函数Visit一次且仅一次 */
if(T) /* T不空 */
{
PostOrderTraverse(T->lchild,Visit); /* 先后序遍历左子树 */
PostOrderTraverse(T->rchild,Visit); /* 再后序遍历右子树 */
Visit(T->data); /* 最后访问根结点 */
}
}

Status Visit(TElemType e)//显示
{
printf("%d ",e);
return OK;
}

Status InOrderTraverse_use_stack(BiTree T,Status(*Visit)(TElemType))
{ /*非递归算法使用栈 进行前序 中序遍历  后序遍历的思想比较复杂需要使用到二次进栈*/

stack<BiTNode*> S;
BiTree p=T;
do
{
while(p)
{ /* 根指针进栈,遍历左子树 */
Visit(p->data);//先序遍历，先输出节点数据再压入栈
S.push(p);
p=p->lchild;
}
if(!S.empty())
{ /* 根指针退栈,访问根结点,遍历右子树 */
p=S.top();
//Visit(p->data);//中序遍历，在栈弹出时显示，（需要时将上面的Visit注释掉）
S.pop();
p=p->rchild;
}
}while(p||!S.empty());
printf("\n");
return OK;
}

/*
后序遍历非递归
后序非递归算法比较复杂，每个结点要到它们左、右子树都遍历完时才得以访问，所以在去遍历它的左、
右子树之前都需要进栈。当它出栈时，需要判断是从左子树回来（即刚遍历完左子树，此时需要去遍历右子树）
，还是从右子树回来（即刚遍历完右子树，此时需要去访问这个结点）。因此，进栈的结点需要伴随着一个标记
tag
*/
void PostOrderTraverse_use_stack(BiTree T)
{
stack<StackNode> S;
BiTree p;
StackNode w;
p=T;
do {
while(p)
{
w.ptr=p;
w.tag=L;
S.push(w);
p=p->lchild;
}
int cont_flag=1;
while( cont_flag&&!S.empty() )
{
w=S.top();
S.pop();
p = w.ptr;
switch(w.tag)
{
case L :
w.tag=R;
S.push(w);
cont_flag = 0;
p=p->rchild;
break;
case R:
Visit(p->data);
break;
}
}
}while(!S.empty() );
}

void LevelOrderTraverse(BiTree T,Status(*Visit)(TElemType))
{ /* 初始条件：二叉树T存在,Visit是对结点操作的应用函数 */
/* 操作结果：层序递归遍历T(利用队列),对每个结点调用函数Visit一次且仅一次 */
queue<BiTNode*> qu;
BiTree p;
p=T;
if(T)
{
qu.push(p);
while(!qu.empty())
{
p=qu.front();
qu.pop();
Visit(p->data);
if(p->lchild!=NULL)
qu.push(p->lchild);
if(p->rchild!=NULL)
qu.push(p->rchild);
}
printf("\n");
}
}

int main()
{
//输入： 1 2 3 -1 -1 4 5 -1 7 -1 -1 6 -1 -1 -1
printf("请输入构造二叉树的值，整数值，空值请输入‘-1’\n");
BiTree BT;
InitBiTree(&BT);
CreateBiTree(&BT);
printf("\n先序递归遍历递归\n");
PreOrderTraverse(BT,Visit);
printf("\n中序归遍历递归\n");
InOrderTraverse(BT,Visit);
printf("\n后序归遍历递归\n");
PostOrderTraverse(BT,Visit);
printf("\n-----------------------\n");
printf("\n先序递归遍历_非递归\n");
InOrderTraverse_use_stack(BT,Visit);
printf("\n后序遍历非递归\n");
PostOrderTraverse_use_stack(BT);
printf("\n层次遍历非递归\n");
LevelOrderTraverse(BT,Visit);
printf("\n");
DestroyBiTree(&BT);
return 0;
}