发布算法训练营第15天|110.平衡二叉树、257.二叉树的所有路径、404.左叶子之和、222.完全二叉树的所有节点个数

迟到的第15天，勉勉强强补完了这几个题，递归，递归，还是TND递归....

补的过程中发现对递归的掌握还是不太顺畅，又去补习了下递归的原理，继续懵逼状态...

110.平衡二叉树

这一题，主要是没想到如果某一层比较出来是非平衡二叉树时怎么返回，看了解答才知道用一个数值标记下然后返回就好了，真是太机智了。

package binaryTree;

public class IsBalancedBinaryTreeDemo {
    public static void main(String[] args) {

    }

    public boolean isBalanced(TreeNode root) {
        return getHeight(root) != -1;
    }

    //递归，递归，还是递归
    //用递归求出左右子树的高度，这里有个注意点是如果左右子树高度差超过1，可以直接返回一个非平衡树的标记
    //否则，继续往下查看更下一级的左右子树高度差
    private int getHeight(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftHeight = getHeight(root.left);
        if (leftHeight == -1) {
            return -1;
        }
        int rightHeight = getHeight(root.right);
        if (rightHeight == -1) {
            return -1;
        }
        // 左右子树高度差大于1，return -1表示已经不是平衡树了
        if (Math.abs(leftHeight - rightHeight) > 1) {
            return -1;
        }
        return Math.max(leftHeight, rightHeight) + 1;
    }
}

257.二叉树的所有路径

package binaryTree;

import java.util.ArrayList;
import java.util.List;

public class BinaryTreePathsDemo {
    static List<String> result = new ArrayList<String>();
    public static void main(String[] args) {

    }

    public static List<String> getBinaryTreePaths(TreeNode root) {
        deal(root,"");
        return result;
    }
    //这种解法更容易理解，通过递归调用，找到所有的叶子节点，在到达叶子节点之前，记录每个路径上的值
    public static void deal(TreeNode node, String s) {
        if(node == null) {return;}

        if(node.left == null && node.right == null) {//找到叶子节点了，记录path
            result.add(s + node.val);
        }
        String tmp = s + node.val + "->";
        deal(node.left, tmp);
        deal(node.right,tmp);
    }


    //另一种解法，递归+回溯，思路并不难，但是代码看起有点费解
    public static List<String> binaryPaths(TreeNode root) {
        List<String> res = new ArrayList<String>();//存最终结果
        if(root == null) {return res;}

        List<Integer> paths = new ArrayList<Integer>();//作为结果中的路径1->2->3这种
        traversal(root,paths,res);
        return res;

    }

    public static void traversal(TreeNode node,List<Integer> paths, List<String> res) {
        //首先，对res进行操作肯定是在叶子节点里，但是我们在这个traversal函数的调用里，
        //要下经过一系列节点，才会到达叶子节点，所以在递归之前需要先处理非叶子节点

        //首先将node节点的值放入paths中
        paths.add(node.val);

        if(node.left == null && node.right == null) {//到达叶子节点了
            //此时需要将paths里的值拼装成string放入res中
            StringBuilder sb = new StringBuilder();
            for(int i = 0; i < paths.size() - 1; i++) {
                sb.append(paths.get(i)).append("->");
            }
            sb.append(paths.getLast());
        }

        //非叶子节点时，需要递归调用到该节点的左右子树中去
        //递归和回溯是同时进行，所以要放在同一个花括号里
        if(node.left != null) {
            traversal(node.left,paths,res);
            //注意，这里的一步非常关键，递归到里面之后，返回的时候因为需要回溯，所以要把最后一个加进去的节点值删除
            paths.removeLast();
        }

        if(node.right != null) {
            traversal(node.right,paths,res);
            paths.removeLast();
        }
    }
}

404.左叶子之和

这一题我用自己的思路写了下，发现在leetcode上有个别case通过不了，主要是是否左叶子的判断逻辑上有问题，我是剔除右叶子的方式，但是应该没剔干净。。。看了老师的代码，原来只要在单层递归逻辑里找出左叶子节点就ok了，尴尬。。

package binaryTree;

import java.util.ArrayList;
import java.util.List;

public class SumOfLeftLeavesDemo {
    public static void main(String[] args) {

    }

    List<Integer> list = new ArrayList<Integer>();
    public int sumOfLeftLeaves(TreeNode root) {
        if(root.left == null && root.right == null) {
            return 0;
        }
        //这一题是要找到所有的左叶子，然后把对应的值加起来就好了
        findLeftLeaves(root,list);
        // System.out.println(list);
        int sum = 0;
        for(int x : list) {
            sum += x;
        }
        return sum;
    }

    public void findLeftLeaves(TreeNode node, List<Integer> list) {
        if(node == null) {return;}

        if(node.left == null && node.right == null) { //此时为叶子节点了，假设都是左叶子
            list.add(node.val);
            return;
        }
        //递归左子树
        findLeftLeaves(node.left,list);

        //递归右子树，得递归右子树的左子树不为空的
        if(node.right != null && node.right.left != null) {
            findLeftLeaves(node.right,list);
        }

    }

    public int sumOfLeftLeaves2(TreeNode root) {
        if(root == null) {return 0;}

        int leftValue = sumOfLeftLeaves2(root.left);
        int rightValue = sumOfLeftLeaves2(root.right);

        //单层递归内部的逻辑，这里要判断出是左叶子节点，和我上面那个没验证通过的方法逻辑差不多
        //就是看这个节点的父节点不为空，且父节点的左节点是叶子节点
        int midValue = 0; //记录当前左叶子节点的值
        if(root.left != null && root.left.left == null && root.left.right == null) {
            midValue = root.left.val;
        }

        int sum = midValue + leftValue + rightValue;

        return sum;
    }
}

222.完全二叉树的节点个数

这个题严重怀疑是贴错地方了，是不是在前面课程里就可以做的了，简单的一个递归搞定了，单层递归里的逻辑也很简单。

package binaryTree;

public class CountNodesDemo {
    public static void main(String[] args) {

    }

    public int countNodes(TreeNode root) {
        if(root == null) return 0;

        if(root.left == null && root.right == null) {
            return 1;
        }

        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}