【剑指offer】面试题六：重建二叉树

题目：输入某二叉树的前序遍历和中序遍历的结点，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含有重复的数字。假设输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建出如下图所示的二叉树并输出它的头结点。

二叉树结点的定义如下：

typedef struct Node
{
    int m_nValue;
    struct Node* n_pLeft;
    struct Node* m_pRIght 
}BinaryTreeNode, *PBinaryTreeNode;

重建的结果如下图所示：

分析：

在二叉树的前序遍历序列中，第一个数字总是树的根结点的值。但在中序遍历序列中。根结点的值在序列的中间，左子树的所有结点的值位于根结点的值的左边，而右子树的所有结点的值位于根结点的值的右边。因此我们可以得出如下一般的步骤：
1、扫描前序遍历的第一个值（假设为value），找到value在其中序遍历中的位置；
2、通过步骤 1，可知该二叉树的根结点和根结点的左子树与右子树；
3、让左子树与右子树分别重复步骤 1；
4、直到左右子树全部遍历完，便可得到该二叉树。

我们可以分析题目中给出的示例：

1、全部结点的前序遍历序列和中序遍历序列：
　前序序列：{1,2,4,7,3,5,6,8}

　中序序列：{4,7,2,1,5,3,8,6}

　前序遍历的第一个数字 1 就是根结点的值。然后扫描中序遍历，就能确定根结点的值的位置。根据中序遍历的特点，在根结点的值 1  前面的三个数字 4,、7、2 都是左子树结点的值，位于 1 后面的数字 5,3,8,6 都是右子树结点的值。

2、根结点左子树的前序遍历序列和中序遍历序列：

　前序序列：{2,4,7}

　中序序列：{4,7,2}

　由于前序遍历的第一个数字就是左子树的根结点的值，即为 2。从而遍历左子树的中序序列找到 2 的位置，而在中序序列中位于 2 左边的就是根结点左子树的左子树，位于 2 右边的就是根结点左子树的右子树。由中序序列{4,7,2}可知，该子树只有左子树，没有右子树。

3、根结点右子树的前序遍历序列和中序遍历序列：

　前序序列：{3,5,6,8}

　中序序列：{5,3,8,6}

　步骤与2类似，不在赘述。

经过分析可知，既然我们已经分别找到了左、右子树的前序遍历序列和中序遍历序列，我们可以用同样的方法分别取构建左右子树。也就是说，接下来的事情可以用递归的方法去完成。

在分析清楚之后，我们可以用递归的方式去实现该题，代码如下：

// construct.cpp
#include "stdio.h"
#include "stdlib.h"
#include <stdexcept>

typedef struct Node
{
    int m_nValue;
    struct Node *m_pLeft;
    struct Node *m_pRight;
}BTreeNode, *pBTreeNode;

BTreeNode *constructCore(int *preOrderStart, int *preOrderEnd,
    int *inOrderStart, int *inOrderEnd);

BTreeNode *construct(int *preOrder, int *inOrder, int len)
{
    if(preOrder == NULL || inOrder == NULL || len <= 0)
        return NULL;

    return constructCore(preOrder, preOrder + len - 1,
            inOrder, inOrder + len - 1);
}

// 建树 (前序开始、前序结束、中序开始、中序结束)
BTreeNode *constructCore(int *preOrderStart, int *preOrderEnd,
    int *inOrderStart, int *inOrderEnd)
{
    int rootVal = preOrderStart[0];

    BTreeNode *root = (BTreeNode*)malloc(sizeof(BTreeNode));
    root->m_nValue = rootVal;
    root->m_pLeft = root->m_pRight = NULL;

    // 递归结束的条件
    if(preOrderStart == preOrderEnd)
    {
        if(inOrderStart == inOrderEnd && *preOrderStart == rootVal)
            return root;
        else
            throw std::out_of_range("Invalid Input");
    }

    // 遍历中序序列
    int *rootInOrder = inOrderStart;
    while(rootInOrder < inOrderEnd && *rootInOrder != rootVal)
        ++rootInOrder;

    if(rootInOrder == inOrderEnd && *rootInOrder != rootVal)
        throw std::out_of_range("Invalid Input");

    int leftLen = rootInOrder - inOrderStart;
    int *leftPreOrderEnd = preOrderStart + leftLen;

    if(leftLen > 0) // 存在左子树
    {
        // 构建左子树
        root->m_pLeft = constructCore(preOrderStart + 1, leftPreOrderEnd,
            inOrderStart, rootInOrder - 1);
    }
    if(leftLen < preOrderEnd - preOrderStart) // 存在右子树
    {
        // 构建右子树
        root->m_pRight = constructCore(leftPreOrderEnd + 1, preOrderEnd,
            rootInOrder + 1, inOrderEnd);
    }
    return root;
}

void preOrderTr(BTreeNode *root) // 先序遍历
{
    if(root != NULL)
    {
        printf("%2d", root->m_nValue);
        preOrderTr(root->m_pLeft);
        preOrderTr(root->m_pRight);
    }
}

void inOrderTr(BTreeNode *root) // 中序遍历
{
    if(root != NULL)
    {
        inOrderTr(root->m_pLeft);
        printf("%2d", root->m_nValue);
        inOrderTr(root->m_pRight);
    }
}

void postOrderTr(BTreeNode *root) // 后序遍历
{
    if(root != NULL)
    {
        postOrderTr(root->m_pLeft);
        postOrderTr(root->m_pRight);
        printf("%2d", root->m_nValue);
    }
}

int main(int argc, char *argv[])
{
    BTreeNode *root = NULL;

    int preOrder[] = {1, 2, 4, 7, 3, 5, 6, 8};
    int inOrder[] = {4, 7, 2, 1, 5, 3, 8, 6}; 

    root = construct(preOrder, inOrder, 8);
    printf("root value: %d
", root->m_nValue);

    printf("先序遍历序列
");
    preOrderTr(root);

    printf("
中序遍历序列
");
    inOrderTr(root);

    printf("
后序遍历序列
");    
    postOrderTr(root);    
    printf("
");

    return 0;
}

编译与执行:

g++ -o construct construct.cpp
./construct

本文完。