训练营1005|二叉树（层序遍历|翻转|对称）

目录

102.二叉树的层序遍历

226.翻转二叉树

101.对称二叉树

---

102.二叉树的层序遍历

 层序遍历----->利用队列，每一层每一层的放进去，因此我们判断循环是否结束的条件是，queue里面是否为空。

class Solution {
    /**
     * 二叉树的层序遍历
     *
     * @param root
     * @return
     */
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<>();
        if (root == null) {
            return ans;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty() ) {
            List<Integer> jo = new ArrayList<>();
            int queueSize = queue.size();
            for (int i = 0; i < queueSize; i++) {
                TreeNode temp = queue.poll();
                jo.add(temp.val);
                if (temp.left != null) {
                    queue.add(temp.left);
                }
                if (temp.right != null) {
                    queue.add(temp.right);
                }
            }
            ans.add(jo);
        }
        return ans;
    }
}

---

226.翻转二叉树

可以利用层序遍历，每一层弹出左右孩子的时候把左右结点交换

递归：

class Solution {
    /**
     * 翻转二叉树，返回翻转后的二叉树的根节点
     *
     * @param root
     * @return
     */
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        TreeNode left = invertTree(root.right);
        TreeNode right = invertTree(root.left);
        root.left = left;
        root.right = right;
        return root;
    }
}

---

101.对称二叉树

检查是否对称，无论是递归还是迭代，都需要把树copy一遍，即在a树，b树的基础上，各看一半

深度优先------>递归。简化递归的想象过程，如果只有一个结点，就是a树，b树去判断这个结点空吗，如果不空就要判断值。这边就可以写出前三个if了。然后递归开始，是因为如果结点多了起来，一样的去判断a的左子树和b的右子树。a的右子树和b的左子树。这边不可以少任何一组，

class Solution {
    /**
     * 检查是否是对称二叉树---->copy成两个树，a树的左子树和b树的右子树比较
     *
     * @param root
     * @return
     */
    public boolean isSymmetric(TreeNode root) {
        return check(root, root);
    }

    public boolean check(TreeNode p, TreeNode q) {
        if (p == null && q == null) {
            return true;
        }
        if (p == null || q == null) {
            return false;
        }
        if (p.val != q.val) {
            return false;
        }
        return check(p.left, q.right) && check(p.right, q.left);
    }
}

广度优先遍历----->迭代。

利用层次遍历，在层次遍历的基础上，每次从队列中取出两个数（两根树压进去的结点值）。注意比对是左孩子跟右孩子比。错开比较，错开压进队列

class Solution {
    /**
     * 检查是否是对称二叉树---->copy成两个树，a树的左子树和b树的右子树比较
     *
     * @param root
     * @return
     */
    public boolean isSymmetric(TreeNode root) {
        return check(root, root);
    }

    public boolean check(TreeNode p, TreeNode q) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(p);
        queue.add(q);
        while (!queue.isEmpty()) {
            TreeNode u = queue.poll();
            TreeNode v = queue.poll();
            if (u == null && v == null) {
                continue;
            }
            if (u == null || v == null) {
                return false;
            }
            if (u.val != v.val) {
                return false;
            }
            queue.add(u.right);
            queue.add(v.left);
            queue.add(u.left);
            queue.add(v.right);
        }
        return true;
    }
}

2022.10.23补