📜  使用邻接矩阵实现BFS

📅  最后修改于: 2021-10-25 03:07:22             🧑  作者: Mango

本文讨论了广度优先搜索 (BFS),它使用邻接表来表示图形。在本文中,将使用邻接矩阵来表示图。

邻接矩阵表示:在图的邻接矩阵表示中,大小为 n*n(其中 n 是顶点数)的矩阵mat[][]将表示图的边,其中mat[i][j] = 1表示顶点ij之间有边,而mat[i][j] = 0表示顶点ij之间没有边。

下面是上图所示图形的邻接矩阵表示:

0 1 2 3
0 0 1 1 0 
1 1 0 0 1 
2 1 0 0 0 
3 0 1 0 0

例子:

Input: source = 0

Output: 0 1 2 3

Input: source = 1

Output:1 0 2 3 4

方法:

  • 创建一个大小为 n*n 的矩阵,其中每个元素都是 0,表示图中没有边。
  • 现在,对于顶点 i 和 j 之间的图的每条边,设置 mat[i][j] = 1。
  • 创建并填充邻接矩阵后,按照本文所述找到图的 BFS 遍历。

下面是上述方法的实现:

C++
// C++ implementation of the approach
#include 
using namespace std;
 
class Graph {
 
    // Number of vertex
    int v;
 
    // Number of edges
    int e;
 
    // Adjacency matrix
    int** adj;
 
public:
    // To create the initial adjacency matrix
    Graph(int v, int e);
 
    // Function to insert a new edge
    void addEdge(int start, int e);
 
    // Function to display the BFS traversal
    void BFS(int start);
};
 
// Function to fill the empty adjacency matrix
Graph::Graph(int v, int e)
{
    this->v = v;
    this->e = e;
    adj = new int*[v];
    for (int row = 0; row < v; row++) {
        adj[row] = new int[v];
        for (int column = 0; column < v; column++) {
            adj[row][column] = 0;
        }
    }
}
 
// Function to add an edge to the graph
void Graph::addEdge(int start, int e)
{
 
    // Considering a bidirectional edge
    adj[start][e] = 1;
    adj[e][start] = 1;
}
 
// Function to perform BFS on the graph
void Graph::BFS(int start)
{
    // Visited vector to so that
    // a vertex is not visited more than once
    // Initializing the vector to false as no
    // vertex is visited at the beginning
    vector visited(v, false);
    vector q;
    q.push_back(start);
 
    // Set source as visited
    visited[start] = true;
 
    int vis;
    while (!q.empty()) {
        vis = q[0];
 
        // Print the current node
        cout << vis << " ";
        q.erase(q.begin());
 
        // For every adjacent vertex to the current vertex
        for (int i = 0; i < v; i++) {
            if (adj[vis][i] == 1 && (!visited[i])) {
 
                // Push the adjacent node to the queue
                q.push_back(i);
 
                // Set
                visited[i] = true;
            }
        }
    }
}
 
// Driver code
int main()
{
    int v = 5, e = 4;
 
    // Create the graph
    Graph G(v, e);
    G.addEdge(0, 1);
    G.addEdge(0, 2);
    G.addEdge(1, 3);
 
    G.BFS(0);
}


Java
// Java implementation of the approach
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
 
class GFG{
 
static class Graph
{
     
    // Number of vertex
    int v;
 
    // Number of edges
    int e;
 
    // Adjacency matrix
    int[][] adj;
 
    // Function to fill the empty
    // adjacency matrix
    Graph(int v, int e)
    {
        this.v = v;
        this.e = e;
         
        adj = new int[v][v];
        for(int row = 0; row < v; row++)
            Arrays.fill(adj[row], 0);
    }
     
    // Function to add an edge to the graph
    void addEdge(int start, int e)
    {
         
        // Considering a bidirectional edge
        adj[start][e] = 1;
        adj[e][start] = 1;
    }
 
    // Function to perform BFS on the graph
    void BFS(int start)
    {
         
        // Visited vector to so that
        // a vertex is not visited more than once
        // Initializing the vector to false as no
        // vertex is visited at the beginning
        boolean[] visited = new boolean[v];
        Arrays.fill(visited, false);
        List q = new ArrayList<>();
        q.add(start);
 
        // Set source as visited
        visited[start] = true;
 
        int vis;
        while (!q.isEmpty())
        {
            vis = q.get(0);
 
            // Print the current node
            System.out.print(vis + " ");
            q.remove(q.get(0));
 
            // For every adjacent vertex to
            // the current vertex
            for(int i = 0; i < v; i++)
            {
                if (adj[vis][i] == 1 && (!visited[i]))
                {
                     
                    // Push the adjacent node to
                    // the queue
                    q.add(i);
 
                    // Set
                    visited[i] = true;
                }
            }
        }
    }
}
 
// Driver code
public static void main(String[] args)
{
     
    int v = 5, e = 4;
 
    // Create the graph
    Graph G = new Graph(v, e);
    G.addEdge(0, 1);
    G.addEdge(0, 2);
    G.addEdge(1, 3);
 
    G.BFS(0);
}
}
 
// This code is contributed by sanjeev2552


Python3
# Python3 implementation of the approach
class Graph:
     
    adj = []
 
    # Function to fill empty adjacency matrix
    def __init__(self, v, e):
         
        self.v = v
        self.e = e
        Graph.adj = [[0 for i in range(v)]
                        for j in range(v)]
 
    # Function to add an edge to the graph
    def addEdge(self, start, e):
         
        # Considering a bidirectional edge
        Graph.adj[start][e] = 1
        Graph.adj[e][start] = 1
 
    # Function to perform DFS on the graph
    def BFS(self, start):
         
        # Visited vector to so that a
        # vertex is not visited more than
        # once Initializing the vector to
        # false as no vertex is visited at
        # the beginning
        visited = [False] * self.v
        q = [start]
 
        # Set source as visited
        visited[start] = True
 
        while q:
            vis = q[0]
 
            # Print current node
            print(vis, end = ' ')
            q.pop(0)
             
            # For every adjacent vertex to
            # the current vertex
            for i in range(self.v):
                if (Graph.adj[vis][i] == 1 and
                      (not visited[i])):
                           
                    # Push the adjacent node
                    # in the queue
                    q.append(i)
                     
                    # set
                    visited[i] = True
 
# Driver code
v, e = 5, 4
 
# Create the graph
G = Graph(v, e)
G.addEdge(0, 1)
G.addEdge(0, 2)
G.addEdge(1, 3)
 
# Perform BFS
G.BFS(0)
 
# This code is contributed by ng24_7


输出:
0 1 2 3

时间复杂度: O(N)
辅助空间: O(N)

如果您希望与专家一起参加现场课程,请参阅DSA 现场工作专业课程学生竞争性编程现场课程