这几天开学，学校还在上课，最近也是在找工作，很多天都没有更新文章，现在补一篇二叉树的文章。

最近校招公司的笔试陆续开始，感觉算法系列的文章还更新不完就结束了，我尽量快的更新吧，自己复习的同时希望能帮助读者复习~

到了树这一节，二叉树较为典型。和链表相比，树的指针操作更复杂，而二叉树作为一种常用的数据结构，是要重点掌握的。二叉树的遍历是比较基础的操作，要熟悉前序遍历，中序遍历和后序遍历几种遍历方式，二叉树的很多题目都会涉及到二叉树的遍历，下面是二叉树系列第一节的题目总结。

• 二叉搜索树的后序遍历序列
• 重建二叉树
• 二叉树的子结构

1.二叉搜索树的后序遍历序列

问题描述：输入一个整数数组，判断它是不是一个二叉搜索树的后序遍历序列，如果是则返回true，否则返回false。假设输入数组的任意2个数字互不相等。

算法思想

先回顾二叉搜索树的概念。

二叉搜索树： 二叉搜索树能保证左子树一定小于根节点，右子树一定大于根节点。在后序遍历的得到的数组中，最后一个数是根节点，数组可以分为2部分，第一部分是根节点的左子树，它们都比根节点小，另一部分是根节点的右子树，它们都大于根节点。

看下面这个例子，输入数组{5,7,6,9,11,10,8}，对应的二叉搜索树如下。

后序遍历序列5,7,6,9,11,10,8对应的二叉搜索树

我们这么来分析，后序遍历结果的最后一个数字8肯定是二叉搜索树的根节点。在这个数组中，前3个数5,7,6都小于8，它们是值为8的节点的左子树，后3个数字9,11,10都大于8，是值为8的节点的右子树。

接下来用同样的方法来确定数组中每一部分对应的子树的结构，这是一个递归的过程。对于数组中的序列5,7,6构成的子树，根节点是6，前一个结点5小于6，是值为6的节点的左子树，后一个结点7是它的右子树。同样，在序列9,11,10中，最后一个数是10，那么构成的子树的根节点也是10，9比10小，9就是值为10的节点的左子树，11是它的右子树。

错误的结构：
再考虑一个特殊的序列{7,4,6,5}，最后一个数是根节点，所以树的根节点是5，由于第一个数是7，大于5，所以这个节点没有左子树，那么7,4,6都是它的右子树的节点，但是我们发现4小于5，这违背了二叉搜索树的定义，因此不存在 一个二叉树，它的后序遍历的结果是7,4,6,5。

代码

注意代码中左子树的判断方法方法，我们不能确定这棵二叉排序树是否是平衡的，不知道根节点的左子结点和右子结点具体有多少个，所以只能顺序比较，将小于根节点的默认为是它的左子树，从第一个大于根节点的值开始，认为其属于右子树（结合代码一起分析）。

注：递归的时候有一个判断,i > 0和i < length – 1，这两个if都是判断左右子树是否满足要求的，如果递归到i = 0或者i = length-1的时候,说明已经判断到叶子节点了，不会再有子树了，这时不会再进行下一次递归，而是直接返回ture.

//判断输入的序列是不是一个二叉排序树的后序遍历的序列，如果是，返回true,否则返回false
bool VerifySquenceOfBST(int sequence[], int length)
{
    if (sequence == NULL || length <= 0)
    {
        fprintf(stderr, "Invalid parameter.\n");
        return false;
    }
    int root = sequence[length - 1];//确定当前子树的根节点
    //确定左子树的结点
    int i = 0;
    for(;i < length - 1; i++)
    {
        if (sequence[i] > root)
            break;
    }
    //确定右子树的结点
    int j = i;
    for (; j < length - 1; j++)
    {
        if (sequence[j] < root)
            return false;
    }
     //递归左子树，判断是否满足左子树节点都小于根节点
    bool left = true;
    if (i > 0)
        left = VerifySquenceOfBST(sequence, i);
    //递归右子树，判断右子树是否满足所有节点都小于根节点
    //判断右子树时，应该从index=i开始，因为0~i-1是属于左子树，i~length-2属于右子树
    bool right = true;
    if (i < length - 1)
        right = VerifySquenceOfBST(sequence+i, length-i-1);
    return (left && right);
}

总结

我们都知道一颗二叉树需要中序序列和后序序列，或者前序序列和中序序列才能唯一确定，而这里只用后序序列就能确定二叉树，是为什么呢？因为这里说的是二叉搜索树，对左右子树的结点的大小是有要求的，可以将这个左子树小于根结点，右子树大于根结点作为附加要求。

同类题目：输入一个整数序列，判断该序列是否是某二叉树前序遍历的结果。和上面的思想类似，只是在前序遍历得
的序列中，第一个数是根节点。

2.重建二叉树

问题描述：输入二叉树的前序遍历和中序遍历的结果，重建二叉树。假设输入的前序遍历和中序遍历的结果中都不含有重复的数字，重建二叉树，并输出它的头结点。例如，根据前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}确定二叉树如下。

重构的二叉树

算法思想

这就是上面提到的前序遍历和中序遍历序列唯一确定一棵二叉树。

在二叉树的前序遍历序列中，第一个数是根节点的值，我们可以在中序遍历序列中找到这个数字，然后确定根节点的位置。在中序遍历序列中，根节点左边的值是左子树的节点，根节点右边的值是右子树的节点。

以上面的例子来说，根节点是1，在中序遍历序列中，1前面有3个数字，说明左子树有3个结点。而在前序遍历序列中，根节点后面的3个数就是左子节点，再后面的数就是右子树的节点。这样我们就在前序遍历和中序遍历两个序列中分别找到了左右子树对应的子序列。接下来用递归分别对左子序列和右子序列构建二叉树。

根据前序遍历和中序遍历序列确定左右子树

代码

二叉树的定义。

//二叉树定义
typedef struct BinaryTreeNode
{
    int value;
    BinaryTreeNode* m_pLeft;
    BinaryTreeNode* m_pRight;
};

构造二叉树

//构造二叉树的核心代码
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)
    {
        fprintf(stderr, "Invalid parameter.\n");
        return NULL;
   }

    return ConstructCore(preorder, preorder + length - 1,
        inorder, inorder + length - 1);
}

//重构二叉树的的核心代码，递归实现
BinaryTreeNode* ConstructCore(int *startPreorder, int *endPreorder, int *startInorder, int *endInorder)
{
    //前序遍历的第一个是根节点的值
    int rootValue = startPreorder[0];
    BinaryTreeNode *root = (BinaryTreeNode *)malloc(sizeof(BinaryTreeNode));
    root->value = rootValue;
    root->m_pLeft = root->m_pRight = NULL;

    //结束条件,遍历到最后一个节点，此时前序遍历和中序遍历序列中剩下的值是一样的
    if (startPreorder == endPreorder)
    {
        //第二个判断条件是避免中序遍历序列和前序遍历序列不匹配的情况
        if (startInorder == endInorder && *startInorder == *startPreorder)
            return root;
        else
        {
            fprintf(stderr, "Invalid input.\n");
            exit(1);
        }
    }
    //在中序遍历中找到根节点的值
    int *rootInorder = startInorder;
    while (rootInorder <= endInorder && *rootInorder != rootValue)
        rootInorder++;
    if (rootInorder == endInorder && *rootInorder != rootValue)
    {
        fprintf(stderr, "Invalid input.\n");
        exit(1);
    }

    //计算右子树有几个节点，此时rootInorder是根节点
    //注意这里，前序遍历序列的第一个和中序遍历序列的rootInorder是根节点，递归的时候要去掉根节点
    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;
}

总结

在函数ConstructCore中，我们先在前序遍历的序列中确定根节点，然后在中序遍历的序列中找到根节点，这样就能确定左右子树的数目，在前序遍历和中序遍历的序列中划分了左右子树之后，就可以递归的调用ConstructCore构建每一个子树。注意递归的终止条件是，当子树序列中只有一个数字时，说明这一分支的左/右子树已经到叶子节点了，此时直接返回节点即可，它的左右子树都是NULL。

另外，在ConstructCore中，我们需要对错误情况进行判断和处理，比如说
前序遍历序列和中序遍历序列不匹配的情况，在两次输出Invalid input的地方都进行了判断。另外，在递归的时候，需要注意将当前的中序遍历和前序遍历序列中的根节点排除在外。

3.二叉树的子结构

问题描述：输入两棵二叉树a和b，判断b是不是a的子结构。如图：A中有一部分子树和B是一样的，因此B是A的子结构。

两棵二叉树A和B，右边的树B是左边的树A的子结构

算法思想

回到题目，在一棵树中判断它的子结构，可以分为两步，第一步，在A中找到和B的根结点一样的结点R；第二步，判断A中以R为根结点的子树是否存在和B一样的结构。

以上面的例子为例，我们现在A中找结点值为8的节点，先找到根节点，接着遍历它的子结点，左子结点为8，和B中的结构不同，需要第二次找值为8的父结点，这次找到的是根结点的左子结点8，比较之后发现它的左右子树和B的根结点的左右子树相同，问题得到解决。

从上面的分析我们得到，这其实就是遍历的过程，遍历A，找到B的根结点在A中的位置。然后在遍历A中的结点，判断结构是否相同。而这里的遍历方式是前序遍历。

代码

二叉树结构定义。

typedef struct BinaryTreeNode
{
    int value;
    BinaryTreeNode* m_pLeft;
    BinaryTreeNode* m_pRight;
};

//判断树1中是否存在树2
bool DoesTree1HaveTree2(BinaryTreeNode *pRoot1, BinaryTreeNode *pRoot2)；

bool HasSubtree(BinaryTreeNode *pRoot1, BinaryTreeNode *pRoot2)
{
    int result = false;
    if (pRoot1 != NULL && pRoot2 != NULL)
    {
        //在A中找到B的根结点的位置，下一步需要判断以这个结点为根节点的子树是否和B的结构相同
        if (pRoot1->value == pRoot2->value)
            result = DoesTree1HaveTree2(pRoot1, pRoot2);
        //如果出现结构不匹配，需重新找到B的根结点对应的A中的结点
        if (!result)
            result = HasSubtree(pRoot1->m_pLeft, pRoot2);
        if (!result)
            result = HasSubtree(pRoot1->m_pRight, pRoot2);
        return result;
    }
}

DoesTree1HaveTree2是判断A中以R为根结点的子树是否和B有相同的结构。首先判断A中的R结点和B的根结点的值是否相同，我们有递归的方法判断，如果不同肯定不是相同的结构，如果相同的话，再递归的判断左子树和右子树是否相等。递归的结束条件是到达B树的叶子结点。

bool DoesTree1HaveTree2(BinaryTreeNode *pRoot1, BinaryTreeNode *pRoot2)
{
    if (pRoot2 == NULL)
        return true;
    if (pRoot1 == NULL)
        return false;
    if (pRoot1->value != pRoot2->value)
        return false;
    //pRoot1->value == pRoot2->value,接下来判断左子树和右子树是否相等
    return DoesTree1HaveTree2(pRoot1->m_pLeft, pRoot2->m_pLeft)
        && DoesTree1HaveTree2(pRoot1->m_pRight, pRoot2->m_pRight);
}

总结

这一节二叉树就到这里了，需要注意理解二叉树的几种遍历方式，然后在题目中灵活运用，二叉树的遍历一般是用递归来解决，递归时要注意结束条件的设置。