【剑指offer】队列+BFS+二叉树三道典型例题

【剑指offer】队列+BFS+二叉树三道典型例题

简单介绍一下BFS

其过程简单来说是对每一层节点依次访问，访问完一层进入下一层，而且每个节点只能访问一次。

对于上面的例子，BFS的结果就是A,B,C,D,E,F,G,H,I(假设每层节点从左到右访问)。

广度优先遍历各个节点，需要使用队列(Queue)这种数据结构，其特点是先进先出。也可以使用双端队列，区别就是双端队列首尾都可以插入和弹出节点。整个遍历过程如下：

1）首先将A节点插入队列中，queue(A)；

2）将A节点弹出，同时将A的子结点B、C插入队列中，此时B在队列首部，C在队列尾部，queue(B，C)；

3）将B节点弹出，同时将B的子结点D、E插入队列中，此时C在队列首部，E在队列尾部，queue(C，D，E)；

4）将C节点弹出，同时将C的子节点F，G，H插入队列中，此时D在队列首部，H在队列尾部，queue(D，E，F，G，H)；

5）将D节点弹出，D没有子节点，此时E在队列首部，H在队列尾部，queue(E，F，G，H)；

…依次往下，最终遍历完成。

BFS模板代码

void bfs(TreeNode root) {
     
    Queue<TreeNode> queue = new LinkedList<>();
    queue.add(root);
    while (!queue.isEmpty()) {
     
        TreeNode node = queue.poll(); 
        if (node.left != null) {
     //左节点不空就入队
            queue.add(node.left);
        }
        if (node.right != null) {
     //右节点不空就入队
            queue.add(node.right);
        }
    }
}

剑指 Offer II 045. 二叉树最底层最左边的值

由题意知，需要按层遍历，得到最后一层最左侧节点的值，所以可以利用BFS来层序遍历这棵二叉树。不过，仅仅利用BFS不能判断哪个节点才是最左侧的节点，所以要加一些判断。要遍历某一层时，获取此时队列的size，此时size的大小即为该层节点的个数，然后利用for循环限制遍历次数，第一次遍历到的节点即为该层最左侧节点。

public int findBottomLeftValue(TreeNode root) {
     
        Queue<TreeNode> q=new LinkedList<>();//利用队列来BFS
        int ret=0;
        q.offer(root);//根节点入队
        while(q.size()!=0){
     //队列不空时执行循环
            int size=q.size();//获取当前队列元素个数，队列元素个数即为要遍历的某层的节点个数
            for(int i=0;i<size;i++){
     //利用for循环来遍历该层，i=0时，遍历到的节点即为该层最左侧节点
                TreeNode t=q.poll();//每次出队一个节点
                if(i==0) ret=t.val;//i==0时，该节点为最左侧节点
                if(t.left!=null) q.offer(t.left);//左右节点不为空就入队
                if(t.right!=null) q.offer(t.right);
            }
        }
    //出循环时，ret保存的即为最后一层最左侧节点的值。
        return ret;
}

剑指 Offer II 044. 二叉树每层的最大值

整体思路和上一题几乎相等，只是在外层循环定义一个变量用于更新每一层的最大值；

class Solution {
     
    public List<Integer> largestValues(TreeNode root) {
     
        Queue<TreeNode> q=new LinkedList<>();
        List<Integer> list=new ArrayList<>();
        if(root==null) return list;
        q.offer(root);
        while(q.size()!=0){
     
            int size=q.size();
            int max=Integer.MIN_VALUE;//定义max用来更新每层最大值
            for(int i=0;i<size;i++){
     
                TreeNode t=q.poll();
                if(max<t.val) max=t.val;
                if(t.left!=null) q.offer(t.left);
                if(t.right!=null) q.offer(t.right);
            }
            list.add(max);  
        }
        return list;
    }
}

剑指 Offer II 046. 二叉树的右侧视图

同样使用BFS层序遍历这课二叉树，当遍历到每层最后一个节点是，把这个节点加入List；

class Solution {
     
    public List<Integer> rightSideView(TreeNode root) {
     
        Queue<TreeNode> q=new LinkedList<>();
        List<Integer> list=new ArrayList<>();
        if(root==null) return list;
        q.offer(root);
        while(q.size()!=0){
     
            int size=q.size();
            for(int i=0;i<size;i++){
     
                TreeNode t=q.poll();
                if(i==size-1){
     //当i=size-1时 遍历到了每层的最后一个节点
                    list.add(t.val);
                }
                if(t.left!=null) q.offer(t.left);
                if(t.right!=null) q.offer(t.right);
            }
        }
        return list;
    }
}

BFS在解决层序遍历时非常有用，对于BFS的实现过程要多加理解，尤其理解为什么要使用队列来辅助进行BFS；