树的遍历（链式结构）

树的遍历（Pre、In、Post递归&非递归算法，层序遍历）

#include <bits/stdc++.h>
using namespace std;
typedef struct node{
    int data, Level;
    struct node *L, *R;
}*BiTree;
int n, m = 0, layer[50], in[50];
//递归算法 
void Order1(BiTree root){
    if(root){
        //printf("%d%s", root->data, ++m == n ? "\n" : " "); //visit(root);
        Order1(root->L);
        //printf("%d%s", root->data, ++m == n ? "\n" : " "); //visit(root);
        Order1(root->R);
        //printf("%d%s", root->data, ++m == n ? "\n" : " "); //visit(root);
    }
}

//先序&中序非递归 
void Order(BiTree root){
    stack<BiTree> s;        // 初始化栈s 
    BiTree p = root;        // p指向根节点 
    while(p || !s.empty()){                 // 如果p不为空或者栈s不空 
        if(p){                              // 如果p不为空，走到最左边 
            //printf("%d ", p->data);   // 访问p;（先序） 
            s.push(p);                      // p压入栈中 
            p = p->L;                       // p指向p的左子树 
        }else{                              // 如果p为空 
            p = s.top();                    // p指向栈顶元素 
            //printf("%d ", p->data);   // 访问p;（中序）
            p = p->R;                       // p指向p的右子树 
            s.pop();                        // 栈顶出栈 
        }
    }
}
//后序非递归
void PostOrder(BiTree root){
    stack<BiTree> s;
    BiTree p = root, r = NULL;
    while(p || !s.empty()){
        if(p){//走到最左边
            s.push(p);
            p = p->L;
        }else{
            p = s.top();
            if(p->R && p->R != r){//右子树存在，未被访问
                p = p->R;
                s.push(p);
                p = p->L;
            }else{   //p出栈时，栈内为根节点到p的路径，以此可以求解公共结点等
                printf("%d ", p->data);//visit(p);
                s.pop();
                r = p;//记录最近访问过的节点
                p = NULL;//节点访问完后，重置p指针
            }
        }
    }
}
//层次
void LevelOrder(BiTree root){
    queue<BiTree> q;      //队列中存放Birootnode变量的地址，这样就可以通过访问地址去修改原元素
    //root->Level = 1;           //记录结点深度
    q.push(root);
    while(!q.empty()){
        BiTree p = q.front();
        q.pop();
        printf("%d ", p->data);//visit(p);
        if(p->L){
            //p->L->Level = p->Level + 1;       //计算各结点深度
            q.push(p->L);
        }
        if(p->R){
            //p->R->Level = p->Level + 1;
            q.push(p->R);
        }
    }
}
BiTree LayerInCreate(int layerL, int layerR, int inL, int inR){
    if(inL > inR)    return NULL;
    int i, j;
    for(i = layerL; i <= layerR; i++){
        bool flag = true;
        for(j = inL; j <= inR; j++){
            if(layer[i] == in[j]){
                flag = false;
                break;
            }
        }
        if(!flag)   break;
    }
    BiTree root = new node;
    root->data = in[j];
    root->L = LayerInCreate(layerL, layerR, inL, j-1);
    root->R = LayerInCreate(layerL, layerR, j+1, inR);
    return root;
}
int main(){
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
        scanf("%d", &layer[i]);
    for(int i = 1; i <= n; i++)
        scanf("%d", &in[i]);
    BiTree root = LayerInCreate(1, n, 1, n);
    //printf("前序非递归：\n"); 
    //Order(root);
    //printf("\n中序非递归：\n"); 
    //Order(root);
    printf("\n后序非递归：\n"); 
    PostOrder(root);
    printf("\n层序：\n"); 
    LevelOrder(root);
    return 0;
}

输入样例

9
1 2 3 4 5 6 7 8 9
4 2 8 5 1 6 9 3 7

输出样例

后序非递归：
4 8 5 2 9 6 7 3 1
层序：
1 2 3 4 5 6 7 8 9