代码随想录算法训练营Day14| 226.翻转二叉树、101. 对称二叉树、104.二叉树的最大深度、 111.二叉树的最小深度

 226.翻转二叉树

        思路：递归把每个节点的左右孩子节点反转。这里用先序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null){return root;}
        //swapNode(root.left,root.right);
        swapChildren(root);
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }

    public void swapNode(TreeNode l, TreeNode r){
        TreeNode temp = l;
        l = r;
        r = temp;
        return;
    }

    private void swapChildren(TreeNode root) {
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
    }
}

101、对称二叉树

        思路：用递归。第一步确定好返回值和参数。第二步：确定终止条件。第三步：确定单个递归逻辑。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null){return true;}
        
        boolean flag = compareNode(root.right, root.left);
        return flag;
    }

    private boolean compareNode(TreeNode left, TreeNode right){
        //终止条件
        if(right == null &&left == null){return true;}
        if(left == null && right != null){return false;}
        if(left != null && right == null ){return false;}
        if(left.val != right.val){return false;}
        boolean flag1 = compareNode(left.left, right.right);
        boolean flag2 = compareNode(left.right, right.left);
        return flag1 && flag2;
    }

}

104.二叉树的最大深度

        思路：采用后序遍历，用高度表示深度

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode cur) {
        if(cur == null) return 0;
        int left = maxDepth(cur.left);
        int right = maxDepth(cur.right);
        int res = Math.max(left,right) + 1;
        return res;
    }

}

111.二叉树的最小深度

        思路：依旧是高度转化为深度。要注意根节点的孩子节点为空时，是不算叶子节点的。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        if(root == null) return 0;
        int left = minDepth(root.left);
        int right = minDepth(root.right);
        if(left == 0 && right != 0){
            return right + 1;
        }
        if(right == 0 && left != 0){
            return left +1;
        }
        if(right == 0 && left == 0){
            return 1;
        }
        int res = Math.min(right, left) + 1;
        return res;
    }
}

N叉树的层序遍历

        思路：和上一篇文章讲的一样，只不过有多个孩子节点

        代码框架：定义一个结果二维数组。判断根节点是否为空，是则返回。不是，创建一个队列，头节点入队。

        while队列不为空时：记录队列长度，创建一个一维数组记录当前层遍历结果。按照队列长度遍历当前层，遍历一个加入数组。遍历结束，当前数组加入结果数组中.

        实际写起来还是有很多错误：

        1、一定要理清楚哪一层循环在做什么事情。添加列表进二维数组是当一层遍历完的时候。

        2、要取出孩子列表，要先将元素弹出来，取他的孩子列表。

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new LinkedList<>();
        if(root == null){
            return res;
        }
        Queue<Node> que = new LinkedList<>();
        que.add(root);
        while(!que.isEmpty()){
            List<Integer> list = new LinkedList<>();
            int size = que.size();
            while(size-- > 0){
                Node cur = que.poll();
                list.add(cur.val);
                List<Node> childrenList = cur.children;
                if(childrenList == null || childrenList.size() == 0){
                    continue;
                }
                for(Node n : childrenList){
                    if(n !=null){
                        que.add(n);
                    }
                }
                res.add(list);
            }
        }
        return res;
    }
}

515.在每个树行中找最大值

        思路:参考上一篇平均值，做起来轻松加愉快。

        注意下节点值是有复数的，所以定义max不能等于0，需要赋值给当前层第一个遍历的节点值，或者整数最小值也行。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root);
        while(!que.isEmpty()){
            int size = que.size();
            int max = que.peek().val;
            while(size-->0){
                TreeNode temp = que.poll();
                max = max > temp.val ? max : temp.val;

                if(temp.left != null){
                    que.add(temp.left);
                }
                if(temp.right !=null){
                    que.add(temp.right);
                }

            }
            res.add(max);
        } 
        return res;
    }
}