二叉树的遍历

设计和调试的算法希望对你们有用哟：

1、递归建立二叉树；

2、先序递归遍历二叉树；

3、中序递归遍历二叉树；

4、后序递归遍历二叉树。

5、中序非递归遍历二叉树

首先要建立一个工程，编译器用codeblocks, vc 6.0等，都能运行，但是可能需要自己调试一下，毕竟每个编译器的环境都是不一样的。

头文件//header,h

#include 
#include 
#include 
#include 
#define  TRUE 1
#define  FALSE 0
#define  OK 1
#define  ERROR 0
#define INFEASIBLE -1
#define  OVERFLOW-2
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
using namespace std;
              //Status是函数的类型，其值是函数结果状态代码
typedef int  status;
typedef int TelemType;
 

算法头文件//Bitree.h

 

#include"header.h"
typedef struct BiTNode {
       TelemTypedata;
        structBiTNode *lchild,*rchild;
} BiTNode,*BiTree;
typedef BiTree SElemType;
typedef struct {
              SElemType *base;
              SElemType  *top;
              int stacksize;
              }SqStack;
status InitStack(SqStack &S) {
       S.base =(SElemType *)malloc  (STACK_INIT_SIZE*sizeof (SElemType));
       if(!S.base) exit (OVERFLOW);
       S.top =S.base;
       S.stacksize= STACK_INIT_SIZE;
       return OK;
     }//InitStack
status StackEmpty(SqStack S)
{
  if (S.base==S.top)
    return TRUE;
  return FALSE;
}
status Push(SqStack &S, SElemType &e) {
          if (S.top-S.base>=S.stacksize) //栈满
           { S.base=(SElemType *)realloc
             (S.base, (S.stacksize+STACKINCREMENT)
             * sizeof(SElemType));
             if (!S.base) exit (OVERFLOW);
             S.top  = S.base + S.stacksize;
             S.stacksize+=STACKINCREMENT;
              } // if
           *S.top++ = e;   return OK; } //Push
status Pop(SqStack &S, SElemType &e) {
         if(S.top == S.base)return ERROR;
        e = * -- S.top;
        return OK;
       } //Pop
status CreateBiTree(BiTree &T){
//按先序次序输入二叉树中结点的值,空格表示空树
//生成二叉树的二叉链表存储结构，T为根结点指针]
    char ch;
   cin>>ch;
    if (ch==' ')T=NULL;
    else{
          if(!(T=(BiTNode *) malloc(sizeof(BiTNode)))) exit(OVERFLOW);
          T->data=ch;  //建立根结点
          CreateBiTree( T->lchild);  //建立左子树
          CreateBiTree(T->rchild);  //建立右子树
          }
  return OK;
} //CreateBiTree
status PrintElement(TelemType e)
{
   cout<data))
     if(PreorderTraverse(T->lchild,visit))
       if(PreorderTraverse(T->rchild,visit)) return OK;
       returnERROR;
       }elsereturn OK;   //if (T)
 }//PreorderTraverse
status InorderTraverse1(BiTree T, status(*visit)(TelemType e)) {
       //先序遍历根结点指针为T的二叉树
 
       if(T)  {
              if(InorderTraverse1(T->lchild,visit))
                     if(visit(T->data))
                            if(InorderTraverse1(T->rchild,visit)) return OK;
              returnERROR;
       }elsereturn OK;   //if (T)
}//InorderTraverse
status  PostorderTraverse(BiTreeT, status(*visit)(TelemType e)) {
//后序遍历根结点指针为T的二叉树
 
if (T)  {
   if(PostorderTraverse(T->lchild,visit))
       if(PostorderTraverse(T->rchild,visit))
              if(visit(T->data))  return OK;
       returnERROR;
       }elsereturn OK;   //if (T)
 }//PostorderTraverse
status InorderTraverse2(BiTree T,status(*visit)(TelemType e)) {
       SqStack S;
       InitStack(S);   BiTree p = T;
              while(p || !StackEmpty(S) ){ // 找到最左下的结点
                     if(p)
               {  Push(S,p);   p=p->lchild;  } // 根指针进栈，遍历左子树
                     else  {                                 //根指针退栈，访问根结点，遍历右子树
                            Pop(S,p);   if (!visit(p->data)  ) return ERROR;
                            p=p->rchild;
                     }//else
              }// while
              return  OK;
}// InOrderTraverse

主函数//main.cpp

#include"header.h"
#include"Bi tree.h"
int main()
{
    BiTree T;
    cout<< "Please input characters to create a tree" << endl;
   CreateBiTree(T);
    cout<