树的前序、中序、后序遍历

#include <iostream>
#include <stdlib.h>
using namespace std;

#define MAXSIZE 100
#define OK 0
#define ERROR -1
//定义结构体模板 
template <typename Type> 
 struct Node{
  struct Node<Type>* left;
  Type val;
  struct Node<Type>* right;

} ;
 typedef struct Node<int> Bnode, *Bitree;

class Stack{
private:
    int top;
    public:
    Bnode* node_array[MAXSIZE];
 public:
    Stack(){
        InitStack();
    }
    void InitStack(){
        top = -1;
    }
    bool isEmpty();
    void push(Bnode* node);
    int pop();
    int getTop(){
        return top;
    } 

};
 bool Stack::isEmpty(){
    if (top < 0){
        return true;
    }

    else return false;
 }

 void Stack::push(Bnode* node){
    top++;
    if (top > MAXSIZE){
       cout<<"Size of  Stack is Over MAXSIZE"<<endl;
       return ;
      }
    node_array[top] = node;
    return;
 }

 int Stack::pop(){
   if(isEmpty())
   {
    cout<<"Stack is NULL!!!"<<endl;
    return -1;
   }

   return top--;    
 }

Bitree CreateBitree(){

    int val;
    Bitree T;

    cin>>val;

    if (val == 0)  
        T = NULL;
    else {
        T = (Bitree) malloc(sizeof(Bnode));
        T->val = val;
        cout<<"Create left：";
        T->left = CreateBitree();
        cout<<"Create right：";
        T->right = CreateBitree();
    }
    return T;
} 

//前序遍历二叉树 
int preOrderTraverse(Bitree node){
    Stack s;
    s.push(node);
    while(!s.isEmpty()){
        while(node){
            cout<<node->val<<" ";
            node = node->left;
            if(node)
                s.push(node);
        }
        if(!s.isEmpty()){
            node = s.node_array[s.pop()];
            if(node = node->right){
                s.push(node);
            }   
        }
    }
    return OK;
} 

//中序遍历二叉树 
int InOrderTraverse(Bitree node){
    Stack s;
     s.push(node);
    while(!s.isEmpty()){
        //遍历左子树 
        while(node){
            node = node->left;
            if(node)
             s.push(node);
         }
       if(!s.isEmpty())   {
            node = s.node_array[s.getTop()];
            cout<<node->val<<" ";
            s.pop();
            node = node->right;
            if(node){
                s.push(node);
            }
        }
    }
   return OK;   
}
//后序遍历二叉树 
int postOrderTraverse(Bitree node){
    Stack s;
    int flag[MAXSIZE];
    for(int i = 0; i < MAXSIZE; i++)
        flag[i] = 0;

    s.push(node);
    flag[s.getTop()] = 1;
    while(!s.isEmpty()){
        while(node){
            node = node->left;
            s.push(node);
            flag[s.getTop()] ++;
        }
           node = s.node_array[s.getTop()];
           if(node->right){
               node = node->right;
           }
              flag[s.getTop()]++;
    }
} 

int main(){
    Stack s;

    Bitree Tree = CreateBitree();
    cout<<"InOrderTraverse():";
    InOrderTraverse(Tree);
    /*while(!s.isEmpty()){
        temp = s.node_array[s.pop()];
        cout<<temp->val<<" ";
    }*/
    cout<<endl<<"preOrderTraverse():";
    preOrderTraverse(Tree);

    cout<<endl<<"postOrderTraverse():";
    postOrderTraverse(Tree); 
   // cout<<endl<<"Traverse Success!!";

    return 0;
}