二叉树的几种递归和非递归式遍历

#include <fstream>
#include <iostream>

using namespace std;

/*
    后序遍历的非递归实现是三种遍历方式中最难的一种。因为在后序遍历中，要保证左孩子和右孩子都已被访问并且左孩子在右孩子
前访问才能访问根结点，这就为流程的控制带来了难题。下面介绍两种思路。
    第一种思路：对于任一结点P，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点，此时该结点出现在栈顶，
但是此时不能将其出栈并访问，因此其右孩子还为被访问。所以接下来按照相同的规则对其右子树进行相同的处理，当访问完其右孩子
时，该结点又出现在栈顶，此时可以将其出栈并访问。这样就保证了正确的访问顺序。可以看出，在这个过程中，每个结点都两次出现
在栈顶，只有在第二次出现在栈顶时，才能访问它。因此需要多设置一个变量标识该结点是否是第一次出现在栈顶。
    第二种思路：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，
则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种
情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结
点前面被访问。
*/

#define queue_len 100

struct node
{
    char c;
    struct node *lch,*rch;
    bool flag;
    node():flag(0){}
    void get_c()
    {
        printf("%c",c);
    }
};

node* set_tree();//建树
void pre_order(node* tree);//先序遍历
void in_order(node* tree);//中序遍历
void post_order(node* tree);//后序遍历
void level_order(node* tree);//层次遍历
void nr_pre_order(node* tree);//非递归先序遍历
void nr_in_order(node* tree);//非递归中序遍历
void nr_post_order_1(node* tree);//非递归后序遍历
void nr_post_order_2(node* tree);//非递归后序遍历

int main()
{
    //freopen("D:\input.in","r",stdin);
    //freopen("D:\output.out","w",stdout);
    node* tree=set_tree();
    printf("先序遍历：");
    pre_order(tree);
    puts("");
    printf("中序遍历：");
    in_order(tree);
    puts("");
    printf("后序遍历：");
    post_order(tree);
    puts("");
    printf("层次遍历：");
    level_order(tree);
    puts("");
    printf("先序遍历：");
    nr_pre_order(tree);
    puts("");
    printf("中序遍历：");
    nr_in_order(tree);
    puts("");
    printf("后序遍历：");
    nr_post_order_1(tree);
    puts("");
    printf("后序遍历：");
    nr_post_order_2(tree);
    puts("");
    return 0;
}
node* set_tree()
{
    node* p,*s;
    node* gen=new node;
    gen->c='A';

    gen->lch=new node;
    p=gen->lch;
    p->c='B';
    p->rch=NULL;
    p->lch=new node;
    p=p->lch;
    p->c='D';
    p->lch=NULL;
    p->rch=new node;
    p=p->rch;
    p->c='G';
    p->lch=NULL;
    p->rch=NULL;

    gen->rch=new node;
    p=gen->rch;
    p->c='C';
    p->lch=new node;
    s=p->lch;
    s->c='E';
    s->lch=NULL;
    s->rch=NULL;
    p->rch=new node;
    s=p->rch;
    s->c='F';
    s->lch=NULL;
    s->rch=NULL;

    return gen;
}
void pre_order(node* tree)
{
    if(tree!=NULL)
    {
        tree->get_c();
        pre_order(tree->lch);
        pre_order(tree->rch);
    }
}
void in_order(node* tree)
{
    if(tree!=NULL)
    {
        in_order(tree->lch);
        tree->get_c();
        in_order(tree->rch);
    }
}
void post_order(node* tree)
{
    if(tree!=NULL)
    {
        post_order(tree->lch);
        post_order(tree->rch);
        tree->get_c();
    }
}
void level_order(node* tree)
{
    node* queue_1[queue_len];
    int front,rear;

    if(tree==NULL)  return;
    front=-1;
    rear=0;
    queue_1[rear]=tree;
    while(front!=rear)
    {
        front++;
        queue_1[front]->get_c();

        if(queue_1[front]->lch!=NULL)
        {
            rear++;
            queue_1[rear]=queue_1[front]->lch;
        }
        if(queue_1[front]->rch!=NULL)
        {
            rear++;
            queue_1[rear]=queue_1[front]->rch;
        }
    }
}
void nr_pre_order(node* tree)
{
    node* stack_1[queue_len];
    int top=-1;

    if(tree==NULL)  return;
    node* p=tree;
    while(p!=NULL||top!=-1)
    {
        while(p!=NULL)
        {
            p->get_c();
            stack_1[++top]=p;
            p=p->lch;
        }
        if(top==-1) return;
        p=stack_1[top--]->rch;
    }
}
void nr_in_order(node* tree)
{
    node* stack_1[queue_len];
    int top=-1;

    if(tree==NULL)  return;
    node* p=tree;
    while(p!=NULL||top!=-1)
    {
        while(p!=NULL)
        {
            stack_1[++top]=p;
            p=p->lch;
        }
        if(top==-1) return;
        stack_1[top]->get_c();
        p=stack_1[top--]->rch;
    }
}
void nr_post_order_1(node* tree)
{
    node* stack_1[queue_len];
    int top=-1;

    if(tree==NULL)  return;
    node* p=tree;
    while(p!=NULL||top!=-1)
    {
        while(p!=NULL)
        {
            stack_1[++top]=p;
            p=p->lch;
        }
        if(top==-1) return;
        p=stack_1[top];
        if(p->flag==0)  {p->flag=1;p=p->rch;}
        else   { p->get_c(),top--;p=NULL;}
    }
}
void nr_post_order_2(node* tree)
{
    node* stack_1[queue_len];
    int top=0;

    if(tree==NULL)  return;
    node* p=tree;
    while(top!=-1)
    {
        p=stack_1[top];
        if((p->lch==NULL||p->lch->flag==0)&&(p->rch==NULL||p->rch->flag==0))
        {
            p->get_c();
            p->flag=0;
            top--;
        }
        else
        {
            if(p->rch!=NULL)
            {
                stack_1[++top]=p->rch;
            }
            if(p->lch!=NULL)
            {
                stack_1[++top]=p->lch;
            }
        }
    }
}