二叉树遍历（递归和非递归实现）

二叉树遍历（递归和非递归实现），网上看了一圈，整理了下，下面直接上代码。。。

#include<iostream>
#include<stack>

#define N 7
using namespace std;

typedef struct node
{
    struct node *leftChild;
    struct node *rightChild;
    int data;
}BiTreeNode, *BiTree;

BiTreeNode *createNode(int i)
{
    BiTreeNode * q = new BiTreeNode;
    q->leftChild = NULL;
    q->rightChild = NULL;
    q->data = i;

    return q;
}

//建树
//1
//2 3
//4 5 6 7
BiTree createBiTree()
{
    BiTreeNode *p[N] = {NULL};
    int i;
    for(i = 0; i < N; i++)
        p[i] = createNode(i + 1);

    for(i = 0; i < N/2; i++)
    {
        p[i]->leftChild = p[i * 2 + 1];
        p[i]->rightChild = p[i * 2 + 2];
    }

    return p[0];
}

int visit(BiTree T)
{
    return T->data;
}

// 先序遍历
void preOrderTraverse(BiTree T)
{
    if(T)
    {
        cout << visit(T) << " ";
        preOrderTraverse(T->leftChild);
        preOrderTraverse(T->rightChild);
    }
}

// 中序遍历
void inOrderTraverse(BiTree T)
{
    if(T)
    {
        inOrderTraverse(T->leftChild);
        cout << visit(T) << " ";
        inOrderTraverse(T->rightChild);
    }
}

// 后序遍历
void postOrderTraverse(BiTree T)
{
    if(T)
    {
        postOrderTraverse(T->leftChild);
        postOrderTraverse(T->rightChild);
        cout << visit(T) << " ";
    }
}

//非递归前序遍历
//1)访问结点P，并将结点P入栈;
//2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);
//若不为空，则将P的左孩子置为当前的结点P;
//3)直到P为NULL并且栈为空，则遍历结束。
//单步执行下就明白了
void preOrderTraverse2(BiTree T)     //非递归前序遍历 
{
    stack<BiTree> s;
    BiTree p = T;
    while(p != NULL || !s.empty())
    {
        while(p != NULL)
        {
            cout<< p->data <<" ";
            s.push(p);
            p = p->leftChild;
        }

        if(!s.empty())
        {
            p = s.top();
            s.pop();
            p = p->rightChild;
        }
    }
}

//非递归中序遍历
//1)若其左孩子不为空，则将P入栈并将P的左孩子置为当前的P，然后对当前结点P再进行相同的处理；
//2)若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的P置为栈顶结点的右孩子；
//3)直到P为NULL并且栈为空则遍历结束
void inOrderTraverse2(BiTree T)      //非递归中序遍历
{
    stack<BiTree> s;
    BiTree p=T;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            s.push(p);
            p=p->leftChild;
        }
        if(!s.empty())
        {
            p=s.top();
            cout<<p->data<<" ";
            s.pop();
            p=p->rightChild;
        }
    }    
}

//非递归后序遍历
//思路：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。
void postOrderTraverse2(BiTree T)     //非递归后序遍历
{
    stack<BiTree> s;
    BiTree cur;                      //当前结点 
    BiTree pre=NULL;                 //前一次访问的结点 
    s.push(T);
    while(!s.empty())
    {
        cur=s.top();
        if( (cur->leftChild == NULL && cur->rightChild == NULL) || 
           (pre!=NULL && (pre==cur->leftChild || pre==cur->rightChild)) )
        {
            cout<<cur->data<<" ";  //如果当前结点没有孩子结点或者孩子节点都已被访问过 
              s.pop();
            pre=cur; 
        }
        else
        {
            if(cur->rightChild!=NULL)
                s.push(cur->rightChild);
            if(cur->leftChild!=NULL)    
                s.push(cur->leftChild);
        }
    }    
}

int main()
{
    BiTree T = createBiTree();

    cout << "先序遍历:" << endl;
    preOrderTraverse(T);
    cout << endl << endl;

    cout << "中序遍历:" << endl;
    inOrderTraverse(T);
    cout << endl << endl;

    cout << "后序遍历:" << endl;
    postOrderTraverse(T);
    cout << endl << endl;

    cout << "非递归先序遍历:" << endl;
    preOrderTraverse2(T);
    cout << endl << endl;

    cout << "非递归中序遍历:" << endl;
    inOrderTraverse2(T);
    cout << endl << endl;

    cout << "非递归后序遍历:" << endl;
    postOrderTraverse2(T);
    cout << endl << endl;

    return 0;
}