DS实验题 Order 已知父节点和中序遍历求前、后序

题目：

思路：

这题是比较典型的树的遍历问题，思路就是将中序遍历作为位置的判断依据，假设有个节点A和它的父亲Afa，那么如果A和Afa的顺序在中序遍历中是先A后Afa，则A是Afa的左儿子，否则是右儿子。

用for遍历一遍所有的节点，让每一个节点都连接到它的父亲，最后从根节点开始访问即可。

代码：

//
//  main.cpp
//  Tree
//
//  Created by wasdns on 16/12/19.
//  Copyright ? 2016年 wasdns. All rights reserved.
//  

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;  

struct Node
{
    int num;  

    Node *lnext, *rnext;
};  

int fa[10005];                  //父亲

Node* node[100005];             //节点

int midorder[100005];           //中序

int preorder[100005];           //先序               

int aftorder[100005];           //后序

int tot = 0;    

/*
    Ininode函数：初始化各个节点
 */
void Ininode(int n)
{
    for (int i = 1; i <= n; i++)
    {
        Node *p = new Node;  

        p -> num = i;
        p -> lnext = NULL;
        p -> rnext = NULL;  

        node[i] = p;
    }
}  

/*
    isleft函数：判断儿子是左儿子还是右儿子
 */
bool isleft(int n, int num, int f)
{
    bool ans = true;  

    for (int i = 1; i <= n; i++)
    {
        if (midorder[i] == num || midorder[i] == f)
        {
            if (midorder[i] == f) {
                ans = false;
            }  

            break;
        }
    }  

    return ans;
}  

/*
    CreatTree：建树
 */
Node* CreatTree(int n)
{
    int i;  

    int fanum;  

    for (i = 2; i <= n; i++)
    {
        fanum = fa[i];  

        if (isleft(n, i, fanum)) {
            node[fanum] -> lnext = node[i];
        }  

        else {
            node[fanum] -> rnext = node[i];
        }
    }  

    return node[1];
}

/*
    CalPreorder函数：计算先序
 */
void CalPreorder(Node *p)
{
    if (p -> lnext == NULL && p -> rnext == NULL) {  

        preorder[tot++] = p -> num;  

        return ;
    }  

    preorder[tot++] = p -> num;  

    if (p -> lnext != NULL) CalPreorder(p -> lnext);  

    if (p -> rnext != NULL) CalPreorder(p -> rnext);
}  

/*
    CalAftorder函数：计算后序
 */
void CalAftorder(Node *p)
{
    if (p -> lnext == NULL && p -> rnext == NULL) {  

        aftorder[tot++] = p -> num;  

        return ;
    }  

    if (p -> lnext != NULL) CalAftorder(p -> lnext);  

    if (p -> rnext != NULL) CalAftorder(p -> rnext);  

    aftorder[tot++] = p -> num;
}  

/*
    PrintTree函数：中序遍历(queue思想)输出树
 */
void PrintTree(Node *head)
{
    queue<Node*> q;  

    q.push(head);  

    Node *p;  

    while (!q.empty())
    {
        p = q.front();  

        q.pop();  

        cout << p -> num << " ";  

        if (p -> lnext != NULL) {
            q.push(p -> lnext);
        }  

        if (p -> rnext != NULL) {
            q.push(p -> rnext);
        }
    }  

    cout << endl;
}  

/*
    Print函数：输出结果
 */
void Print(int n)
{
    int i;  

    for (i = 0; i < n; i++) {
        cout << preorder[i] << " ";
    }  

    cout << endl;  

    for (i = 0; i < n; i++) {
        cout << aftorder[i] << " ";
    }  

    cout << endl;
}  

int main()
{
    int n;  

    cin >> n;  

    int i;  

    for (i = 1; i <= n; i++) {
        cin >> fa[i];
    }  

    for (i = 1; i <= n; i++) {
        cin >> midorder[i];
    }  

    Ininode(n);  

    Node* head;  

    head = new Node;  

    head = CreatTree(n);  

    //PrintTree(head);  

    CalPreorder(head);  

    tot = 0;  

    CalAftorder(head);  

    Print(n);  

    return 0;
}  

2016/12/19