Question

我想创建一个10000个节点（实际上为100 * 100）的2d网格图，并在C中添加周期性条件。我不知道该怎么办？

之后，我想获取该图的邻接矩阵，而我对此一无所知。

我可以使用Networkx在python中轻松地完成这些操作。但是在C语言中我不知道该怎么做。请帮忙。

Answer 1

邻接矩阵

邻接矩阵是将图G = {V，E}表示为布尔矩阵的一种方式。

矩阵的大小为VxV，其中V是图形中的顶点数，而条目Aij的值为1或0，具体取决于从顶点i到顶点j是否有边。

在有向图的情况下，由于每个边（i，j），矩阵关于对角线对称，也有一个边（j，i）。

伪代码：

int Node,Edge;
int matrix[100][100];
scanf("%d%d",&Node,&Edge);
for(i=0;i<Edge;i++)
{
int n1,n2,cost;
scanf("%d%d%d",&n1,&n2,&cost);
matrix[n1][n2]=cost;
matrix[n2][n1]=cost;
}

邻接矩阵的

缺点

邻接矩阵的VxV空间要求使其成为一个存储猪。野外绘制的图通常没有太多的联系，这就是为什么邻接表是大多数任务的更好选择的主要原因。

虽然基本操作很容易，但是使用邻接矩阵表示法时，诸如inEdges和outEdges之类的操作很昂贵。

邻接表

邻接表将图表示为链接列表的数组。

数组的索引表示一个顶点，其链表中的每个元素表示与该顶点形成边的其他顶点。

伪代码：

#include <stdio.h>
#include <stdlib.h>

struct node
{
    int vertex;
    struct node* next;
};
struct node* createNode(int);

struct Graph
{
    int numVertices;
    struct node** adjLists;
};

struct Graph* createGraph(int vertices);
void addEdge(struct Graph* graph, int src, int dest);
void printGraph(struct Graph* graph);

int main()
{
    struct Graph* graph = createGraph(6);
    addEdge(graph, 0, 1);
    addEdge(graph, 0, 2);
    addEdge(graph, 1, 2);
    addEdge(graph, 1, 4);
    addEdge(graph, 1, 3);
    addEdge(graph, 2, 4);
    addEdge(graph, 3, 4);
    addEdge(graph, 4, 6);
    addEdge(graph, 5, 1);
    addEdge(graph, 5, 6);

    printGraph(graph);

    return 0;
}




    struct node* createNode(int v)
    {
        struct node* newNode = malloc(sizeof(struct node));
        newNode->vertex = v;
        newNode->next = NULL;
        return newNode;
    }


    struct Graph* createGraph(int vertices)
    {
        struct Graph* graph = malloc(sizeof(struct Graph));
        graph->numVertices = vertices;



    graph->adjLists = malloc(vertices * sizeof(struct node*));

    int i;
    for (i = 0; i < vertices; i++)
        graph->adjLists[i] = NULL;

    return graph;
}

void addEdge(struct Graph* graph, int src, int dest)
{
    // Add edge from src to dest
    struct node* newNode = createNode(dest);
    newNode->next = graph->adjLists[src];
    graph->adjLists[src] = newNode;

    // Add edge from dest to src
    newNode = createNode(src);
    newNode->next = graph->adjLists[dest];
    graph->adjLists[dest] = newNode;
}

void printGraph(struct Graph* graph)
{
    int v;
    for (v = 0; v < graph->numVertices; v++)
    {
        struct node* temp = graph->adjLists[v];
        printf("\n Adjacency list of vertex %d\n ", v);
        while (temp)
        {
            printf("%d -> ", temp->vertex);
            temp = temp->next;
        }
        printf("\n");
    }
}

使用Vector的邻接列表：

通过使用“向量”，您无需提及大小，仅需提及最大节点数即可。

输入：

6 8 //node-edge
1 2 //node1-node2
1 4
2 4
2 5
4 5
5 3
3 6
6 6

代码就是这样。

伪代码：

#include<cstdio>
#include<vector>
using namespace std;
#define MAX 100000 //maximum node
vector<int>edges[MAX];
vector<int>cost[MAX]; //parallel vector to store costs;
int main()
{
int N,E,i;

scanf("%d%d",&N,&E);
for(i=1;i<=E;i++)
{
int x,y;
scanf("%d%d",&x,&y);
edges[x].push_back(y);
edges[y].push_back(x);
cost[x].push_back(1);
cost[y].push_back(1);
}
return 0;
}

在C语言中实现2D网格网络（图）及其邻接矩阵。

1 个答案: