队列 + 宽搜(BFS) 算法专题

层序遍历 == 宽搜 == BFS
利用队列这种数据结构来完成

一. N叉树的层序遍历

N叉树的层序遍历

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> retList = new ArrayList<>();
        if (root == null)
            return retList;
        Queue<Node> q = new LinkedList<>();
        q.offer(root);
        while (!q.isEmpty()) {
            int size = q.size();
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                Node cur = q.poll();

                list.add(cur.val);
                for (Node child : cur.children) {
                    if (child != null) {
                        q.offer(child);
                    }
                }
            }
            retList.add(list);
        }
        return retList;
    }
}

二. 二叉树的锯齿形层序遍历

二叉树的锯齿形层序遍历
用一个变量记录当前的层数, 如果是偶数层, 就先逆序在保存

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> retList = new ArrayList<>();
        if (root == null) {
            return retList;
        }
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        int tmp = 0;
        while (!q.isEmpty()) {
            int size = q.size();
            List<Integer> list = new ArrayList<>();
            tmp++;
            while (size > 0) {
                TreeNode cur = q.poll();
                list.add(cur.val);
                size--;
                if (cur.left != null) {
                    q.offer(cur.left);
                }
                if (cur.right != null) {
                    q.offer(cur.right);
                }
            }
            if (tmp % 2 == 0) {
                Collections.reverse(list);
            }
            retList.add(list);
        }
        return retList;
    }
}

三. 二叉树最大宽度

二叉树最大宽度
每一层的下标差 + 1, 就是宽度
用pair对应结点和下标

class Solution {
    public int widthOfBinaryTree(TreeNode root) {
        List<Pair<TreeNode, Integer>> queue = new ArrayList<>();
        queue.add(new Pair(root, 1));
        int ret = 0;
        while(!queue.isEmpty()){
            Pair<TreeNode, Integer> t1 = queue.get(0);
            Pair<TreeNode, Integer> t2 = queue.get(queue.size() - 1);
            ret = Math.max(t2.getValue() - t1.getValue() + 1, ret);
            List<Pair<TreeNode, Integer>> tmp = new ArrayList<>();
            for(Pair<TreeNode, Integer> x : queue){
                TreeNode node = x.getKey();
                int index = x.getValue();
                if(node.left != null){
                    tmp.add(new Pair(node.left, index * 2));
                }
                if(node.right != null){
                    tmp.add(new Pair(node.right, index * 2 + 1));
                }
            }
            queue = tmp;
        }
        return ret;
    }
}

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

在每个树行中找最大值

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

        return ret;
    }
}