剑指Offer对答如流系列 - 重建二叉树

面试题6：重建二叉树

题目描述：

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

class Node{
    int e;
    Node left;
    Node right;
    Node(int x) { e = x; }
}

这道题主要测试你对二叉树性质的了解，非常有代表性，不过在这之前，我们先把二叉树的基本性质捋一遍。

二叉树的基本性质

（1）关于树

树是一种数据结构，它是由n（n>=1）个有限结点组成一个具有层次关系的集合。

树的基本术语有：

• 每个结点有零个或多个子结点
• 没有父节点的结点称为根节点
• 每一个非根结点有且只有一个父节点
• 除了根结点外，每个子结点可以分为多个不相交的子树。
• 若一个结点有子树，那么该结点称为子树根的“双亲”，子树的根称为该结点的“孩子”。有相同双亲的结点互为“兄弟”。
• 一个结点的所有子树上的任何结点都是该结点的后裔。从根结点到某个结点的路径上的所有结点都是该结点的祖先。
• 结点的度：结点拥有的子树的数目
• 叶子结点：度为0的结点
• 分支结点：度不为0的结点
• 树的度：树中结点的最大的度
• 层次：根结点的层次为1，其余结点的层次等于该结点的双亲结点的层次加1
• 树的高度：树中结点的最大层次
• 森林：0个或多个不相交的树组成。对森林加上一个根，森林即成为树；删去根，树即成为森林。

“树”是计算机科学中非常重要的一部分内容，它的变形和应用非常之多。比如说，在做通讯录的时候，Android 工程师往往喜欢用字典树来存取数据，对于Java后端，有的时候我们处理的数据的时候也需要进行区间的查询，比如说去年你的博客在什么时间段关注你的人增长最快啊，一天中自己的博文阅读量最高的时间段啊，可以采用线段树来实现。在JDK1.8的HashMap的结构中，当元素超过8个的时候，会转为红黑树等等。

不过对于Java开发而言，二叉树是基础也是接触较多的一种结构。

（2）关于二叉树

二叉树是每个结点最多有两个子树的树结构。它有五种基本形态：

1)空树;

2)只有根的树,即单结点;

3)有根且有一个左子树;

4)有根且有一个右子树;

5)有根且有一个左子树,有一个右子树。

二叉树的性质有：

• 二叉树第i层上的结点数目最多为2i-1(i>=1)
• 深度为k的二叉树至多有2k-1个结点（k>=1）
• 包含n个结点的二叉树的高度至少为(log2n)+1

• 在任意一棵二叉树中，若叶子结点的个数为n0，度为2的结点数为n2，则n0=n2+1

  第四条的证明： 因为二叉树中所有结点的度数均不大于2，设n0表示度为0的结点个数，n1表示度为1的结点个数，n2表示度为2的结点个数。
  三类结点加起来为总结点个数，于是便可得到：n=n0+n1+n2 (公式1)
  由度之间的关系可得第二个等式：n=n0*0+n1*1+n2*2+1 即n=n1+2n2+1 (公式2)
  将（公式1）（公式2）组合在一起可得到n0=n2+1

了解这第四条性质就差不多了。如果想进一步学习二叉树的性质，不妨去找本《离散数学》？

对二叉树遍历的理解

以这棵树为例：

前序遍历：根结点 —> 左子树 —> 右子树（先遍历根节点，然后左右）

    //前序遍历以node为根
    public void preOrder(Node node) {
        //终止条件
        if(node == null) {
            return;
        }
        System.out.println(node.e);
        preOrder(node.left);
        preOrder(node.right);
    }

这棵树的前序遍历为：FCADBEHGM

中序遍历：左子树—> 根结点 —> 右子树（在中间遍历根节点）

    //中序以node为根的
    public void inOrder(Node node) {
        //终止条件
        if(node == null) {
            return;
        }
        inOrder(node.left);
        System.out.println(node.e);
        inOrder(node.right);
    }

这棵树的中序遍历为：ACBDFHEMG

后序遍历：左子树 —> 右子树 —> 根结点（最后遍历根节点）

        //中序以node为根
        public void postOrder(Node node) {
            //终止条件
            if(node == null) {
                return;
            }
    
            postOrder(node.left);
            postOrder(node.right);
            System.out.println(node.e);
        }

这棵树的后序遍历为：ABDCHMGEF

层序遍历：

    //层序遍历
    public void levelOrder() {
        Queue q = new LinkedList<>();
        q.add(root);
        while( !q.isEmpty() ) {
            Node cur = q.remove();
            System.out.println(cur.e);
            
            if(cur.left != null)
                q.add(cur.left);
            if(cur.right != null)
                q.add(cur.right);  //后出
        }
    }

这棵树层序遍历为：FCEADHGBM

所谓的前序、中序、后序，就是对根节点而言的，左右的遍历顺序不变，前序就是根节点最先遍历，然后左右；中序就是把根节点放在中间遍历；后序则是把根节点放在最后遍历。

中序遍历能够帮助我们很好地确定根节点的位置，这个就有点可怕了，实际面试的时候，不单单会有给出前序遍历和中序遍历的结果让你重建二叉树，还有给出后序遍历和中序遍历结果或者 层序遍历和中序遍历的结果重建二叉树、

其他的遍历组合均不能还原出二叉树的形状，因为无法确认其左右孩子。例如，前序为AB，后序为AB，则无法确认出，B节点是A节点的左孩子还是右孩子，因此无法还原。

题解

思路：通过前序遍历获得根节点的位置，利用根节点将中序序列分为左子树和右子树，然后不断的递归划分即可。

代码中有解释。

  private Node buildTree(int[] pre, int preBegin, int preEnd, int[] mid, int midBegin, int midEnd) {
        // 前序遍历确第一个元素为根节点
        Node root = new Node(pre[preBegin]);
        // 用于标记中序遍历结果中根节点的位置
        int midRootLocation= 0;
        for (int i = midBegin; i <= midEnd; i++) {
            if (mid[i] == pre[preBegin]) {  
                midRootLocation= i;
                break;
            }
        }

        if ( midRootLocation - midBegin >= 1 ) {
            // 递归得到左子树
            
            // 中序遍历：左子树—> 根结点 —> 右子树（在中间遍历根节点）
            // midRootLocation标记了中序遍历结果中根节点的位置，这个位置两端对应根节点左子树和右子树
            // midRootLocation- midBegin 表示该根节点左边的节点的数量
            
            // 前序遍历：根结点 —> 左子树 —> 右子树（先遍历根节点，然后左右）
            // preBegin 标记了前序遍历结果中根节点的位置
            // preBegin + 1 表示该根节点左子树起始位置
            // preBegin + (midRootLocation- midBegin) 表示给根节点左子树结束的位置
            Node left = buildTree(pre, preBegin + 1, preBegin + (midRootLocation- midBegin),
                    mid, midBegin, midRootLocation - 1);
            root.left = left;
        }


        if ( midEnd - midRootLocation >= 1 ) {
            // 递归得到右子树
            // 原理和上面相同
            Node right = buildTree(pre, preEnd - (midEnd - midRootLocation) + 1, preEnd,
                    mid, midRootLocation+ 1, midEnd);
            root.right = right;
        }

        return root;
    }

举一反三

（1）给出后序遍历和中序遍历的结果重建二叉树

思路：通过后序获取根节点的位置，然后在中序中划分左子树和右子树，然后递归划分即可。

形式与上面 给出 前序遍历和中序遍历的结果重建二叉树相同

    private Node buildTree(int[] mid, int midBegin, int midEnd, int[] end, int endBegin, int endEnd) {
        
        Node root = new Node(end[endEnd]);
        int midRootLocation = 0;
        for (int i = midEnd; i >= midBegin; i--) {
            if (mid[i] == end[endEnd]) {
                midRootLocation = i;
                break;
            }
        }
        
        //还原左子树
        if (midRootLocation - midBegin >= 1 ) {
            Node left = buildTree(mid, midBegin, midRootLocation - 1, end, endBegin, endBegin + (midRootLocation - midBegin) - 1);
            root.left = left;
        }

        //还原右子树
        if (midEnd - midRootLocation >=  1 ) {
            Node right = buildTree(mid, midRootLocation + 1, midEnd, end, endEnd - (midEnd - midRootLocation), endEnd - 1);
            root.right = right;
        }
        
        return root;
    }

（2）给出层序遍历和中序遍历结果重建二叉树

思路：

（1）根据层序遍历获取根节点的位置

（2）根据（1）将中序划分为左子树和右子树

（3）根据（2）划分出的左子树和右子树分别在层序遍历中获取其对应的层序顺序

（4）然后递归调用划分。

  private Node buildTree(int[] mid, int[] level, int midBegin, int midEnd) {

        // 层序遍历的第一个结果是 根节点
        Node root = new Node(level[0]);
        // 用于标记中序遍历的根节点
        int midLocation = -1;
        for (int i = midBegin; i <= midEnd; i++) {
            if (mid[i] == level[0]) {
                midLocation = i;
                break;
            }
        }

        if (level.length >= 2) {
            if (isLeft(mid, level[0], level[1])) {
                Node left = buildTree(mid, getLevelArray(mid, midBegin, midLocation - 1, level), midBegin, midLocation - 1);
                root.left = left;
                if (level.length >= 3 && !isLeft(mid, level[0], level[2])) {
                    Node right = buildTree(mid, getLevelArray(mid, midLocation + 1, midEnd, level), midLocation + 1, midEnd);
                    root.right = right;
                }
            } else {
                Node right = buildTree(mid, getLevelArray(mid, midLocation + 1, midEnd, level), midLocation + 1, midEnd);
                root.right = right;
            }
        }
        return root;
    }


    // 功能 ： 判断元素是根节点的左子树节点还是右子树节点
    // 参数 ： target为根节点 isLeft在中序遍历结果中判断children是根节点的左子树还是右子树
    // 返回值 : 如果为左子树节点则为true 否则为false
    private boolean isLeft(int[] array, int target, int children) {
        boolean findC = false;

        for (int temp : array) {
            if (temp == children) {
                findC = true;
            } else if (temp == target) {
                return findC;
            }
        }
        return false;
    }


    // 功能： 将中序序列中midBegin与midEnd的元素依次从level中提取出来，保持level中的元素顺序不变
    private int[] getLevelArray(int[] mid, int midBegin, int midEnd, int[] level) {
        int[] result = new int[midEnd - midBegin + 1];
        int curLocation = 0;
        for (int i = 0; i < level.length; i++) {
            if (contains(mid, level[i], midBegin, midEnd)) {
                result[curLocation++] = level[i];
            }
        }
        return result;
    }

    // 如果array的begin和end位置之间（包括begin和end）含有target,则返回true。
    private boolean contains(int[] array, int target, int begin, int end) {
        for (int i = begin; i <= end; i++) {
            if (array[i] == target) {
                return true;
            }
        }
        return false;
    }