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

Leetcode 102.二叉树的层序遍历

题目链接
思路：BFS广度优先遍历，借助队列
代码：

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new LinkedList<>();
        if (root == null) {
            return result;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            // 每一层的list
            List<Integer> itemList = new ArrayList<>();
            // size用来记录每一层的数量
            int size = queue.size();
            while (size-- > 0) {
                TreeNode node = queue.poll();
                itemList.add(node.val);

                if (node.left != null) {
                    queue.offer(node.left);
                }

                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(itemList);
        }
        return result;
    }
}

Leetcode 226.翻转二叉树

题目链接
思路：前中后序的递归，前中后序的迭代，前中后序的统一迭代，层序遍历都能实现。
代码：

class Solution {
    public TreeNode invertTree(TreeNode root) {
        // 递归法 前序遍历
        if (root == null) {
            return null;
        }
        swap(root);
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }

    private void swap(TreeNode root) {
        TreeNode tempNode = root.left;
        root.left = root.right;
        root.right = tempNode;
    }
}

Leetcode 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 compareOutside = compare(left.left, right.right);
        // 比较内侧
        boolean compareInside = compare(left.right, right.left);
        return compareOutside && compareInside;
    }
}