算法专题十四：队列+宽搜

N叉树的层序遍历

429. N 叉树的层序遍历 - 力扣（LeetCode）

/*
// 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>> ret=new ArrayList<>();
        if(root==null){
            return ret;
        }
        Queue<Node> q=new LinkedList<>();
        q.add(root);
        while(!q.isEmpty()){
            int size=q.size();
            List<Integer> tmp=new ArrayList<>();
            for(int i=0;i<size;i++){
                Node t=q.poll();
                tmp.add(t.val);
                for(Node child:t.children){
                    if(child!=null){
                        q.add(child);
                    }
                }

            }
            ret.add(tmp);

        }
        return ret;

    }
}

二叉树的锯齿形层序遍历

103. 二叉树的锯齿形层序遍历 - 力扣（LeetCode）

在上一题的基础上将偶数行的结果进行反转后，在进行保存

/**
 * 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>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> ret=new ArrayList<>();
        if(root==null){
            return ret;
        }
        Queue<TreeNode> q=new LinkedList<>();
        int level=1;
        q.add(root);
        while(!q.isEmpty()){
            int size=q.size();
            List<Integer> tem=new ArrayList<>();
            for(int i=0;i<size;i++){
                TreeNode t=q.poll();
                tem.add(t.val);
                if(t.left!=null){
                    q.add(t.left);
                }
                if(t.right!=null){
                    q.add(t.right);
                }
                
            }
            if(level%2==0){
                    Collections.reverse(tem);
                }
                level++;
            ret.add(tem);
        }
        return ret;
    }
}
    

在每个树 行中找最大值

515. 在每个树行中找最大值 - 力扣（LeetCode）

/**
 * 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<Integer> largestValues(TreeNode root) {
        List<Integer> ret=new ArrayList<>();
        if(root==null){
            return ret;
        }
        Queue<TreeNode> q=new LinkedList<>();
        q.add(root);
        while(!q.isEmpty()){
            int tem=Integer.MIN_VALUE;
            int size=q.size();
            for(int i=0;i<size;i++){
                TreeNode t=q.poll();
                tem=Math.max(tem,t.val);
                if(t.left!=null){
                    q.add(t.left);
                }
                if(t.right!=null){
                    q.add(t.right);
                }
            }
            ret.add(tem);
        }
        return ret;
    }
}

二叉树的最大宽度（⭐）

662. 二叉树最大宽度 - 力扣（LeetCode）

/**
 * 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 int widthOfBinaryTree(TreeNode root) {
        // 数组模拟队列
        List<Pair<TreeNode,Integer>> q=new ArrayList<>();
        q.add((new Pair<TreeNode, Integer>(root, 1)));
        int ret = 0;
        while(!q.isEmpty()){
        // 先更新⼀下这⼀层的宽度
 
        Pair<TreeNode, Integer> t1 = q.get(0);
        Pair<TreeNode, Integer> t2 = q.get(q.size() - 1);
        ret = Math.max(ret, t2.getValue() - t1.getValue() + 1);
        // 让下⼀层进队
 
        List<Pair<TreeNode, Integer>> tmp = new ArrayList<>();
        for(Pair<TreeNode, Integer> t : q){
                TreeNode node = t.getKey();
                int index = t.getValue();
                if(node.left != null)
                {
                    tmp.add(new Pair<TreeNode, Integer>(node.left, index * 2));
                }
                if(node.right != null)
                {
                    tmp.add(new Pair<TreeNode, Integer>(node.right, index * 2 + 1));
                }
            }
            q = tmp;
        }
        return ret;
    }
 }