代码随想录算法训练营第十八天|LeetCode513,112,113,105,106

代码随想录算法训练营第十八天|LeetCode513,112,113,105,106

513. 找树左下角的值

在树的最后一行找到最左边的值。

首先要是最后一行，然后是最左边的值。即深度最大的最左边的叶子节点。利用层序遍历来实现迭代的话相对简单，使用递归的话需要用到回溯。

 int maxDepth = Integer.MIN_VALUE;
    int result;
    public int findBottomLeftValue(TreeNode root){
        traversal(root,0);
        return result;
    }
    public  void traversal(TreeNode node, int depth){
        if (node.left == null && node.right == null){
            //如果是更深的节点
            if (depth > maxDepth){
                maxDepth = depth;
                result = node.val;
            }
            return;
        }


        if (node.left!=null){
            depth++;
            traversal(node.left, depth);
            depth--;//回溯
        }
        if (node.right!=null){
            depth++;
            traversal(node.right, depth);
            depth--;//回溯
        }

//        //精简的回溯
//        if (node.left) {
//            traversal(node.left, depth + 1); // 隐藏着回溯,因为当前层的depth没有+1.
//        }
//        if (node.right) {
//            traversal(node.right, depth + 1); // 隐藏着回溯
//        }
        return;
    }

112.路径总和/113.路径总和ii

通过这两道题，主要是明确递归函数什么时候需要返回值，什么时候不需要返回值。
总结如下：

• 如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。
• 如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。
• 如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。（本题的情况）

此外，需要注意这两道题都运用到了回溯

  //递归,112
    public boolean hasPathSum(TreeNode root, int targetSum){
        if (root == null) return false;
        return traversal(root,targetSum-root.val);

    }

    public boolean traversal(TreeNode node, int count){
        //判断叶子节点是否满足条件
        if (node.right == null && node.left == null&&count==0) return true;
        if(node.right == null && node.left == null) return false;
        if (node.left!=null){
            if (traversal(node.left,count - node.left.val))
                return true;
        }
        if (node.right!=null){
            if (traversal(node.right,count-node.right.val)){
                return true;
            }
        }
        return false;
    }

	//递归，113
	 List<List<Integer>> result = new ArrayList<>();
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<Integer> path = new ArrayList<>();
        if (root == null){
            return result;
        }
        traversal(root, targetSum-root.val,path);
        return result;
    }

    public void traversal(TreeNode node, int count,List<Integer> path){

        path.add(node.val);


        //找到叶子节点并且满足条件
        if (node.left == null && node.right == null&&count == 0){
            result.add(new ArrayList<>(path));
            return;
        }
        //找到不满足条件的叶子结点
        if(node.left == null && node.right == null){
            return;
        }

        if (node.left!=null){
            traversal(node.left,count - node.left.val,path);//隐含了对count的回溯
            path.remove(path.size()-1);//对路径的回溯
        }

        if (node.right!=null){
            traversal(node.right,count - node.right.val,path);//隐含了对count的回溯
            path.remove(path.size()-1);//对路径的回溯
        }

    }

106.从中序与后序遍历序列构造二叉树/105.从中序与前序遍历序列构造二叉树

以 后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来再切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素。

• 第一步：如果数组大小为零的话，说明是空节点了。
• 第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。
• 第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点
• 第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）
• 第五步：切割后序数组，切成后序左数组和后序右数组
• 第六步：递归处理左区间和右区间

本题需要注意的点：

本题并不需要实际上拆分数组，通过索引进行划分即可。中序数组通过后续数组最后一个进行划分，然后后续数组根据中序数组划分后的大小进行划分。

//106
 Map<Integer, Integer> map;  // 方便根据数值查找位置
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        map = new HashMap<>();
        for (int i = 0; i < inorder.length; i++) { // 用map保存中序序列的数值对应位置
            map.put(inorder[i], i);
        }

        return findNode(inorder,  0, inorder.length, postorder,0, postorder.length);  // 前闭后开
    }

    public TreeNode findNode(int[] inorder, int inBegin, int inEnd, int[] postorder, int postBegin, int postEnd) {
        // 参数里的范围都是前闭后开
        if (inBegin >= inEnd || postBegin >= postEnd) {  // 不满足左闭右开，说明没有元素，返回空树
            return null;
        }
        int rootIndex = map.get(postorder[postEnd - 1]);  // 找到后序遍历的最后一个元素在中序遍历中的位置
        TreeNode root = new TreeNode(inorder[rootIndex]);  // 构造结点
        int lenOfLeft = rootIndex - inBegin;  // 保存中序左子树个数，用来确定后序数列的个数
        root.left = findNode(inorder, inBegin, rootIndex,
                postorder, postBegin, postBegin + lenOfLeft);
        root.right = findNode(inorder, rootIndex + 1, inEnd,
                postorder, postBegin + lenOfLeft, postEnd - 1);

        return root;
    }

//105
    Map<Integer, Integer> map;
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        map = new HashMap<>();
        for (int i =0;i<inorder.length;i++){
            map.put(inorder[i],i);
        }
        //在这里就决定了左右数组的表示方式为左闭右开。
        return findNode(preorder, 0,preorder.length,inorder,0,inorder.length );
    }

    public TreeNode findNode(int[] preorder, int preBegin, int preEnd,int[] inorder, int inBegin, int inEnd){
        if (preBegin >= preEnd||inBegin >= inEnd){
            return null;
        }
        int rootIndex = map.get(preorder[preBegin]);//找到前序遍历的第一个点在中序遍历的位置
        TreeNode root = new TreeNode(inorder[rootIndex]);//构造节点
        int lenOfLeft = rootIndex - inBegin; //保存中序左子树的个数，用来分隔前序数组
        root.left = findNode(preorder,preBegin+1,preBegin+lenOfLeft+1,inorder,inBegin,rootIndex);
        root.right = findNode(preorder,preBegin+lenOfLeft+1,preEnd,inorder,rootIndex+1,inEnd);
        return root;

    }