邻接矩阵和邻接表的转换

邻接矩阵和邻接表

邻接矩阵

邻接矩阵 使用 二维数组来表示图结构。 邻接矩阵是从节点的角度来表示图，有多少节点就申请多大的二维数组。

比如我们会有n 个节点，因为节点标号是从1开始的，为了节点标号和下标对齐，我们申请 n + 1 * n + 1 这么大的二维数组。

vector<vector<int>> graph(n + 1, vector<int>(n + 1, 0));

输入m个边，构造方式如下：

while (m--) {
    cin >> s >> t;
    // 使用邻接矩阵 ，1 表示 节点s 指向 节点t
    graph[s][t] = 1;
}

#邻接表
邻接表 使用 数组 + 链表的方式来表示。 邻接表是从边的数量来表示图，有多少边 才会申请对应大小的链表。
举个例子：

这里表达的图是：

节点1 指向 节点3 和 节点5
节点2 指向 节点4、节点3、节点5
节点3 指向 节点4
节点4指向节点1

我们需要构造一个数组，数组里的元素是一个链表。

// 节点编号从1到n，所以申请 n+1 这么大的数组
vector<list<int>> graph(n + 1); // 邻接表，list为C++里的链表

输入m个边，构造方式如下：

while (m--) {
    cin >> s >> t;
    // 使用邻接表 ，表示 s -> t 是相连的
    graph[s].push_back(t);
}

以题目为例讲解如何转换邻接矩阵和邻接表：

105. 有向图的完全可达性

给定一个有向图，包含 N 个节点，节点编号分别为 1，2，…，N。现从 1 号节点开始，如果可以从 1 号节点的边可以到达任何节点，则输出 1，否则输出 -1。

输入描述
第一行包含两个正整数，表示节点数量 N 和边的数量 K。 后续 K 行，每行两个正整数 s 和 t，表示从 s 节点有一条边单向连接到 t 节点。

输出描述
如果可以从 1 号节点的边可以到达任何节点，则输出 1，否则输出 -1。

输入示例
4 4
1 2
2 1
1 3
2 4

输出示例
1
提示信息

从 1 号节点可以到达任意节点，输出 1。

数据范围：

• 1 <= N <= 100；
• 1 <= K <= 2000。

---

转换：

邻接矩阵

邻接矩阵存储图

//  邻接矩阵存储图
int n, k, s, t;
cin >> n >> k;
vector<vector<int>> graph(n + 1, vector<int>(n + 1, 0));

while(k--){
    cin >> s >> t;
    graph[s][t] = 1;
}

邻接矩阵进行广搜

while(!que.empty()){
    int cur = que.front(); que.pop();
    
    for(int i = 1; i < graph.size(); i++){
        if(graph[cur][i] && !visited[i]){
            que.push(i);
            visited[i] = true;
        }
    }
}

邻接表存储图

//  邻接表存储图
int n, k, s, t;
cin >> n >> k;

vector<list<int>> graph(n + 1);
while (m--) {
    cin >> s >> t;
    graph[s].push_back(t);
}

邻接表进行广搜

while (!que.empty()) {
    int cur = que.front(); que.pop();
    // 遍历当前节点的所有邻居
    for (int neighbor : graph[cur]) {
        if (!visited[neighbor]) {
            que.push(neighbor);
            visited[neighbor] = true;
        }
    }
}

---

代码：

邻接矩阵

#include<iostream>
#include<vector>
#include<queue>
 
using namespace std;

//  广度优先搜索
void bfs(const vector<vector<int>>& graph, vector<bool>& visited, int x){
    queue<int> que;
    que.push(x);
    visited[x] = true;
     
    while(!que.empty()){
        int cur = que.front(); que.pop();
         
        for(int i = 1; i < graph.size(); i++){
            if(graph[cur][i] && !visited[i]){
                que.push(i);
                visited[i] = true;
            }
        }
    }
}

int main(){
     
    //  邻接矩阵存储图
    int n, k, s, t;
     
    cin >> n >> k;
     
    vector<vector<int>> graph(n + 1, vector<int>(n + 1, 0));
     
    while(k--){
        cin >> s >> t;
        graph[s][t] = 1;
    }
     
    vector<bool> visited(n + 1, false);
     
    bfs(graph, visited, 1);
     
    //  如果有的点仍然未被访问，则表明从1号节点不可以到达任何节点
    for(int i = 1; i <= n; i++){
        if(visited[i] == false){
            cout << -1 << endl;
            return 0;
        } 
    }
     
    cout << 1 << endl;
     
    return 0;
}

邻接表

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

// 广度优先搜索
void bfs(const vector<vector<int>>& graph, vector<bool>& visited, int start) {
    queue<int> que;
    que.push(start);
    visited[start] = true;

    while (!que.empty()) {
        int cur = que.front(); que.pop();

        // 遍历当前节点的所有邻居
        for (int neighbor : graph[cur]) {
            if (!visited[neighbor]) {
                que.push(neighbor);
                visited[neighbor] = true;
            }
        }
    }
}

int main() {
    int n, k, s, t;

    cin >> n >> k;

    // 邻接表存储图
    vector<vector<int>> graph(n + 1);

    // 读取边的信息并填充邻接表
    while (k--) {
        cin >> s >> t;
        graph[s].push_back(t); // 添加从 s 到 t 的边
    }

    // 初始化访问标记数组
    vector<bool> visited(n + 1, false);

    // 从节点 1 开始 BFS
    bfs(graph, visited, 1);

    // 检查是否所有节点都被访问
    for (int i = 1; i <= n; i++) {
        if (!visited[i]) {
            cout << -1 << endl;
            return 0;
        }
    }

    cout << 1 << endl;
    return 0;
}

---

总结：

邻接矩阵和邻接表都要掌握

---

参考：

代码随想录