代码随想录算法训练营Day 15| 层序遍历、226.翻转二叉树、101.对称二叉树

层序遍历

代码随想录

思路：

代码:

迭代法

class Solution {//迭代法借助队列
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<TreeNode> que = new LinkedList<>();
        que.add(root);
        while(!que.isEmpty()){
            List<Integer> list = new ArrayList<>();//记录每一层遍历的结果
            int size = que.size();//每层需要遍历的元素数
            while(size > 0){//将每层元素加入的同时将每个元素下一层的元素放入队列
                TreeNode node = que.poll();
                list.add(node.val);
                if(node.left != null){
                    que.add(node.left);
                }
                if(node.right != null){
                    que.add(node.right);
                }
                size--;
            }
            res.add(list);
        }
        return res;
    }
}

递归法

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        process(root, 0, res);
        return res;
    }

    private void process(TreeNode node, int deep, List<List<Integer>> res){
        if(node == null){
            return;
        }
        deep++;//每下一曾deep就要增加，来控制res中list的数量
        if(res.size() < deep){
            res.add(new ArrayList<>());
        }
        res.get(deep - 1).add(node.val);
        process(node.left, deep, res);
        process(node.right, deep, res);

    }
}

 层遍历：

需要注意的点：

226.翻转二叉树

代码随想录

思路：

代码:

递归法：

class Solution {//递归法
    public TreeNode invertTree(TreeNode root) {//含义：翻转root之下的树
        if(root == null){
            return null;
        }
        invertTree(root.left);//先反转root的左树
        invertTree(root.right);//再反转root的右树
        swap(root);//最后交换root的左右子树
        return root;
    }
    private void swap(TreeNode node){//交换node的左右孩子
        TreeNode temp = node.left;
        node.left = node.right;
        node.right = temp;
    }
}

 层遍历：

class Solution {//用层遍历，此时的目的是每层遍历到的元素交换其左右子树
    public TreeNode invertTree(TreeNode root) {
        if(root == null) return null;
        Queue<TreeNode> que = new LinkedList<>();
        que.add(root);
        while(!que.isEmpty()){
            int size = que.size();
            while(size-- > 0){
                TreeNode node = que.poll();
                swap(node);
                if(node.left != null){
                    que.add(node.left);
                }
                if(node.right != null){
                    que.add(node.right);
                }
            }
        }
        return root;
    }

    private void swap(TreeNode node){
        TreeNode temp = node.left;
        node.left = node.right;
        node.right = temp;
    }
}

 

需要注意的点：

101.对称二叉树

代码随想录

思路：

代码:

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return compare(root.left, root.right);
    }

    private boolean compare(TreeNode left, TreeNode right){
        if(left == null && right != null){
            return false;
        }
        if(left != null && right == null){
            return false;
        }

        if(left == null && right == null){//直到判定到结尾还没有结果就说明对称
            return true;
        }

        if(left.val != right.val){
            return false;
        }

        boolean outside = compare(left.left, right.right);//比较外侧
        boolean inside = compare(left.right, right.left);//比较内侧
        return outside && inside;
    }
}

需要注意的点：

1、对值的判断要放在最后，以为可能出现null