代码随想录day16|树左下角,路径总和,从中后序遍历序列构造二叉树

文章:代码随想录

树左下角的值:

思路：

前中后序遍历都可以,通过找到最大深度的叶子节点获取它的值,所以需要两个全局变量,maxDepth记录最大深度和maxVlue记录最大值。 因为目的只是更新这两个值所以遍历顺序前中后都可以. 你可能会疑惑,不是找最左边的叶子节点吗？那怎么判断它是不是最左呢？ 其实那种顺序我们都是左边优先先遍历,所以当maxDepth和maxValue更新到第一个最大值时已经是最左边那个左叶子节点了 后面同一层的右叶子节点也没办法更新maxDepth和maxValue,因为比它们大才会更新,相等不更新。

注意: 最大深度的靠左节点不代表一定是左孩子,如果是右孩子但是它是唯一的最大深度的叶子节点,那么它也是这棵树的最底层最左边的节点，因为最底层就只有它一个节点.

代码：

 int maxDepth=0;
    int maxValue=0;
    public int findBottomLeftValue(TreeNode root) {
        getLeft(root,1);
        return maxValue;
    }

    private void getLeft(TreeNode node, int depth) {
        //叶子节点
        if(node.left==null && node.right==null){
            if(depth>maxDepth){
                maxDepth=depth;
                maxValue=node.val;
            }
            return;
        }
        depth++;
        if(node.left!=null) getLeft(node.left,depth);
        if(node.right!=null) getLeft(node.right,depth);
    }

层序遍历方法：

更加直观,只需要一直记录每一层的第一个就可以。

public int findBottomLeftValueLevel(TreeNode root){
        if(root==null){return 0;}
        Queue<TreeNode> levelRecord=new LinkedList<>();
        levelRecord.offer(root);
        int result=0;
        while(!levelRecord.isEmpty()){
            int size=levelRecord.size();
            for(int i=0;i<size;i++){
                TreeNode top=levelRecord.poll();
                if(i==0){result=top.val;}
                if(top.left!=null){levelRecord.offer(top.left);}
                if(top.right!=null){levelRecord.offer(top.right);}
            }
        }

        return result;
    }

路径总和：

分为中序递归遍历,和层序迭代遍历思路.

递归思路：

传入targetSum逐层递减,最后判断是否为0。

代码：

public boolean hasPathSumPost(TreeNode root, int targetSum) {
        //这是为了防止root一开始就是null
        if(root==null){return false;}
        targetSum-=root.val;
        //终止条件,遍历到叶子节点
        if(root.left==null&&root.right==null){
            if(targetSum==0){return true;}
            else return false;
        }
        boolean left=false;
        boolean right=false;
        //这里targetSum是基本数据类型,那在这个方法栈里它的值不会随着传入下一层就改变,所以不需要回溯.
        if(root.left!=null){ left=hasPathSumPost(root.left,targetSum);}
        if(root.right!=null){right=hasPathSumPost(root.right,targetSum);}
        //只要有任意一条路径满足满足就返回true
        return left || right;
    }

层序遍历：

一次压入队列两个值,节点和节点值加sum的累加值,看到最后叶子节点的时候,是否sum为targetSum。(用两个栈实现也可以,用栈记得左右压入顺序要调换)。

代码：

 public boolean hasPathSumPostLevel(TreeNode root, int targetSum) {
        if(root==null){return false;}
        Queue<Object> levelRecordValue=new LinkedList<>();
        levelRecordValue.offer(root);
        levelRecordValue.offer(root.val);
        while (!levelRecordValue.isEmpty()){
            int size=levelRecordValue.size();
            for (int i=0;i<size;i+=2){
                TreeNode top=(TreeNode) levelRecordValue.poll();
                int sum=(int) levelRecordValue.poll();
                if(top.left==null&&top.right==null){
                    if(sum==targetSum) return true;

                }
                if(top.left!=null){
                    levelRecordValue.offer(top.left);
                    levelRecordValue.offer(sum+top.left.val);
                }
                if(top.right!=null){
                    levelRecordValue.offer(top.right);
                    levelRecordValue.offer(sum+top.right.val);
                }
            }

        }

        return false;

    }

从中后序遍历序列构造二叉树

思路：

可以注意到后序的最后一个节点一定是根节点,那么根据这个根节点,可以切出此时中序中根节点的左右子树,那么知道了根节点的左右子树, 这时,又可以根据中序数组中的左右子树的长度,再切割后序数组中的根节点的左右子树. 接着又可以根据这个根节点的左右子树的最后一个节点,知道下一层的左右节点分别是什么,然后再到中序数组中切割,再通过中序数组的信息反过来切割后序数组,以此往复递推。所以要新建一个方法,递归更新节点,记录左区间的开始和结束位置,右区间的开始和结束位置.是不是有点像二分法？其实底层逻辑是差不多的.

思路比较简答,但是细节很多,同时也要注意循环不变量,是左闭右开还是左闭右闭.

我在代码中注释了每一行的思路和细节。

代码:

 public static TreeNode buildTree(int[] inorder, int[] postorder) {
        if(inorder.length==0 || postorder.length==0 ){return null;}
        //左闭右闭
        return buildTreeHelper(inorder,0,inorder.length-1,postorder,0,postorder.length-1);
    }

    private static TreeNode buildTreeHelper(int[] inorder, int inStart, int inEnd, int[] postorder, int postStart, int postEnd) {

        //终止条件,当开始和结束指针相遇时,就证明这次递归到尽头了。
        // 因为是左闭右闭原则,所以当结束指针小于开始指针时才结束,因为他们相等时还需要遍历最后一个元素
        // 如果是左闭合右开,那么就可以判断相等时就结束.
        if(postEnd<postStart || inEnd< inStart) return null;
        //得到这一层的中节点的值

        int nodeVal=postorder[postEnd];
        //创建这个树节点
        //第一次进来时其实就是根节点
        TreeNode root=new TreeNode(nodeVal);
        //找到这个中节点在中序数组中当前区间里的位置
        int midIndex=0;
        //这里同时要遵循左闭右闭原则
        for (int i = inStart; i <=inEnd ; i++) {
            if(inorder[i]==nodeVal){midIndex=i;break;}
        }

        //那么找到了这个中节点的位置,我们可以干什么?我们可以把中序数组中这个区间的左右子树的区间找到对吧。
        //当前区间下的左子树区间
        int leftTreeStartIn=inStart;
        int leftTreeEndIn=midIndex-1;
        //当前区间下的右子树区间
        int rightTreeStartIn=midIndex+1;
        int rightTreeEndIn=inEnd;

        //这个时候我们知道了中序数组中左右子树的长度,那么后序是左右中的对吧?
        //那我们就可以根据这个长度信息来把当前节点/区间下的左右子树切割出来.
        //当前区间下的左子树区间。
        int leftTreeStartPost=postStart;
        int leftTreeEndPost=postStart+(leftTreeEndIn-leftTreeStartIn);
        //当前区间下的右子树区间。
        int rightTreeStartPost=leftTreeEndPost+1;
        int rightTreeEndPost=postEnd-1;

        //找到中后序的左右子树区间之后就可以根据区间进行递归,然后将节点的左右子树挂载
        root.left=buildTreeHelper(inorder,leftTreeStartIn,leftTreeEndIn,postorder,leftTreeStartPost,leftTreeEndPost);
        root.right=buildTreeHelper(inorder,rightTreeStartIn,rightTreeEndIn,postorder,rightTreeStartPost,rightTreeEndPost);


        //将节点返回
        return root;
    }

 一种优化方法,就是用一个map先记录中序中每一个元素的下标,这样后序查询都只需要O(1),不需要每次都for循环遍历。空间换时间。

这一次写左闭右开,然后同时简化前面的左右子树赋值步骤到递归调用中.逻辑和步骤是一致的。

代码：

 Map<Integer,Integer> record;
    public  TreeNode buildTreeMap(int[] inorder, int[] postorder) {
        if(inorder.length==0 || postorder.length==0 ){return null;}
        record=new HashMap<>();
        for (int i = 0; i < inorder.length; i++) {
            record.put(inorder[i],i);
        }
        //左闭右开
        return buildTreeHelperMap(inorder,0,inorder.length,postorder,0,postorder.length);
    }

    private  TreeNode buildTreeHelperMap(int[] inorder, int inBegin, int inEnd, int[] postorder, int postBegin, int postEnd) {
        //左闭右开,所以这里是相等来判断
        if(postEnd==postBegin || inEnd==inBegin) return null;
        int midIndex = record.get(postorder[postEnd - 1]);
        TreeNode root = new TreeNode(postorder[postEnd - 1]);
        int lenOfLeft = midIndex - inBegin;
        root.left = buildTreeHelperMap(inorder, inBegin, midIndex,
                postorder, postBegin, postBegin + lenOfLeft);
        root.right = buildTreeHelperMap(inorder, midIndex + 1, inEnd,
                postorder, postBegin + lenOfLeft, postEnd - 1);

        return root;
    }