二叉树BFS层序遍历模板

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

    public List<List<Integer>> levelOrder(TreeNode root) {
        bfs(root);
        return res;
    }

    private void bfs(TreeNode node){
        if(node == null)return;

        Queue<TreeNode> q = new LinkedList<>();
        q.offer(node);

        while(!q.isEmpty()){
            List<Integer> item = new ArrayList<>();
            int len = q.size();

            while(len > 0){
                TreeNode temp = q.poll();
                item.add(temp.val);

                if(temp.left != null)q.offer(temp.left);
                if(temp.right != null)q.offer(temp.right);

                len--;
            }

            res.add(item);
        }
    }
}

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 temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}

迭代翻转：

class Solution {
    public TreeNode invertTree(TreeNode root) {
        Stack<TreeNode> stk = new Stack<>();
        if(root != null)stk.push(root);
        while(!stk.isEmpty()){
            TreeNode node = stk.peek();
            if(node != null){
                stk.pop(); // 避免重复操作
                
                if(node.right != null)stk.push(node.right);
                if(node.left != null)stk.push(node.left);
                stk.push(node);
                stk.push(null);
            }
            else{
                stk.pop(); // 弹出null标志位
                node = stk.pop(); // 取到栈顶元素

                swap(node); // 翻转处理
            }
        }
        return root;
    }

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

层次遍历翻转：

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null)return null;

        Deque<TreeNode> q = new LinkedList<>();
        q.add(root);
        while(!q.isEmpty()){
            int size = q.size();
            while(size-- > 0){
                TreeNode node = q.poll();
                swap(node);
                if(node.left != null)q.add(node.left);
                if(node.right != null)q.add(node.right);
            }
        }
        return root;
    }

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

101. 对称二叉树

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