读入数据，创建无向图的邻接矩阵

好的，邻接矩阵是一种表示图形的方法，它是一个二维数组，其中每个元素表示两个顶点之间是否存在边。如果存在边，则元素的值为1，否则为0。下面是一个简单的示例代码，用于读取图形数据并创建邻接矩阵：

# 读取数据
n, m = map(int, input().split()) # n表示节点数，m表示边数
edges = [] # 存储边的列表
for i in range(m):
    u, v = map(int, input().split()) # 读取一条边
    edges.append((u, v))

# 创建邻接矩阵
adj_matrix = [[0] * n for i in range(n)] # 初始化邻接矩阵
for u, v in edges:
    adj_matrix[u][v] = 1 # u到v有边
    adj_matrix[v][u] = 1 # v到u也有边，因为是无向图

这段代码首先读取节点数和边数，然后读取每条边，并将它们存储在一个列表中。接下来，我们创建一个初始值为0的二维数组，表示没有边。最后，我们遍历边列表，将每条边的两个端点之间的邻接矩阵元素设置为1，表示它们之间有边。由于是无向图，因此我们还需要反向设置邻接矩阵元素，以便正确表示双向关系。

相关问题

c语言代码建立一个无向图，输出其邻接矩阵并输出输出深度遍历结果，无向图邻接矩阵如下

好的，下面是用 C 语言实现建立一个无向图，输出其邻接矩阵并输出深度遍历结果的代码，假设邻接矩阵如下：

0 1 1 1 0
1 0 1 0 1
1 1 0 1 0
1 0 1 0 1
0 1 0 1 0

#include <stdio.h>
#include <stdbool.h>

#define MAX_VERTICES 100

int n; // 图的节点数
int graph[MAX_VERTICES][MAX_VERTICES]; // 存储图的邻接矩阵
bool visited[MAX_VERTICES]; // 标记节点是否被访问过

// 深度优先搜索
void dfs(int v) {
    printf("%d ", v);
    visited[v] = true;
    for (int i = 0; i < n; i++) {
        if (graph[v][i] && !visited[i]) {
            dfs(i);
        }
    }
}

int main() {
    // 读入图的节点数
    scanf("%d", &n);

    // 读入图的邻接矩阵
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &graph[i][j]);
        }
    }

    // 输出邻接矩阵
    printf("邻接矩阵：\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", graph[i][j]);
        }
        printf("\n");
    }

    // 深度遍历
    printf("深度遍历结果：");
    for (int i = 0; i < n; i++) {
        visited[i] = false;
    }
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            dfs(i);
        }
    }
    printf("\n");

    return 0;
}

输出结果如下：

邻接矩阵：
0 1 1 1 0 
1 0 1 0 1 
1 1 0 1 0 
1 0 1 0 1 
0 1 0 1 0 
深度遍历结果：0 1 2 3 4

希望这个代码能够帮助你解决问题，如果还有其他问题，请随时问我。

无向图邻接矩阵深度优先遍历

好的，我可以为您解答这个问题。

无向图的邻接矩阵表示法可以用一个二维数组来表示，其中矩阵的行列数都等于图的顶点数，矩阵中的元素表示两个顶点之间是否有边相连，通常用 0 或 1 来表示。

深度优先遍历（Depth First Search，DFS）是一种常用的图遍历算法，主要思想是从某个顶点开始，沿着一条路径遍历直到不能继续为止，然后返回到前一级顶点，继续沿着另一条路径遍历，直到所有的顶点都被访问过。

无向图邻接矩阵深度优先遍历的步骤如下：

1. 访问起始顶点，并将其标记为已访问；
2. 从起始顶点出发，依次遍历它的邻接点；
3. 对于每个邻接点，如果它未被访问，则递归访问它，并将其标记为已访问；
4. 重复步骤 2 和步骤 3，直到所有顶点都被访问过。

具体实现可以参考以下代码：

#include <iostream>
#include <cstring>
using namespace std;

const int MAXN = 100;

int n; // 顶点数
int G[MAXN][MAXN]; // 邻接矩阵
bool visited[MAXN]; // 标记数组

void dfs(int v) {
    visited[v] = true; // 标记当前顶点已访问
    cout << v << " "; // 输出当前顶点

    for (int i = 0; i < n; i++) {
        if (G[v][i] && !visited[i]) { // 如果有边相连且未访问过
            dfs(i); // 递归访问邻接点
        }
    }
}

int main() {
    memset(G, 0, sizeof(G)); // 初始化邻接矩阵
    memset(visited, false, sizeof(visited)); // 初始化标记数组

    // 读入无向图的顶点数和边数
    int m;
    cin >> n >> m;

    // 读入边的信息，建立邻接矩阵
    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;
        G[u][v] = G[v][u] = 1; // 无向图的边是双向的
    }

    // 从顶点 0 开始深度优先遍历
    dfs(0);

    return 0;
}

以上代码实现了无向图邻接矩阵深度优先遍历，并输出了遍历结果。