数据结构之邻阶矩阵

邻阶矩阵是一种表示图形的矩阵。邻阶矩阵的原理是将图形中的每个顶点都表示成矩阵的一行或一列，然后用矩阵的元素表示两个顶点之间是否存在一条边。因此，在邻阶矩阵中，矩阵的大小为n×n（n为图形中点的数量），如果i、j两个顶点之间存在一条边，则邻阶矩阵中第i行第j列的元素值为1；如果没有，则该元素值为0。

邻阶矩阵的优点是可以快速地检测任意两个顶点之间是否有边相连。它还可以用于计算图形中的路径和环的数量。同时，邻阶矩阵也可以用于其他图形算法中，例如最小生成树算法、拓扑排序算法和Floyd算法等。

一、C 邻阶矩阵 源码实现及详解

邻接矩阵是一种表示图的数据结构，它用二维数组来表示节点之间的连接关系。在这种表示方法中，图中的每个顶点都被表示为矩阵中的一个行和一列，行和列之间的交点表示相应顶点之间的连接关系。

下面以 C 语言为例，给出邻接矩阵的源码实现及详解。

#include <stdio.h>

#define MAXV 100 // 最大顶点数

int graph[MAXV][MAXV]; // 邻接矩阵
int V, E; // 顶点数、边数

void init() {
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            graph[i][j] = 0; // 初始化邻接矩阵
        }
    }
}

void addEdge(int u, int v) {
    graph[u][v] = 1; // 添加边
}

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

int main() {
    scanf("%d %d", &V, &E); // 输入顶点数和边数
    init(); // 初始化邻接矩阵
    for (int i = 0; i < E; i++) {
        int u, v;
        scanf("%d %d", &u, &v); // 输入边的起点和终点
        addEdge(u, v); // 添加边到邻接矩阵
    }
    printGraph(); // 输出邻接矩阵
    return 0;
}

在上述代码中，我们使用了一个二维数组 graph 来表示邻接矩阵，其中 graph[i][j] 表示节点 i 和节点 j 之间是否有连接关系。 初始化邻接矩阵时，我们将所有元素初始化为 0。

在输入边时，我们使用一个 addEdge() 函数将节点 u 和节点 v 之间添加一条边，即将 graph[u][v] 的值设为 1。输出邻接矩阵时，我们使用一个 printGraph() 函数来遍历邻接矩阵，并输出矩阵中的每个元素。

二、C++ 邻阶矩阵 源码实现及详解

邻阶矩阵是图的一种表示方法，用一个二维数组来表示，其中数组的每个元素表示两个顶点之间的边是否存在。以下是使用 C++ 实现邻阶矩阵的代码及详细解释。

#include <iostream>
#include <vector>

using namespace std;

class Graph {
private:
    int V; // 图中的顶点数
    vector<vector<int>> adj; // 存储邻阶矩阵的二维数组

public:
    Graph(int V) {
        this->V = V;
        adj = vector<vector<int>>(V, vector<int>(V, 0)); // 初始化邻阶矩阵
    }

    // 添加一条无向边
    void addEdge(int u, int v) {
        adj[u][v] = adj[v][u] = 1;
    }

    // 打印邻阶矩阵
    void printMatrix() {
        for (int i = 0; i < V; i++) {
            for (int j = 0; j < V; j++) {
                cout << adj[i][j] << " ";
            }
            cout << endl;
        }
    }
};

int main() {
    Graph g(4);
    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(1, 2);
    g.addEdge(2, 3);
    g.printMatrix();
    return 0;
}

上述代码中，Graph 类中定义了一个私有变量 V，表示图中的顶点数，以及一个二维向量 adj，用来存储邻阶矩阵。构造函数中初始化邻阶矩阵为 V × V 的二维数组，所有元素的初始值都为 0。addEdge() 函数用于添加一条无向边，这里的无向边在邻阶矩阵中体现为对称的两个元素。printMatrix() 函数用于打印邻阶矩阵。

在主函数中，首先创建了一个包含 4 个顶点的图，然后添加了几条边，并最终打印出邻阶矩阵。

运行程序，可以得到以下输出结果：

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

三、python 邻阶矩阵 源码实现及详解

邻接矩阵是一种图形表示方法，用于表示图形的节点之间的关系和连接。在邻接矩阵中，每个节点被表示为矩阵中的一行或一列，其中每个元素表示从一个节点到另一个节点的连接关系。

下面是使用 Python 实现邻接矩阵的代码及详解：

class Graph:
    def __init__(self, vertices):
        self.vertices = vertices
        self.adj_matrix = [[0 for _ in range(vertices)] for _ in range(vertices)]

    def add_edge(self, u, v):
        self.adj_matrix[u][v] = 1
        self.adj_matrix[v][u] = 1

    def print_matrix(self):
        for row in self.adj_matrix:
            print(row)

代码解析：

1. Graph 类是用于创建和管理图形的主要类。
2. __init__ 方法创建一个邻接矩阵，其中 vertices 参数表示图形中的节点数。
3. add_edge 方法用于将两个节点连接起来。在邻接矩阵中，连接节点的方法是将矩阵中的相应元素设置为 1。
4. print_matrix 方法用于打印邻接矩阵。

下面是一个示例，该示例在邻接矩阵中表示以下图形：

  0---1
  |   |
  2---3---4

g = Graph(5)
g.add_edge(0, 1)
g.add_edge(0, 2)
g.add_edge(1, 3)
g.add_edge(2, 3)
g.add_edge(3, 4)

g.print_matrix()

输出结果：

[0, 1, 1, 0, 0]
[1, 0, 0, 1, 0]
[1, 0, 0, 1, 0]
[0, 1, 1, 0, 1]
[0, 0, 0, 1, 0]

在上面的示例中，我们首先创建了一个 Graph 对象，该对象包含 5 个节点。然后，我们使用 add_edge 方法将这五个节点连接起来。最后，我们使用 print_matrix 方法打印邻接矩阵。

从输出结果中可以看出，邻接矩阵中的每个元素都表示两个节点之间的连接关系。对于上面的图形，我们可以看到邻接矩阵中的第一行和第二列显示了节点 0 和节点 1 之间的连接关系，这是因为我们在 add_edge 方法中使用了 self.adj_matrix[u][v] = 1 来设置连接关系。同样，可以看到邻接矩阵中的第一列和第三列显示了节点 0 和节点 2 之间的连接关系，以此类推。