利用遞迴，構建二叉樹的時候主要就是要搞清楚，前序和中序，後序與中序的關係，然後要遞迴地往下構建，先建當前節點的左孩子，再右孩子，然後我利用另外一種序列遍歷來驗證 構建的二叉樹是否正確。

#include <iostream>
#include <cstdio>
using namespace std;
const int maxn = 35;
int in[maxn];
int pre[maxn];
struct node {
    int data;
    node *lchild;
    node *rchild;
};


//inOrder和preOrder建立 樹
 

/*
    inOrder: 12 11 20 17 1 15 8 5
    preOrder: 1 11 12 17 20 5 8 15
*/
// or
//
//use the inOrder and preOrder create the binary tree
node *Create(int preL, int preR, int inL,int inR) {
    if ( preL > preR ) return NULL;
    node *root = new node();
    root->data = pre[preL];
    int index;
    for
 
 ( index = inL; index <= inR; index++ ) {
        if ( in[index] == pre[preL] )break;
    }
    int numLeft = index - inL;
    root->lchild = Create(preL+1, preL+numLeft, inL, index-1);
    root->rchild = Create(preL+numLeft+1, preR, index+1, inR);
    return root;
}


void PostOrderTraversal(node *root) {
    if
 
 ( root != NULL ) {
        PostOrderTraversal(root->lchild);
        PostOrderTraversal(root->rchild);
        cout << root->data << " ";
    }
}
int main() {
    int n;
    cin >> n;


    for ( int i = 0 ; i < n; i++ ) {
        cin >> in[i];
    }
    for ( int i = 0; i < n; i++ ) {
        cin >> pre[i];
    }
    node *root;
    root = Create(0,n-1,0,n-1);


    PostOrderTraversal(root);


    return 0;
}


#include <iostream>
#include <cstdio>
using namespace std;
const int maxn = 35;
int in[maxn];
int post[maxn];
struct node {
    int data;
    node *lchild;
    node *rchild;
};
//inOrder和postOrder 建立 樹
/*
    inOrder:12 11 20 17 1 15 8 5
    postOrder:12 20 17 11 15 8 5 1
*/
// use the inOrder and postOrder create the binary tree
//
node *Create(int postL, int postR, int inL, int inR) {
    if ( postL > postR ) return NULL;
    node *root = new node();
    root->data = post[postR];
    int index;
    for ( index = inL; index <= inR; index++ ) {
        if ( in[index] == post[postR] )break;
    }
    int numLeft = index - inL;
    root->lchild = Create(postL, postL+numLeft-1, inL, index-1);
    root->rchild = Create(postL+numLeft, postR-1, index+1, inR);
    return root;
}
void PreOrderTraversal(node *root) {
    if ( root != NULL ) {
        cout << root->data << " ";
        PreOrderTraversal(root->lchild);
        PreOrderTraversal(root->rchild);
    }
}
int main() {
    int n;
    cin >> n;
    for ( int i = 0 ; i < n; i++ ) {
        cin >> in[i];
    }
    for ( int i = 0; i < n; i++ ) {
        cin >> post[i];
    }
    node *root;
    root = Create(0,n-1,0,n-1);
    PreOrderTraversal(root);
    return 0;
}

Java 先序和中序為例:

public class Solution {
   public static TreeNode reConstructBinaryTree(int [] pre,int [] in) {
       int in_size = in.length;
       if (in_size == 0) return null;
       int val = pre[0];
       TreeNode treeNode = new TreeNode(val);
       int i;
       for (i = 0; i < in_size; i++) {
           if (in[i] == val) break;
       }
       int[] pre_left = new int[i];
       int[] in_left = new int[i];
       int[] pre_right = new int[in_size-i-1];
       int[] in_right = new int[in_size-i-1];
       //left tree
       if (i > 0) {
           for (int j = 0; j < i; j++) {
               pre_left[j] = pre[j+1];
               in_left[j] = in[j];
           }
           treeNode.left = reConstructBinaryTree(pre_left, in_left);
       } else {
           treeNode.left = null;
       }
       //right tree
       if (in_size-i-1 > 0) {
           for (int j = i+1; j < in_size; j++) {
               pre_right[j-i-1] = pre[j];
               in_right[j-i-1] = in[j];
           }
           treeNode.right = reConstructBinaryTree(pre_right, in_right);
       } else {
           treeNode.right = null;
       }
       return treeNode;
   }
    public static class TreeNode {
       int val;
       TreeNode left;
       TreeNode right;
       TreeNode(int x) { val = x; }
    }
    public static void PostTraversal(TreeNode treeNode) {
        if (treeNode != null){
            PostTraversal(treeNode.left);
            PostTraversal(treeNode.right);
            System.out.print(treeNode.val+" ");
        }
    }
    static int[] pre = {1, 2, 4, 7, 3, 5, 6, 8};
    static int[] in = {4, 7, 2, 1, 5, 3, 8, 6};
    public static TreeNode BuildTree(int PreL, int PreR, int inL, int inR) {
        if (PreL > PreR) return null;
        int val = pre[PreL];
        TreeNode treeNode = new TreeNode(val);
        int i;
        for (i = inL; i <= inR; i++) {
            if (in[i] == val) break;
        }
        int numleft =  i - inL;
        treeNode.left = BuildTree(PreL+1, PreL+numleft, inL, i-1);
        treeNode.right = BuildTree(PreL+numleft+1, PreR, i+1, inR);
        return treeNode;
    }

    public static void main(String[] args) {

        TreeNode treeNode1 = reConstructBinaryTree(pre, in);
        PostTraversal(treeNode1);
        int len = pre.length;
        System.out.println();
        TreeNode treeNode2 = BuildTree(0, len-1, 0, len-1);
        PostTraversal(treeNode2);
    }
}