代码随想录算法训练营day15｜层序遍历（10），226.翻转二叉树，101.对称二叉树-CSDN博客

本文链接：https://blog.csdn.net/weixin_52121600/article/details/127768614

本文介绍了多种二叉树的层次遍历算法，包括常规的层次遍历、倒序遍历、获取每层最大值、计算每层平均值以及查找右视图。此外，还涉及到了填充每个节点的相邻节点指针问题和判断二叉树是否对称的算法，涵盖了递归和迭代两种方法。这些算法展示了如何利用队列进行层次遍历以及处理二叉树节点信息的关键技巧。

摘要由CSDN通过智能技术生成

层序遍历（10）

思路：

1.借助队列【队列先进先出，符合一层一层遍历的逻辑】；

2. 声明一个size，用来控制每次队列弹出的元素数量。

102. 二叉树的层序遍历

力扣

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root);
        while(!que.isEmpty()){
            LinkedList<Integer> item = new LinkedList<>();
            int len = que.size();
            while(len>0){
                TreeNode temp = que.poll();
                item.add(temp.val);
                if(temp.left!=null){
                    que.offer(temp.left);
                }
                if(temp.right!=null){
                    que.offer(temp.right);
                }
                len--;
            }
            res.add(item);
        }
        return res;
    }
}

107.二叉树的层次遍历II

力扣

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<TreeNode> que = new LinkedList<>();//队列
        que.offer(root);
        while(!que.isEmpty()){
            List<Integer> item = new ArrayList<>();//记录每一行的元素
            int len = que.size();
            while(len>0){
                TreeNode temp = que.poll();
                if(temp.left!=null){
                    que.offer(temp.left);
                }
                if(temp.right!=null){
                    que.offer(temp.right);
                }
                len--;
                item.add(temp.val);
            }
            res.add(item);
        }
        Collections.reverse(res);
        return res;
    }
}

199.二叉树的右视图

力扣

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root);
        while(!que.isEmpty()){
            int len = que.size();
            List<Integer> item = new ArrayList<>();
            for(int i = 0; i<len; i++){
                TreeNode temp = que.poll();
                item.add(temp.val);
                if(temp.right!=null){
                    que.offer(temp.right);
                }
                if(temp.left!=null){
                    que.offer(temp.left);
                }
            }
            res.add(item.get(0));
        }
        return res;
    }
}

637.二叉树的层平均值

力扣

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root);
        while(!que.isEmpty()){
            int len = que.size();
            double sum = 0;
            for(int i = 0; i<len; i++){
                TreeNode temp = que.poll();
                sum += temp.val;
                if(temp.left!=null){
                    que.offer(temp.left);
                }
                if(temp.right!=null){
                    que.offer(temp.right);
                }
            }
            res.add(sum/len);
        }
        return res;
    }
}

429.N叉树的层序遍历

力扣

注意对children的处理

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<Node> que = new LinkedList<>();
        que.offer(root);
        while(!que.isEmpty()){
            List<Integer> item = new LinkedList<>();
            int len = que.size();
            for(int i = 0; i<len; i++){
                Node temp = que.poll();
                item.add(temp.val);
                List<Node> children = temp.children;
                if(children==null||children.size()==0){
                    continue;
                }
                for(Node child:children){
                    que.offer(child);
                }
            }
            res.add(item);
        }
        return res;
    }
}

515.在每个树行中找最大值

力扣

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root);
        while(!que.isEmpty()){
            int max = -Integer.MIN_VALUE;
            int len = que.size();
            while(len>0){
                TreeNode temp = que.poll();
                max = Math.max(max,temp.val);
                if(temp.left!=null){
                    que.offer(temp.left);
                }
                if(temp.right!=null){
                    que.offer(temp.right);
                }
                len--;
            }
            res.add(max);
        }
        return res;
    }
}

116.填充每个节点的下一个右侧节点指针

力扣

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if(root != null){
            root.next= null;
            Queue<Node> que = new LinkedList<>();
            que.offer(root);
            while(!que.isEmpty()){
                int len = que.size();
                Node cur = que.poll();
                if(cur.left!=null){
                    que.offer(cur.left);
                }
                if(cur.right!=null){
                    que.offer(cur.right);
                }
                for(int i = 1; i<len; i++){
                    Node next = que.poll();
                    if(next.left!=null){
                        que.offer(next.left);
                    }
                    if(next.right!=null){
                        que.offer(next.right);
                    }
                    cur.next = next;
                    cur = next;
                }
            }
        }
        return root;
    }
}

117.填充每个节点的下一个右侧节点指针II

力扣

同116

104.二叉树的最大深度

力扣

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        int count = 0;
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root);
        while(!que.isEmpty()){
            int len = que.size();
            while(len>0){
                TreeNode temp = que.poll();
                if(temp.left!=null){
                    que.offer(temp.left);
                }
                if(temp.right!=null){
                    que.offer(temp.right);
                }
                len--;
            }
            count++;
        }
        return count;
    }
}

111.二叉树的最小深度

力扣

注意：只有当左右节点都为空时，才是遍历的最低点。只有一个孩子为空时不是最低点。

class Solution {
    public int minDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        int count = 0;
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root);
        while(!que.isEmpty()){
            int len = que.size();
            count++;
            while(len>0){
                TreeNode temp = que.poll();
                if(temp.left == null && temp.right == null){
                    return count;
                }
                if(temp.left!=null){
                    que.offer(temp.left);
                }
                if(temp.right!=null){
                    que.offer(temp.right);
                }
                len--;
            }
        }
        return count;
    }
}

226.翻转二叉树

力扣

//DFS递归
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return null;
        }
        invertTree(root.left);
        invertTree(root.right);
        swapChildren(root);
        return root;
    }
    private void swapChildren(TreeNode root){
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}

101.对称二叉树（2）

力扣

需要收集孩子的信息，向上一层返回的，都采用后序遍历。

//递归法
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;
    }
}

//迭代法【双端队列】
class solution{
    public boolean isSymmetric2(TreeNode root) {
        Deque<TreeNode> deque = new LinkedList<>();
        deque.offerFirst(root.left);
        deque.offerLast(root.right);
        while (!deque.isEmpty()) {
            TreeNode leftNode = deque.pollFirst();
            TreeNode rightNode = deque.pollLast();
            if (leftNode == null && rightNode == null) {
                continue;
            }
            if (leftNode == null || rightNode == null || leftNode.val != rightNode.val) {
                return false;
            }
            deque.offerFirst(leftNode.left);
            deque.offerFirst(leftNode.right);
            deque.offerLast(rightNode.right);
            deque.offerLast(rightNode.left);
        }
        return true;
    }
}

//迭代法【普通队列】
class solution{
    public boolean isSymmetric(TreeNode root) {
        Queue<TreeNode> deque = new LinkedList<>();
        deque.offer(root.left);
        deque.offer(root.right);
        while (!deque.isEmpty()) {
            TreeNode leftNode = deque.poll();
            TreeNode rightNode = deque.poll();
            if (leftNode == null && rightNode == null) {
                continue;
            }
            if (leftNode == null || rightNode == null || leftNode.val != rightNode.val) {
                return false;
            }
            deque.offer(leftNode.left);
            deque.offer(rightNode.right);
            deque.offer(leftNode.right);
            deque.offer(rightNode.left);
        }
        return true;
    }
}