LeetCode 打卡day15 --树的层序遍历, 递归迭代都实现

---

知识总结

今天学习了树的层序遍历， 深入了解了DFS递归的方法和BFS迭代的方法， 题目都很经典， 自己也都写出来了。

---

Leetcode 102. 二叉树的层序遍历

题目链接

题目说明

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

代码说明

递归法要注意，传进去的参数是node和deep表示当期遍历的树节点和当前的层数。 至于结果的res, 我们可以当作参数， 也可以直接作为一个成员变量。
递归法

class Solution {
    public List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        dfs(root, 0);
        return res;
    }

    private void dfs(TreeNode node, int deep){
        if(node == null) return;
        deep++;

        if(res.size() < deep){
            res.add(new ArrayList<Integer>());
        }
        res.get(deep -1).add(node.val); // 这里deep -1 表示最后一个列表， 也可以理解成当前的层数对应的列表
        dfs(node.left, deep);
        dfs(node.right, deep);
    }
}

迭代法

class Solution {
    public List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        if(root == null) return res;
        queue.offer(root);
        while(!queue.isEmpty()){
            int len = queue.size(); // len 表示这一层有多少个节点需要遍历
            List<Integer> leverList = new ArrayList<>();
            while(len>0){
                TreeNode cur = queue.poll();
                if(cur.left != null) queue.offer(cur.left);
                if(cur.right!= null) queue.offer(cur.right);
                leverList.add(cur.val);
                len--;
            }
            res.add(leverList);
        }
        return res;
    }    
}

---

Leetcode 107. 二叉树的层序遍历 II

题目链接

题目说明

这是一个变种题， 有两个方法。
最直接的使用 Collections.reverse() 方法返回结果

Collections.reverse(res);
return res;

或者每次插入列表的时候， 插入在头节点， 而不是在尾节点

res.add(0, levelList)

代码说明

递归法

class Solution {
    public List<List<Integer>> res = new ArrayList<>();

    private void dfs(TreeNode node, int deep){
        if(node == null) {
            return;
        }

        if(res.size() == deep){
            res.add(0, new ArrayList<Integer>()); //关键区别1
        }
        res.get(res.size() - deep - 1).add(node.val); //关键区别2
        dfs(node.left, deep+1);
        dfs(node.right, deep+1);
        
    }
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        dfs(root, 0);   
        return res;
    }
}

迭代法

class Solution {
    public List<List<Integer>> res = new ArrayList<>();
       
    public List<List<Integer>> levelOrderBottom(TreeNode root) {  
        Queue<TreeNode> queue = new LinkedList<>();
        if(root == null) return res;
        queue.offer(root);
        while(!queue.isEmpty()){
            int len = queue.size();
            List<Integer> list = new ArrayList<>();
            while(len > 0){
                TreeNode cur = queue.poll();
                list.add(cur.val);
                if(cur.left != null) queue.offer(cur.left);
                if(cur.right!= null) queue.offer(cur.right);
                len--;
            }
            res.add(0, list);
        }
        return res;
    }
}

---

Leetcode 226. 翻转二叉树

题目链接

题目说明

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

代码说明

DFS 代码量明显少很多

class Solution {
    public TreeNode invertTree(TreeNode root) {
        dfs(root);
        return root;
    }
    public void dfs(TreeNode root){
        if(root == null) return;
        
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        dfs(root.left);
        dfs(root.right);
    }

---

Leetcode 101. 对称二叉树

题目链接

题目说明

给你一个二叉树的根节点 root ， 检查它是否轴对称。

代码说明

递归法， 不要忘记对空值针的考虑

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return dfs(root.left, root.right);
    }
    public boolean dfs(TreeNode left, TreeNode right){
        if(left == null && right == null){
            return true;
        }
        if(left == null || right == null){
            return false;
        }

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

迭代法，每次遍历两个节点

class Solution {
    public boolean isSymmetric(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        
        if(root == null) return true;
        queue.offer(root.left);
        queue.offer(root.right);
        while(!queue.isEmpty()){
            int len = queue.size();
            if(len % 2 != 0) return false;
            TreeNode l = queue.poll();
            TreeNode r = queue.poll();

            if(l == null && r == null){
                continue;
            }

            if(l == null || r == null){
                return false;
            }

            if(l.val != r.val){
                return false;
            }

            queue.offer(l.left);
            queue.offer(r.right);
            queue.offer(l.right);
            queue.offer(r.left);
        }
        return true;
    }    
}

---