LeetCode--广度优先(BFS)--基础概念总结和经典题目解析汇总

目录

BFS代码模板

题目一：二叉树的层次遍历2

题目二：填充每个结点得下一个右侧结点指针

---

BFS代码模板

（一般Java中用队列，双端队列解决，python中用数组存储）

def BFS(graph,start,end):
    queue = []
    queue.append([start])
    visited.add(start)
    while queue:
        node = queue.pop()
        visited.add(node)
        process(node)
        nodes = generate_related_nodes(node)
        queue.push(nodes)
    #other processing work

题目一：二叉树的层次遍历2

（题目链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii/）

给定一个二叉树，返回其节点值自底向上的层序遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

例如：
给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回其自底向上的层序遍历为：

[
  [15,7],
  [9,20],
  [3]
]

思路：对于二叉树的层次遍历，使用经典的BFS搜索

注意：int size = queue.size();
            for(int i=0;i<size;i++)

千万不能写为for(int i =0;i<queue.size();i++) 因为for循环中queue.size()一直在变化

最后搜索完，逆序输出结果即可

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        List<List<Integer>> res2 = new ArrayList<List<Integer>>();
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        if(root == null){
            return res2;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            List<Integer> curr_level = new ArrayList<Integer>();
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode tempnode = queue.poll();
                curr_level.add(tempnode.val);
                if(tempnode.left!=null){
                    queue.offer(tempnode.left);
                }
                if(tempnode.right!=null){
                    queue.offer(tempnode.right);
                }
            }
            res.add(new ArrayList<Integer>(curr_level));
        }
        for(int i = res.size()-1;i>=0;i--){
            res2.add(res.get(i));
        }
        return  res2;
    }
}

题目二：填充每个结点得下一个右侧结点指针

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

样例：

思路：还是使用二叉树层次遍历得方法，先使用队列得到每一层得结点，

使用queue.poll()一个一个得到每一层结点，再使用queue.peek()把每一层结点串起来

// 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) {
        Queue<Node> queue = new LinkedList<Node>();
        if(root == null){
            return root;
        }
        queue.add(root);
        while(!queue.isEmpty()){
            int levelsize = queue.size(); 
            for(int i =0;i<levelsize;i++){
                Node temp = queue.poll();
                if (i < levelsize - 1) {
                    temp.next = queue.peek();
                }
                if(temp.left !=null){
                    queue.add(temp.left);
                }
                if(temp.right !=null){
                    queue.add(temp.right);
                }   
            }
          
        }
        return root;
    }
}