代码随想录算法训练营第十五天 | 二叉树层序遍历 & 翻转二叉树 & 对称二叉树

1. 二叉树层序遍历

102. 二叉树的层序遍历 - 力扣（LeetCode）

迭代

队列实现，size记录每层的元素个数

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        LinkedList<TreeNode> list = new LinkedList();
        if(root != null) list.offerLast(root);

        List<List<Integer>> res = new ArrayList<>();
        
        while(!list.isEmpty()){
            int size = list.size();
            List<Integer> temp = new ArrayList<>();
            while(size!=0){
                TreeNode target = list.pollFirst();
                temp.add(target.val);
                if(target.left != null) list.offerLast(target.left);
                if(target.right != null) list.offerLast(target.right);
                size--;
            }
            res.add(temp);
        }
        return res;
    }
}

递归

deep用来确保一层只加一个list

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

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

    public void addNode(TreeNode node, int deep){
        if(node == null) return;
        
        if(res.size() < deep)//第几层，有几个List
            res.add(new ArrayList<Integer>());

        res.get(deep-1).add(node.val);
        deep++;//下一层
        addNode(node.left, deep);
        addNode(node.right, deep);
    }

}

2. 翻转二叉树

226. 翻转二叉树 - 力扣（LeetCode）

前序：先将左右子树交换，再处理左右子树

后序：先处理左右子树，再将左右子树交换

中序：先处理左右子树，再交换左右子树，在处理现在的左子树（即原来的右子树）

递归实现

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

        swap(root);
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
    //后序
    public TreeNode invertTree(TreeNode root) {
        if(root == null) return root;

        invertTree(root.left);
        invertTree(root.right);
        swap(root);
        return root;
    }
    //中序
    public TreeNode invertTree(TreeNode root) {
        if(root == null) return root;

        invertTree(root.left);
        swap(root);
        invertTree(root.left);//注意
        return root;
    }


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

3. 对称二叉树

101. 对称二叉树 - 力扣（LeetCode）

递归

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

    public boolean isSymmetricChild(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 isSymmetricChild(left.right, right.left) && isSymmetricChild(left.left, right.right);
    }
}

迭代

入列的时候注意

外侧一起，内侧一起

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null) return true;
        LinkedList<TreeNode> queue = new LinkedList<>();

        queue.offer(root.left);
        queue.offer(root.right);
        while(!queue.isEmpty()){
            TreeNode left = queue.poll();
            TreeNode right = queue.poll();
            if(left == null && right == null) continue;
            if(left==null || right==null|| left.val != right.val) return false;

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