c语言,以邻接矩阵形式创建一个无向图的算法分析
时间: 2023-12-06 14:40:40 浏览: 121
创建一个无向图的邻接矩阵的算法如下:
1. 首先,需要定义一个二维数组来表示邻接矩阵,假设该数组名为adj_matrix。
2. 然后,需要输入图的顶点数n和边数m。
3. 接下来,需要初始化邻接矩阵,将其中所有元素都置为0。
4. 读入每一条边的信息,包括边的起点和终点。
5. 对于每一条边,将其对应的邻接矩阵中的元素设为1,表示该边存在。
6. 最后,输出邻接矩阵adj_matrix。
算法分析:
时间复杂度为O(n^2),因为需要初始化整个邻接矩阵,并且需要遍历所有的边。空间复杂度为O(n^2),因为需要存储整个邻接矩阵。这种方法适用于边数比较少的情况,对于边数很大的图,邻接矩阵会变得非常稀疏,造成空间浪费。此时,可以考虑使用邻接表来表示图。
相关问题
用c语言以邻接矩阵形式创建一个无向图并 以邻接表的形式创建一个无向图。
创建无向图邻接矩阵的C语言代码:
```c
#include <stdio.h>
#define MAXV 100 // 最大顶点数
typedef struct {
int matrix[MAXV][MAXV]; // 邻接矩阵
int num_v; // 顶点数
} Graph;
void init(Graph *G, int num_v) {
G->num_v = num_v;
for (int i = 0; i < num_v; i++) {
for (int j = 0; j < num_v; j++) {
G->matrix[i][j] = 0; // 初始化为0
}
}
}
void addEdge(Graph *G, int u, int v) {
G->matrix[u][v] = 1;
G->matrix[v][u] = 1; // 无向图,所以需要反向再赋值一次
}
void printGraph(Graph *G) {
for (int i = 0; i < G->num_v; i++) {
printf("%d: ", i);
for (int j = 0; j < G->num_v; j++) {
if (G->matrix[i][j]) {
printf("%d ", j);
}
}
printf("\n");
}
}
int main() {
Graph G;
int num_v = 5;
init(&G, num_v);
addEdge(&G, 0, 1);
addEdge(&G, 0, 4);
addEdge(&G, 1, 2);
addEdge(&G, 1, 3);
addEdge(&G, 1, 4);
addEdge(&G, 2, 3);
addEdge(&G, 3, 4);
printGraph(&G);
return 0;
}
```
创建无向图邻接表的C语言代码:
```c
#include <stdio.h>
#include <stdlib.h>
typedef struct node {
int v; // 该边所连向的顶点
struct node *next; // 指向下一条边的指针
} EdgeNode;
typedef struct vnode {
int data; // 顶点信息
EdgeNode *first_edge; // 指向第一条依附于该顶点的边的指针
} VertexNode;
typedef struct {
VertexNode adj_list[100]; // 邻接表,最多100个顶点
int num_v, num_e; // 顶点数和边数
} Graph;
void init(Graph *G, int num_v) {
G->num_v = num_v;
G->num_e = 0;
for (int i = 0; i < num_v; i++) {
G->adj_list[i].data = i;
G->adj_list[i].first_edge = NULL;
}
}
void addEdge(Graph *G, int u, int v) {
EdgeNode *e = (EdgeNode *) malloc(sizeof(EdgeNode));
e->v = v;
e->next = G->adj_list[u].first_edge;
G->adj_list[u].first_edge = e;
e = (EdgeNode *) malloc(sizeof(EdgeNode));
e->v = u;
e->next = G->adj_list[v].first_edge;
G->adj_list[v].first_edge = e;
G->num_e++;
}
void printGraph(Graph *G) {
for (int i = 0; i < G->num_v; i++) {
printf("%d: ", G->adj_list[i].data);
EdgeNode *e = G->adj_list[i].first_edge;
while (e != NULL) {
printf("%d ", e->v);
e = e->next;
}
printf("\n");
}
}
int main() {
Graph G;
int num_v = 5;
init(&G, num_v);
addEdge(&G, 0, 1);
addEdge(&G, 0, 4);
addEdge(&G, 1, 2);
addEdge(&G, 1, 3);
addEdge(&G, 1, 4);
addEdge(&G, 2, 3);
addEdge(&G, 3, 4);
printGraph(&G);
return 0;
}
```
c语言以邻接矩阵的形式创建一个无向图算法分析
创建无向图的邻接矩阵需要先确定图的顶点数和边数。假设图的顶点数为n,边数为m,则无向图的邻接矩阵是一个n*n的方阵,其中每个元素a[i][j]表示顶点i和j之间是否有边相连。
算法步骤如下:
1. 定义一个n*n的二维数组adjMatrix,初始化所有元素为0。
2. 读入图中所有的边信息,对于每条边(u,v),将adjMatrix[u][v]和adjMatrix[v][u]都设为1。
3. 遍历邻接矩阵adjMatrix,可以输出图的邻接矩阵或者进行其他算法操作。
下面是一个C语言实现的示例代码:
```c
#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTEX_NUM 100
int adjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 邻接矩阵
int n, m; // 顶点数和边数
void createGraph()
{
int i, u, v;
printf("请输入顶点数和边数:");
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
printf("请输入第%d条边的两个顶点:", i);
scanf("%d%d", &u, &v);
adjMatrix[u][v] = 1;
adjMatrix[v][u] = 1; // 无向图需要将两个方向都赋值
}
}
void printGraph()
{
int i, j;
printf("图的邻接矩阵为:\n");
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
printf("%d ", adjMatrix[i][j]);
}
printf("\n");
}
}
int main()
{
createGraph(); // 创建无向图
printGraph(); // 输出邻接矩阵
return 0;
}
```
该代码读入图的顶点数和边数,然后读入每条边的两个顶点,将邻接矩阵对应元素设为1,最后输出邻接矩阵。
阅读全文
相关推荐
















