BFS广度优先算法入门

BFS广度优先算法入门

简介

核心

BFS算法的核心就是把问题抽象成图，从一个点开始向四周扩散。一般来说，BFS的具体实现需要队列这种数据结构，将每个结点按照广度优先的顺序依次入队遍历。

缺点

相对于DFS，BFS的时间复杂度一样是O(n)，但是空间复杂度却要不DFS大得多。

BFS遍历二叉树演示

代码实现

层次遍历这个二叉树

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YQ3FFuz3-1654488576861)(C:\Users\jackonessalad\AppData\Roaming\Typora\typora-user-images\image-20220606113810730.png)]

Java

import java.util.LinkedList;
import java.util.Queue;

public class main {
    static bt bb;

    public static void main(String[] args) {
        init();
        Queue<bt> ql = new LinkedList();	// 队列声明
        ql.add(bb);	// 入队
        while (!ql.isEmpty()) {
            bt cur = ql.peek();	// 队首
            ql.poll();	// 出队
            System.out.print(cur.val + " ");
            if (cur.left != null)
                ql.add(cur.left);
            if (cur.right != null)
                ql.add(cur.right);
        }
    }
	// 生成二叉树
    static void init() {
        bt[] bbs = new bt[7];
        bb = new bt(1);
        for (int i = 0; i < 7; i++)
            bbs[i] = new bt(i + 2);
        bb.left = bbs[0];
        bb.right = bbs[1];
        bbs[0].left = bbs[2];
        bbs[1].left = bbs[3];
        bbs[1].right = bbs[4];
        bbs[3].left = bbs[5];
        bbs[3].right = bbs[6];
    }

}

class bt {
    int val;
    bt left, right;

    public bt(int val) {
        this.val = val;
    }

    bt(int val, bt left, bt right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}
// output: 1 2 3 4 5 6 7 8

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

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

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

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

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

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