題目：輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建出該二叉樹

 　

　　

　　問題描述：

　　　　輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建出該二叉樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重復的數字。例如輸入前序遍歷序列{1,2,4,7,3,5,6,8}和中序遍歷序列{4,7,2,1,5,3,8,6}，則重建二叉樹並返回。

　　思路：

　　在二叉樹的前序遍歷序列中，第一個數字總是樹的根結點的值。但在中序遍歷序列中，根結點的值在序列的中間，左子樹的結點的值位於根結點的值的左邊，而右子樹的結點的值位於根結點的值的右邊。因此我們需要掃描中序遍歷序列，才能找到根結點的值。

　　如下圖所示，前序遍歷序列的第一個數字1就是根結點的值。掃描中序遍歷序列，就能確定根結點的值的位置。根據中序遍歷特點，在根結點的值1前面的3個數字都是左子樹結點的值，位於1后面的數字都是右子樹結點的值。

 

 

　　

　　同樣，在前序遍歷的序列中，根結點后面的3個數字就是3個左子樹結點的值，再后面的所有數字都是右子樹結點的值。這樣我們就在前序遍歷和中序遍歷兩個序列中，分別找到了左右子樹對應的子序列。

　　既然我們已經分別找到了左、右子樹的前序遍歷序列和中序遍歷序列，我們可以用同樣的方法分別去構建左右子樹。也就是說，接下來的事情可以用遞歸的方法去完成。
　　完整的代碼示例如下，方式一使用數組存儲前序遍歷序列和中序遍歷序列；方式二使用容器存儲。

/*
題目描述
輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建出該二叉樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重復的數字。
例如輸入前序遍歷序列{1,2,4,7,3,5,6,8}和中序遍歷序列{4,7,2,1,5,3,8,6}，則重建二叉樹並返回。
*/

/*
思路：
先序遍歷的第一個元素為根節點，在中序遍歷中找到這個根節點，從而可以將中序遍歷分為左右兩個部分，
左邊部分為左子樹的中序遍歷，右邊部分為右子樹的中序遍歷，進而也可以將先序遍歷除第一個元素以外的剩余部分分為兩個部分，
第一個部分為左子樹的先序遍歷，第二個部分為右子樹的先序遍歷。
由上述分析結果，可以遞歸調用構建函數，根據左子樹、右子樹的先序、中序遍歷重建左、右子樹。
*/
/*
Time:2016年9月9日11:57:07
Author:CodingMengmeng
*/

/*
方式一：
    數組+遞歸
*/
#include <iostream>
using namespace std;

//樹結點結構體
struct BinaryTreeNode
{

    int                    m_nValue;
    BinaryTreeNode*        m_pLeft;
    BinaryTreeNode*        m_pRight;



};

//打印樹結點
void PrintTreeNode(BinaryTreeNode *pNode)
{
    if (pNode != NULL)
    {
        printf("value of this node is : %d\n", pNode->m_nValue);

        if (pNode->m_pLeft != NULL)
            printf("value of its left child is: %d.\n", pNode->m_pLeft->m_nValue);
        else
            printf("left child is null.\n");
        if (pNode->m_pRight != NULL)
            printf("value of its right childe is : %d.\n", pNode->m_pRight->m_nValue);
        else
            printf("right child is null.\n");
    }
    else
    {

        printf("this node is null.\n");

    }
    printf("\n");
}
void PrintTree(BinaryTreeNode *pRoot)
{
    PrintTreeNode(pRoot);
    //   
    if (pRoot != NULL)
    {
        if (pRoot->m_pLeft != NULL)
            PrintTree(pRoot->m_pLeft);
        if (pRoot->m_pRight != NULL)
            PrintTree(pRoot->m_pRight);
    }
}

/*
preorder 前序遍歷
inorder 中序遍歷

*/

BinaryTreeNode* ConstructCore(int* startPreorder, int* endPreorder, int* startInorder, int* endInorder);
BinaryTreeNode *Construct(int *preorder, int *inorder, int length)//輸入前序序列，中序序列和序列長度
{
    if (preorder == NULL || inorder == NULL || length <= 0)
        return NULL;
    return ConstructCore(preorder, preorder + length - 1, inorder, inorder + length - 1);

}

// startPreorder 前序遍歷的第一個節點  
// endPreorder   前序遍歷的最后后一個節點  
// startInorder  中序遍歷的第一個節點  
// startInorder  中序遍歷的最后一個節點  

BinaryTreeNode* ConstructCore(int* startPreorder, int* endPreorder, int* startInorder, int* endInorder)
{
    // 前序遍歷序列的第一個數字是根結點的值  
    int rootValue = startPreorder[0];
    BinaryTreeNode *root = new BinaryTreeNode();
    root->m_nValue = rootValue;
    root->m_pLeft = root->m_pRight = NULL;
    
    // 只有一個結點
    if (startPreorder == endPreorder)
    {
        if (startInorder == endInorder && *startPreorder == *startInorder)
            return root;
        else
            throw std::exception("Invalid input.");
    }

    //有多個結點
    // 在中序遍歷中找到根結點的值  
    int *rootInorder = startInorder;
    while (rootInorder <= endInorder && *rootInorder != rootValue)
        ++rootInorder;
    if (rootInorder == endInorder && *rootInorder != rootValue)
        throw std::exception("Invalid input");
    //  
    int leftLength = rootInorder - startInorder;    //中序序列的左子樹序列長度
    int *leftPreorderEnd = startPreorder + leftLength;    //左子樹前序序列的最后一個結點
    if (leftLength > 0)
    {
        // 構建左子樹  
        root->m_pLeft = ConstructCore(startPreorder + 1, leftPreorderEnd, startInorder, rootInorder - 1);
    }
    if (leftLength < endPreorder - startPreorder)    //（中序序列）若還有左子樹，則左子樹序列長度應等於當前前序序列的長度
        //若小於，說明已無左子樹，此時建立右子樹
    {
        // 構建右子樹  
        root->m_pRight = ConstructCore(leftPreorderEnd + 1, endPreorder, rootInorder + 1, endInorder);
    }
    //  
    return root;
}

// 測試代碼  
void Test(char *testName, int *preorder, int *inorder, int length)
{
    if (testName != NULL)
        printf("%s Begins:\n", testName);
    printf("The preorder sequence is: ");
    for (int i = 0; i < length; ++i)
        printf("%d ", preorder[i]);
    printf("\n");

    printf("The inorder sequence is:");
    for (int i = 0; i < length; ++i)
        printf("%d ", inorder[i]);
    printf("\n");

    try
    {
        BinaryTreeNode *root = Construct(preorder, inorder, length);
        PrintTree(root);

    }
    catch (std::exception &expection)
    {
        printf("Invalid Input.\n");
    }
}

// 普通二叉樹  
//              1  
//           /     \  
//          2       3    
//         /       / \  
//        4       5   6  
//         \         /  
//          7       8  
void Test1()
{
    const int length = 8;
    int preorder[length] = { 1, 2, 4, 7, 3, 5, 6, 8 };
    int inorder[length] = { 4, 7, 2, 1, 5, 3, 8, 6 };

    Test("Test1", preorder, inorder, length);
}

int main()
{
    Test1();  
    system("pause");
    return 0;
}

/*
輸出結果：
----------------------------------------------------------------
Test1 Begins:
The preorder sequence is: 1 2 4 7 3 5 6 8
The inorder sequence is:4 7 2 1 5 3 8 6
value of this node is : 1
value of its left child is: 2.
value of its right childe is : 3.

value of this node is : 2
value of its left child is: 4.
right child is null.

value of this node is : 4
left child is null.
value of its right childe is : 7.

value of this node is : 7
left child is null.
right child is null.

value of this node is : 3
value of its left child is: 5.
value of its right childe is : 6.

value of this node is : 5
left child is null.
right child is null.

value of this node is : 6
value of its left child is: 8.
right child is null.

value of this node is : 8
left child is null.
right child is null.

請按任意鍵繼續. . .
----------------------------------------------------------------

*/

/*
方式二：容器+遞歸
*/

#include <iostream>
#include <vector>
using namespace std;


// Definition for binary tree
struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 };

/* 先序遍歷第一個位置肯定是根節點node，

中序遍歷的根節點位置在中間p，在p左邊的肯定是node的左子樹的中序數組，p右邊的肯定是node的右子樹的中序數組

另一方面，先序遍歷的第二個位置到p，也是node左子樹的先序子數組，剩下p右邊的就是node的右子樹的先序子數組

把四個數組找出來，分左右遞歸調用即可

*/

class Solution {

public:

    struct TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> in) {

        int in_size = in.size();//獲得序列的長度

        if (in_size == 0)

            return NULL;

        //分別存儲先序序列的左子樹，先序序列的右子樹，中序序列的左子樹，中序序列的右子樹
        vector<int> pre_left, pre_right, in_left, in_right;

        int val = pre[0];//先序遍歷第一個位置肯定是根節點node,取其值
        //新建一個樹結點，並傳入結點值
        TreeNode* node = new TreeNode(val);//root node is the first element in pre
        //p用於存儲中序序列中根結點的位置
        int p = 0;

        for (p; p < in_size; ++p){

            if (in[p] == val) //Find the root position in in 

                break;        //找到即跳出for循環

        }

        for (int i = 0; i < in_size; ++i){

            if (i < p){
                //建立中序序列的左子樹和前序序列的左子樹
                in_left.push_back(in[i]);//Construct the left pre and in 

                pre_left.push_back(pre[i + 1]);//前序第一個為根節點,+1從下一個開始記錄

            }

            else if (i > p){
                //建立中序序列的右子樹和前序序列的左子樹
                in_right.push_back(in[i]);//Construct the right pre and in 

                pre_right.push_back(pre[i]);

            }

        }
        //取出前序和中序遍歷根節點左邊和右邊的子樹
        //遞歸，再對其進行上述所有步驟，即再區分子樹的左、右子子數，直到葉節點
        node->left = reConstructBinaryTree(pre_left, in_left);

        node->right = reConstructBinaryTree(pre_right, in_right);

        return node;

    }

};