代码随想录day15 |二叉树的层序遍历. 翻转二叉树. 对称二叉树

二叉树的层序遍历

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

分析 用队列先进先出的特性, 将左右节点offer, 记录每层长度 

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new LinkedList<>();

        if(root==null)  return res;

        int len;
        Queue<TreeNode> queue= new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            len=queue.size();
            List<Integer> l = new ArrayList<>();
            while(len-->0){
                TreeNode temp = queue.poll();
                l.add(temp.val);
                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null) queue.offer(temp.right);
            }

            res.add(l);
        }

        return res;
    }
}

翻转二叉树

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

分析 递归法 基本和遍历一致  迭代法 也基本和遍历一致, 将遍历中的add操作 改为swap

class Solution {
    public TreeNode invertTree(TreeNode root) {
        Deque<TreeNode> deque = new LinkedList<>();
        if(root==null) return root;

        deque.offer(root);
        while(!deque.isEmpty()){
            TreeNode temp = deque.pollLast();
            swap(temp);
            if(temp.right!=null) deque.offer(temp.right);
            if(temp.left!=null) deque.offer(temp.left);
        }

        return root;
    }

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

对称二叉树

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

分析 用队列 维护每层节点 (跟层序遍历类似)  判断是否相等时 先判断是否都为空  再判断是否有空  最后判断是否值相等

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

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