算法题399：从前序与中序遍历序列构造二叉树

文章来源于公众号数据结构和算法，作者山大王wld

问题描述

今天我们就不做关于双指针的了，我们爬到树上玩会儿，做一道关于二叉树的题。今天的题就一句话，根据一棵树的前序遍历与中序遍历构造二叉树。

注意:

你可以假设树中没有重复的元素。

例如，给出

前序遍历 preorder = [3,9,20,15,7]

中序遍历 inorder = [9,3,15,20,7]

返回如下的二叉树：

3

/ \

9 20
/  \
15 7

问题分析

做这题之前我们先来看一下树的几种遍历顺序。

先序遍历：根节点→左子树→右子树。

中序遍历：左子树→根节点→右子树。

后续遍历：左子树→右子树→根节点。

其实也很好记，他是根据根节点遍历的顺序来定义的，比如先遍历根节点就是先序遍历，中间遍历根节点就是中序遍历，最后遍历根节点就是后续遍历，至于左子树和右子树哪个先遍历，记住一点，这3种遍历顺序右节点永远都不可能比左节点先遍历。

我们就以上面的示例数据来看下，前序遍历是[3,9,20,15,7]，前序遍历先访问的是根节点，所以3就是根节点。中序遍历是[9,3,15,20,7]，由于中序遍历是在左子树都遍历完的时候才遍历根节点，所有在中序遍历中3前面的都是3的左子树节点，3后面的都是3的右子树节点。也就是下面这样

image

然后我们再使用同样的方式对左右子树继续划分，一直这样下去，直到不能再分为止，我们来看下代码

 1public TreeNode buildTree(int[] preorder, int[] inorder) {
 2    //把前序遍历的值和中序遍历的值放到list中
 3    List<Integer> preorderList = new ArrayList<>();
 4    List<Integer> inorderList = new ArrayList<>();
 5    for (int i = 0; i < preorder.length; i++) {
 6        preorderList.add(preorder[i]);
 7        inorderList.add(inorder[i]);
 8    }
 9    return helper(preorderList, inorderList);
10}
11
12private TreeNode helper(List<Integer> preorderList, List<Integer> inorderList) {
13    if (inorderList.size() == 0)
14        return null;
15    //前序遍历的第一个值就是根节点
16    int rootVal = preorderList.remove(0);
17    //创建跟结点
18    TreeNode root = new TreeNode(rootVal);
19    //查看根节点在中序遍历中的位置，然后再把中序遍历的数组劈两半，前面部分是
20    //根节点左子树的所有值，后面部分是根节点右子树的所有值
21    int mid = inorderList.indexOf(rootVal);
22    //[0，mid)是左子树的所有值，inorderList.subList(0, mid)表示截取inorderList
23    //的值，截取的范围是[0，mid)，包含0不包含mid。
24    root.left = helper(preorderList, inorderList.subList(0, mid));
25    //[mid+1，inorderList.size())是右子树的所有值，
26    // inorderList.subList(mid + 1, inorderList.size())表示截取inorderList
27    //的值，截取的范围是[mid+1，inorderList.size())，包含mid+1不包含inorderList.size()。
28    root.right = helper(preorderList, inorderList.subList(mid + 1, inorderList.size()));
29    return root;
30}

上面代码中是先把数组转化为list集合，然后在list集合中进行截取，这样效率明显不是很高，实际上我们还可以不使用list，不对数组进行截取。

使用指针解决

我们只需要使用3个指针即可。一个是preStart，他表示的是前序遍历开始的位置，一个是inStart，他表示的是中序遍历开始的位置。一个是inEnd，他表示的是中序遍历结束的位置，我们主要是对中序遍历的数组进行拆解，下面就以下面的这棵树来画个图分析下

image

他的前序遍历是：[3,9,8,5,2,20,15,7]

他的中序遍历是：[5,8,9,2,3,15,20,7]

image

这里只要找到了前序遍历的结点在中序遍历的位置，我们就可以把中序遍历数组分解为两部分了。如果index是前序遍历的某个值在中序遍历数组中的索引，以index为根节点划分的话，那么中序遍历中

[0，index-1]就是根节点左子树的所有节点，

[index+1，inorder.length-1]就是根节点右子树的所有节点。

中序遍历好划分，那么前序遍历呢，如果是左子树：

preStart=index+1；

如果是右子树就稍微麻烦点，

preStart=preStart+(index-instart+1)；

preStart是当前节点比如m先序遍历开始的位置，index-instart+1就是当前节点m左子树的数量加上当前节点的数量，所以preStart+(index-instart+1)就是当前节点m右子树前序遍历开始的位置，我们来看下完整代码

 1public TreeNode buildTree(int[] preorder, int[] inorder) {
 2    return helper(0, 0, inorder.length - 1, preorder, inorder);
 3}
 4
 5public TreeNode helper(int preStart, int inStart, int inEnd, int[] preorder, int[] inorder) {
 6    if (preStart > preorder.length - 1 || inStart > inEnd) {
 7        return null;
 8    }
 9    //创建结点
10    TreeNode root = new TreeNode(preorder[preStart]);
11    int index = 0;
12    //找到当前节点root在中序遍历中的位置，然后再把数组分两半
13    for (int i = inStart; i <= inEnd; i++) {
14        if (inorder[i] == root.val) {
15            index = i;
16            break;
17        }
18    }
19    root.left = helper(preStart + 1, inStart, index - 1, preorder, inorder);
20    root.right = helper(preStart + index - inStart + 1, index + 1, inEnd, preorder, inorder);
21    return root;
22}

使用栈解决

如果使用栈来解决首先要搞懂一个知识点，就是前序遍历挨着的两个值比如m和n，他们会有下面两种情况之一的关系。

1，n是m左子树节点的值。

2，n是m右子树节点的值或者是m某个祖先节点的右节点的值。

对于第一个知识点我们很容易理解，如果m的左子树不为空，那么n就是m左子树节点的值。
对于第二个问题，如果一个结点没有左子树只有右子树，那么n就是m右子树节点的值，如果一个结点既没有左子树也没有右子树，那么n就是m某个祖先节点的右节点，我们只要找到这个祖先节点就好办了。

搞懂了这点，代码就很容易写了，下面看下完整代码

 1public TreeNode buildTree(int[] preorder, int[] inorder) {
 2    if (preorder.length == 0)
 3        return null;
 4    Stack<TreeNode> s = new Stack<>();
 5    //前序的第一个其实就是根节点
 6    TreeNode root = new TreeNode(preorder[0]);
 7    TreeNode cur = root;
 8    for (int i = 1, j = 0; i < preorder.length; i++) {
 9        //第一种情况
10        if (cur.val != inorder[j]) {
11            cur.left = new TreeNode(preorder[i]);
12            s.push(cur);
13            cur = cur.left;
14        } else {
15            //第二种情况
16            j++;
17            //找到合适的cur，然后确定他的右节点
18            while (!s.empty() && s.peek().val == inorder[j]) {
19                cur = s.pop();
20                j++;
21            }
22            //给cur添加右节点
23            cur = cur.right = new TreeNode(preorder[i]);
24        }
25    }
26    return root;
27}

总结

这题如果直接在纸上推算出来还是很简单的，如果写成代码就稍微有一点难度。当然第一种写法还是非常简单，他是每次遍历都会把数组截取，但截取效率不高，所以第二种方式就使用指针的方式，每次遍历的时候通过指针来固定左子树和右子树在数组中的范围。第3种方式是巧妙的运用了前序遍历的特点，然后使用栈的方式解决，这种方式也是非常经典的，一般不太容易想到。