数据结构作业：利用中序遍历和后序遍历构建二叉树（RMQ转LCA）

　　最近数据结构课给了一个二叉树的作业，给出二叉树的中序和后序遍历的序列，要求构建出改二叉树。我最初的时候是想到用map和RMQ来，以稳定O(nlogn)的时间构建这棵树。这样的复杂度已经是比普通的构建方法最坏情况O(n^2)（也就是单链的情况下）的复杂度要快不少的了。不过，今天在我打模板的时候找回我的笛卡尔树算法，那时忘记了是用来处理RMQ转LCA还是LCA转RMQ的了。于是，我就去回顾了一下LCA和RMQ的资料，发现RMQ是可以转成LCA的，其中区间最小值就是二叉树的对应的那两个端点结点的LCA（最低公共祖先）。以RMQ构建出来的树也恰好是我们想要的树。代码测试通过过小数据，准备用大数据来试下有没有什么漏洞 ！

用RMQ的代码，有点复杂。。。囧：

用笛卡尔树的代码，主要操作比较简短：

/*
Author : SCAU_Lyon
Class : Software Engineering Class 10
Stu_ID : 201131001011
Problem : build binary tree by in-order && post-order traverse
Time Complexity : O(n)
Algorithm : Cartesian Tree, Hash Table
Date : 2012-11-05
Declaration : At the second day, I find a new method to solve this problem with a more efficient and space-saving algorithm.
Usage : First, input the size; then, input the in-order traverse list; last, input the post-order traverse list.
Warning : Every key should be unique! And, the tree's size is better lower than 100000!
*/

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>

using namespace std;

typedef vector<int> vi;
const int maxHash = 400009;
const int HASH = 0x55555555;
vi inOrder, postOrder;
int hash[maxHash], hashPos[maxHash];

void initHash() {
    memset(hashPos, -1, sizeof(hashPos));
}

void insHash(int pos, int key) {
    int p = ((key << 4) ^ HASH) % maxHash;

    if (p < 0) p += maxHash;
    while (hash[p] != key && ~hashPos[p]) {
        p++;
        if (p >= maxHash) p -= maxHash;
    }

    hash[p] = key;
    hashPos[p] = pos;
}

int getHash(int key) {
    int p = ((key << 4) ^ HASH) % maxHash;

    if (p < 0) p += maxHash;
    while (hash[p] != key && ~hashPos[p]) {
        p++;
        if (p >= maxHash) p -= maxHash;
    }

    return hashPos[p];
}

struct Node {
    int key, fix;
    Node *c[2], *p; // c[0] is the left child, c[1] is the right child

    Node(int _key = 0, int _fix = 0) {
        key = _key;
        fix = _fix;
        p = c[0] = c[1] = NULL;
    }
} ;

struct Cartesian {
    Node *Root, *Back;

    Cartesian() {
        Root = Back = NULL;
    }

    void delMain(Node *&rt) {
        if (!rt) return ;
        delMain(rt->c[0]);
        delMain(rt->c[1]);
        delete rt;
        rt = NULL;
    }

    void delTree() {
        delMain(Root);
    }

    void pushBack(Node *x) {
        while (Back && Back->fix < x->fix) {
            Back = Back->p;
        }
        if (Back) {
            x->c[0] = Back->c[1];
            if (Back->c[1]) {
                Back->c[1]->p = x;
            }
            Back->c[1] = x;
            x->p = Back;
        } else {
            x->c[0] = Root;
            if (Root) Root->p = x;
            Root = x;
        }
        Back = x;
    }

    void _pushBack(int key, int fix) {
        Node *tmp = new Node(key, fix);
        pushBack(tmp);
    }

    void preTra(Node *rt) {
        if (!rt) return ;
        printf("%d ", rt->key);
        preTra(rt->c[0]);
        preTra(rt->c[1]);
    }

    void preTraverse() {
        puts("pre-traverse : ");
        preTra(Root);
        puts("");
    }

    void inTra(Node *rt) {
        if (!rt) return ;
        inTra(rt->c[0]);
        printf("%d ", rt->key);
        inTra(rt->c[1]);
    }

    void inTraverse() {
        puts("in-traverse : ");
        inTra(Root);
        puts("");
    }

    void postTra(Node *rt) {
        if (!rt) return ;
        postTra(rt->c[0]);
        postTra(rt->c[1]);
        printf("%d ", rt->key);
    }

    void postTraverse() {
        puts("post-traverse : ");
        postTra(Root);
        puts("");
    }
} cart;

void input(int n) {
    int x;

    inOrder.clear();
    postOrder.clear();
    initHash();

    for (int i = 0; i < n; i++) {
        scanf("%d", &x);
        inOrder.push_back(x);
    }
    for (int i = 0; i < n; i++) {
        scanf("%d", &x);
        postOrder.push_back(x);
        insHash(i, x);
    }
}

void buildTree(int n) {
    cart = Cartesian();
    for (int i = 0; i < n; i++) {
        cart._pushBack(inOrder[i], getHash(inOrder[i]));
    }
}

int main() {
    int n;

//    freopen("in", "r", stdin);
    while (~scanf("%d", &n)) {
        input(n);
        buildTree(n);
        puts("Built Successfully!");

//        cart.preTraverse();
//        cart.inTraverse();
//        cart.postTraverse();
//        puts("");
        /*** You can add other functions here! ***/

        /*****************************************/

        cart.delTree();
    }

    return 0;
}

　　一个简单的算法就这样被我搞复杂了，还用了不少非教材上的算法。。。囧！不过还是挺好玩的~

 补充：通过大数据（100组约60000个结点的随机数据）的运算，算法1平均要27秒，算法2平均只要9秒~

——written by Lyon