面试题07 输入某二叉树的前序遍历和中序遍历的结果,请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

package SwordOffer;

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

/**
* @Description: 输入某二叉树的前序遍历和中序遍历的结果,请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

 

例如,给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树:

3
/ \
9  20
/  \
15   7
 

限制:

0 <= 节点个数 <= 5000

来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
* @Param:
* @return:
* @Author: lvhong
* @Date:
* @E-mail lvhong282@163.com
*/
public class lab7midium {
    public static void main(String[] args){
        int[] in1 = {3,9,20,15,7};
        int [] in2 = {9,3,15,20,7};
        buildTree(in1,in2);
    }
      public static  class TreeNode {
          int val;
          TreeNode left;
          TreeNode right;
          TreeNode(int x) { val = x; }
     }

     //递归  时间复杂度 O(n)   空间复杂度O(n)
//    二叉树的前序遍历顺序是:根节点、左子树、右子树,每个子树的遍历顺序同样满足前序遍历顺序。
//    二叉树的中序遍历顺序是:左子树、根节点、右子树,每个子树的遍历顺序同样满足中序遍历顺序。
//    前序遍历的第一个节点是根节点,只要找到根节点在中序遍历中的位置,在根节点之前被访问的节点都位于左子树,在根节点之后被访问的节点都位于右子树,由此可知左子树和右子树分别有多少个节点。
//    由于树中的节点数量与遍历方式无关,通过中序遍历得知左子树和右子树的节点数量之后,可以根据节点数量得到前序遍历中的左子树和右子树的分界,因此可以进一步得到左子树和右子树各自的前序遍历和中序遍历,可以通过递归的方式,重建左子树和右子树,然后重建整个二叉树。
//    使用一个 Map 存储中序遍历的每个元素及其对应的下标,目的是为了快速获得一个元素在中序遍历中的位置。调用递归方法,对于前序遍历和中序遍历,下标范围都是从 0 到 n-1,其中 n 是二叉树节点个数。
//    递归方法的基准情形有两个:判断前序遍历的下标范围的开始和结束,若开始大于结束,则当前的二叉树中没有节点,返回空值 null。若开始等于结束,则当前的二叉树中恰好有一个节点,根据节点值创建该节点作为根节点并返回。
//    若开始小于结束,则当前的二叉树中有多个节点。在中序遍历中得到根节点的位置,从而得到左子树和右子树各自的下标范围和节点数量,知道节点数量后,在前序遍历中即可得到左子树和右子树各自的下标范围,然后递归重建左子树和右子树,并将左右子树的根节点分别作为当前根节点的左右子节点。
//    作者:LeetCode-Solution
//    链接:https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof/solution/mian-shi-ti-07-zhong-jian-er-cha-shu-by-leetcode-s/
//    来源:力扣(LeetCode)
//    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。


//        public static  TreeNode buildTree(int[] preorder, int[] inorder) {
//            if(preorder==null||preorder.length==0){
//                return null;
//            }
//            TreeNode out = new TreeNode(0);
//            Map<Integer,Integer> temp =new HashMap<Integer,Integer>();
//            int length = preorder.length;
//            for(int i=0;i<length;i++){
//                temp.put(inorder[i],i);
//            }
//            out = buildTree(preorder,0,length-1,inorder,0,length-1,temp);
//            return out;
//        }
//
//
//        private static TreeNode buildTree(int[] preorder, int preBegin, int preEnd, int[] inorder, int inBegin, int inEnd, Map<Integer,Integer> temp){
//            TreeNode root = new TreeNode(preorder[preBegin]);
//            if(preBegin>preEnd){
//                return null;
//            }
//            if(preBegin==preEnd){
//                return root;
//            }
//            int rootPos = temp.get(preorder[preBegin]);
//            int leftLength = rootPos-inBegin;
//            int rightLength =inEnd-rootPos;
//            TreeNode left = buildTree(preorder,preBegin+1,preBegin+leftLength,inorder,inBegin,rootPos-1,temp);
//            TreeNode right = buildTree(preorder,preBegin+leftLength+1,preEnd,inorder,rootPos+1,inEnd,temp);
//            root.left=left;
//            root.right=right;
//            return root;
//        }


//                      3
//                     / \
//                    9  20
//                   /  /  \
//                 8   15   7
//                / \
//               5  10
//              /
//             4

//    其前序遍历和中序遍历如下。
//    preorder = [3,9,8,5,4,10,20,15,7]
//    inorder = [4,5,8,10,9,3,15,20,7]
//    前序遍历的第一个元素 3 是根节点,第二个元素 9 可能位于左子树或者右子树,需要通过中序遍历判断。
//    中序遍历的第一个元素是 4 ,不是根节点 3,说明 9 位于左子树,因为根节点不是中序遍历中的第一个节点。同理,前序遍历的后几个元素 8、5、4 也都位于左子树,且每个节点都是其上一个节点的左子节点。
//    前序遍历到元素 4,和中序遍历的第一个元素相等,说明前序遍历的下一个元素 10 位于右子树。那么 10 位于哪个元素的右子树?从前序遍历看,10 可能位于 4、5、8、9、3 这些元素中任何一个元素的右子树。从中序遍历看,10 在 8 的后面,因此 10 位于 8 的右子树。把前序遍历的顺序反转,则在 10 之前的元素是 4、5、8、9、3,其中 8 是最后一次相等的节点,因此前序遍历的下一个元素位于中序遍历中最后一次相等的节点的右子树。
//    同理可知,20 位于 3 的右子树,15 和 7 分别是 20 的左右子节点。
//    根据上述例子和分析,可以使用栈保存遍历过的节点。初始时令中序遍历的指针指向第一个元素,遍历前序遍历的数组,如果前序遍历的元素不等于中序遍历的指针指向的元素,则前序遍历的元素为上一个节点的左子节点。如果前序遍历的元素等于中序遍历的指针指向的元素,则正向遍历中序遍历的元素同时反向遍历前序遍历的元素,找到最后一次相等的元素,将前序遍历的下一个节点作为最后一次相等的元素的右子节点。其中,反向遍历前序遍历的元素可通过栈的弹出元素实现。
//    使用前序遍历的第一个元素创建根节点。
//    创建一个栈,将根节点压入栈内。
//    初始化中序遍历下标为 0。
//    遍历前序遍历的每个元素,判断其上一个元素(即栈顶元素)是否等于中序遍历下标指向的元素。
//    若上一个元素不等于中序遍历下标指向的元素,则将当前元素作为其上一个元素的左子节点,并将当前元素压入栈内。
//    若上一个元素等于中序遍历下标指向的元素,则从栈内弹出一个元素,同时令中序遍历下标指向下一个元素,之后继续判断栈顶元素是否等于中序遍历下标指向的元素,若相等则重复该操作,直至栈为空或者元素不相等。然后令当前元素为最后一个想等元素的右节点。
//    遍历结束,返回根节点。
//
//    作者:LeetCode-Solution
//    链接:https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof/solution/mian-shi-ti-07-zhong-jian-er-cha-shu-by-leetcode-s/
//    来源:力扣(LeetCode)
//    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。



//    前序遍历,从根节点root开始,只要有左子节点,就一直会往左下方走,直到最左下角。 而中序遍历,是从最左下角往上(示例中的4-5-8-9-3),如果碰到节点有右子节点,则会转向(示例中的8-10)。
//    因此,代码中的if块是用前序数组一直构建左子树,如果碰到了inorder[inorderIndex],表示到了左下角,这时就需要往上走并处理右子树,也就是while代码块。
//    public static TreeNode buildTree(int[] preorder, int[] inorder) {
//        if (preorder == null || preorder.length == 0) {
//            return null;
//        }
//        TreeNode root = new TreeNode(preorder[0]);
//        int length = preorder.length;
//        Stack<TreeNode> stack = new Stack<TreeNode>();
//        stack.push(root);
//        int inorderIndex = 0;
//        for (int i = 1; i < length; i++) {
//            int preorderVal = preorder[i];
//            TreeNode node = stack.peek();
//            if (node.val != inorder[inorderIndex]) {
//                node.left = new TreeNode(preorderVal);
//                stack.push(node.left);
//            } else {
//                while (!stack.isEmpty() && stack.peek().val == inorder[inorderIndex]) {
//                    node = stack.pop();
//                    inorderIndex++;
//                }
//                node.right = new TreeNode(preorderVal);
//                stack.push(node.right);
//            }
//        }
//        return root;
//    }


//    作者:sdwwld
//    链接:https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof/solution/4chong-jie-fa-di-gui-zhan-dui-lie-by-sdwwld/
//    来源:力扣(LeetCode)
//    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
//                      3
//                     / \
//                    9  20
//                   /  /  \
//                 8   15   7
//                / \
//               5  10
//              / \
//             4  null
//            /  \
//          null null
    private static int in = 0;  //遍历中序遍历的下标
    private static int pre = 0;  //遍历前序遍历的下标

    public static TreeNode buildTree(int[] preorder, int[] inorder) {
        return build(preorder, inorder, 0);    //这里的0可以是题目中明确规定的不可能在树上的value值}
    }
    private static TreeNode build(int[] preorder, int[] inorder, int stop) {
        if (pre >= preorder.length)
            return null;
        if (inorder[in] == stop) {     //中序遍历中找到前序遍历的第一个值(根节点)
            in++;
            return null;
        }

        TreeNode node = new TreeNode(preorder[pre++]);    //取前序遍历当前结点的内容
        node.left = build(preorder, inorder, node.val);   //前序遍历的值进入递归,递归取理论上中序遍历这个值之前都是左子树的内容,
        node.right = build(preorder, inorder, stop);     //其他的就是当前节点的整个右子树,继续遍历划分左右子树
        return node;
    }

}

 

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页