面试100题之43 -- 递归和非递归二叉树遍历

参考了july的非递归解法，一下是自己的代码：

//递归和非递归遍历Tree

//         1

//       /   \

//      2     3

//     / \   / \

//    4   5 6   7

//Pre-Order: 1 2 4 5 3 6 7

//In-Order:  4 2 5 1 6 3 7

//Post-Order:4 5 2 6 7 3 1



#include <iostream>

#include <cstdio>

#include <stack>



using namespace std;



typedef struct node

{

    int val;

    struct node *lc;

    struct node *rc;

    node(int v1, struct node* _lc, struct node* _rc):val(v1),lc(_lc),rc(_rc){};

}Node;



Node* createTree()

{

    Node *n4 = new Node(4,NULL,NULL);

    Node *n5 = new Node(5,NULL,NULL);

    Node *n6 = new Node(6,NULL,NULL);

    Node *n7 = new Node(7,NULL,NULL);

    Node *n2 = new Node(2,n4,n5);

    Node *n3 = new Node(3,n6,n7);

    Node *n1 = new Node(1,n2,n3);

    return n1;

}



void preOrder(const Node * p)

{

    if(!p)

    {

        return;

    }

    printf("%d\n",p->val);

    preOrder(p->lc);

    preOrder(p->rc);

}



void preOrder1(Node *p)

{

    stack<Node*> ns;



    while(!ns.empty() || p)

    {

        while(p)

        {

            printf("%d\n",p->val);

            ns.push(p);

            p=p->lc;

        }

        if(!ns.empty())

        {

            p=ns.top();

            ns.pop();

            p=p->rc;

        }

    }

}



void inOrder(const Node *p)

{

    if(!p)

    {

        return;

    }

    inOrder(p->lc);

    printf("%d\n",p->val);

    inOrder(p->rc);

}



void inOrder1(Node *p)

{

    stack<Node*> ns;



    while(!ns.empty()||p)

    {

        while(p)

        {

            ns.push(p);

            p=p->lc;

        }

        if(!ns.empty())

        {

            p=ns.top();

            printf("%d\n",p->val);

            ns.pop();

            p=p->rc;

        }

    }

}



void postOrder(const Node *p)

{

    if(!p)

    {

        return;

    }

    postOrder(p->lc);

    postOrder(p->rc);

    printf("%d\n",p->val);

}



void postOrder1(Node *p)

{

    stack<Node *> ns;

    bool tag[8] = {false};



    while(!ns.empty() || p)

    {

        while(p)

        {

            ns.push(p);

            p=p->lc;

        }

        while(!ns.empty()&&tag[ns.top()->val]==true)

        {

            p=ns.top();

            printf("%d\n",p->val);

            ns.pop();

        }

        if(!ns.empty())

        {

            p=ns.top();

            tag[p->val]=true;

            p=p->rc;

        }

        else

        {

            p=NULL;

        }

    }

}



int main()

{

    Node *root;



    root=createTree();



    printf("preOrder Travel:\n");

    preOrder(root);

    printf("\n\n");



    printf("InOrder Travel:\n");

    inOrder(root);

    printf("\n\n");



    printf("PostOrder Travel:\n");

    postOrder(root);

    printf("\n\n");



    //with stack, non-recursive travel

    printf("preOrder1 Travel:\n");

    preOrder1(root);

    printf("\n\n");



    printf("InOrder1 Travel:\n");

    inOrder1(root);

    printf("\n\n");



    printf("PostOrder1 Travel:\n");

    postOrder1(root);

    printf("\n\n");



    return 0;

}

　　

 

转自http://blog.csdn.net/v_JULY_v/article/details/6171539

现在，我们可以看二叉树前序遍历的非递归实现了。
按照二叉树前序遍历的定义，无论是访问整棵树还是其子树，均应该遵循先访问根结点，
然后访问根结点的左子树，最后访问根结点的右子树的。

 

因为对于一棵树（子树）t,如果t非空，访问完t的根结点值后，就应该进入t的左子树，
但此时必须将t保存起来，以便访问完其左子树后，进入其右子树的访问。
yeah，就是这个意思。:）...

即在t处设置一个回溯点，并将该回溯点进栈保存。

 

在整个二叉树前序遍历的过程中，程序始终要做的工作分成俩个部分：
1.当前正在处理的树（子树）
2.保存在栈中等待处理的部分。

//注：当栈中元素位于栈顶即将出栈时，意味着其根结点和左子树已访问完成，
//出栈后，进入其右子树进行访问，
//前序遍历，非递归实现

//出栈后，进入其右子树进行访问，

//前序遍历，非递归实现

void preorderT(bintree t)

{

  seqstack s;

  s.top=0;

  while( (t)||(s.top!=0) )  //当前处理的子树不为空或栈不为空

  {

    while(t)         //子树不为空

    {

      printf("%c",t->data);   //1.先访问根结点

      push(&s,t);             //2.访问左子树之前，记得先把根结点进栈保存 

      t=t->lchild;            //3.然后才访问左子树，

    }

    if(s.top>0)      //栈不为空

    {

      t.pop(&s);               //4.pop根结点

      t=t->rchild;             //5.访问右子树

    }

  }

}



//中序遍历，非递归实现，

void inorderT(bintree t)

{

  seqstack s;

  s.top=0;

  while( (t)||(s.top!=0) )  //当前处理的子树不为空或栈不为空

  {

    while(t)     //子树不为空

    {

      push(&s,t);             //1.访问左子树之前，记得先把根结点push进栈

      t=t->lchild;            //2.访问左子树

    }

    if(s.top!=0)    //栈不为空

    {

      t.pop(&s);             //3.pop根结点(访问完左子树后)

      printf("%c",t->data);  //4.访问根结点 (把先前保存的t给拿出来，要用了..)

      t=t->rchild;           //5.访问右子树

    }

  }

}

　　

//后序遍历，非递归实现
后序遍历的非递归算法，稍微复杂点。请看，

按照二叉树后序遍历的定义，无论是访问整棵树还是起子树，
均应该遵循先访问根结点左子树，然后访问根结点的右子树，最后访问根结点。

值得注意的是，当一个元素位于栈顶即将处理的是，其左子树的访问一定完成，
如果其右子树不为空，接下来应该进入其右子树尽情访问。
//注意了，
但此时该栈顶元素时不能出栈的，因为它作为根结点，其本身的值还未被访问。
只有等到其右子树也访问完成后，该栈顶元素才能出栈，并输出它的值。

因此，在二叉树后序遍历的算法中，必须使用seqstack类型的数组tag，
其每个元素取值为0或1，用于标识栈中每个元素的状态。

1.当一个元素刚进栈时，其对应的tag值置为0；
2.当它位于栈顶即将被处理时，其tag值为0.意味着应该访问其右子树。
于是将右子树作为当前处理的对象，此时该栈顶元素仍应该保留在栈中。
并将其对应的tag值改为1.
3.当其右子树访问完成后，该元素又一次位于栈顶，而此时其tag值为1，
意味着其右子树已访问完成，接下来，应该直接访问的就是它，将其出栈。

void postorderT(bintree t)

{

  seqstack s;

  s.top=0;

  while( (t)||(s.top!=0) )

  {

    while(t)

    {

      s.data[s.top]=t;

      s.tag[s.top]=0;   //tag置为0

      s.top++;

      t=t->lchild;      //访问左子树

    }

    while( (s.top>0)&&(s.tag[s.top-1]==1) )        

    {

      s.top--;

      t=s.data[s.top];

      printf("%c",t->data);

    }

    if(s.top>0)

    {

      t=s.data[s.top-1];

      s.tag[s.top-1]=1;

      t=t->rchild;

    }

    else

      t=NULL;

  }

}