二叉树遍历的非递归实现

#include<stdio.h>

#include<stack>

#include<stdlib.h>

using namespace std;



struct ListNode

{

    int data;

    ListNode *lchild,*rchild;

};



ListNode* Createbst()

{

    int data;

    scanf("%d",&data);

    if(data!=-1)

    {

        ListNode* root=(ListNode*)malloc(sizeof(ListNode));

        root->lchild=root->rchild=NULL;

        root->data=data;

        root->lchild=Createbst();

        root->rchild=Createbst();

        return root;

    }

    else return NULL;

}



void PreOrder(ListNode *root)

{

    stack<ListNode*> s;

    ListNode *p=root;

    while(p!=NULL || !s.empty())

    {

        while(p!=NULL)

        {

            printf("%d",p->data);

            s.push(p);

            p=p->lchild;

        }

        if(!s.empty())

        {

            p=s.top();

            s.pop();

            p=p->rchild;

        }

    }

}



int main()

{

    ListNode* root;

    root=Createbst();

    PreOrder(root);

    return 0;

}

　中序遍历

void InOrder(ListNode*root)

{

    stack<ListNode*>s;

    ListNode* p=root;

    while(p!=NULL || !s.empty())

    {

        while(p!=NULL)

        {

            s.push(p);

            p=p->lchild;

        }

        if(!s.empty())

        {

            p=s.top();

            s.pop();

            printf("%d",p->data);

            p=p->rchild;

        }

    }

}

　后序遍历

struct BiTree

{

    ListNode* treeNode;

    int flag;

};

void PostOrder(ListNode* root)

{

   stack<BiTree*> s;

   BiTree* sTree=(BiTree*)malloc(sizeof(BiTree));

   sTree->treeNode=root;

   sTree->flag=0;

   s.push(sTree);

   while(!s.empty())

   {

       BiTree* tmptree=s.top();

       if(tmptree->flag==2)

       {

           printf("%d ",tmptree->treeNode->data);

           s.pop();

       }

       else

       {

           if(tmptree->treeNode->rchild)

           {

               sTree=(BiTree*)malloc(sizeof(BiTree));

               sTree->flag=0;

               sTree->treeNode=tmptree->treeNode->rchild;

               s.push(sTree);

           }

           tmptree->flag++;

           if(tmptree->treeNode->lchild) 

           {

               sTree=(BiTree*)malloc(sizeof(BiTree));

               sTree->flag=0;

               sTree->treeNode=tmptree->treeNode->lchild;

               s.push(sTree);

           }

           tmptree->flag++;

       }

   }

}