数据结构与算法：图的理论与应用_数据结构与算法图的应用-CSDN博客

数据结构与算法：图的理论与应用

图是一种强大的数据结构，用于表示各种复杂关系和连接。图在计算机科学中的应用十分广泛，例如社交网络分析、最短路径计算以及各种网络流问题。本章将重点介绍图的表示方法、遍历算法、拓扑排序及高级图算法，帮助我们更好地理解和应用图的理论。

8.1 图的表示

图可以通过多种方式来表示，不同的表示方法有着不同的优缺点，适用于不同的应用场景。

图的不同表示方法（邻接矩阵、邻接表、边集表）：

邻接矩阵：使用一个二维数组来表示图，其中 matrix[i][j] 表示顶点 i 和顶点 j 之间是否存在边。这种方法适合表示稠密图，因为它能够快速查找任意两点之间的连接关系。
邻接表：使用链表或数组列表来存储每个顶点的邻接点，更加节省空间，适用于稀疏图。邻接表在进行邻接节点遍历时比邻接矩阵高效。
边集表：用边的集合来表示图，特别适合于需要频繁遍历边的场景。

代码示例：邻接表的实现

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

#define MAX_VERTICES 5

struct Node {
    int vertex;
    struct Node* next;
};

struct Node* adjList[MAX_VERTICES];

void addEdge(int src, int dest) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->vertex = dest;
    newNode->next = adjList[src];
    adjList[src] = newNode;
}

void displayGraph() {
    for (int i = 0; i < MAX_VERTICES; i++) {
        struct Node* temp = adjList[i];
        printf("顶点 %d: ", i);
        while (temp) {
            printf("%d -> ", temp->vertex);
            temp = temp->next;
        }
        printf("NULL\n");
    }
}

int main() {
    addEdge(0, 1);
    addEdge(0, 4);
    addEdge(1, 2);
    addEdge(1, 3);
    addEdge(1, 4);
    addEdge(2, 3);
    addEdge(3, 4);

    displayGraph();
    return 0;
}

在上述代码中，使用邻接表表示了一个简单的无向图，每个顶点都维护一个邻接链表，从而有效地存储邻接信息。

稠密图与稀疏图的处理方法：稠密图和稀疏图在内存占用和访问性能方面有很大区别。对于稠密图，邻接矩阵更加高效，而对于稀疏图，邻接表能够更好地节省内存。

8.2 图的遍历算法

图的遍历是图论中的基础问题，用于访问图中的所有节点。常见的遍历方法包括深度优先搜索（DFS）和广度优先搜索（BFS）。

深度优先搜索（DFS）与广度优先搜索（BFS）：

DFS 采用递归或栈的方式访问图中的节点，优先深入到每一个分支。DFS 常用于路径查找和检测图的连通性。
BFS 使用队列逐层访问节点，适合查找最短路径。BFS 常用于无权图的最短路径查找以及分层遍历。

代码示例：DFS 与 BFS 的实现

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

#define MAX_VERTICES 5

struct Node {
    int vertex;
    struct Node* next;
};

struct Node* adjList[MAX_VERTICES];
bool visited[MAX_VERTICES];

void addEdge(int src, int dest) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->vertex = dest;
    newNode->next = adjList[src];
    adjList[src] = newNode;
}

void DFS(int vertex) {
    visited[vertex] = true;
    printf("访问顶点 %d\n", vertex);
    struct Node* temp = adjList[vertex];
    while (temp) {
        int connectedVertex = temp->vertex;
        if (!visited[connectedVertex]) {
            DFS(connectedVertex);
        }
        temp = temp->next;
    }
}

void BFS(int startVertex) {
    bool visited[MAX_VERTICES] = {false};
    int queue[MAX_VERTICES];
    int front = 0, rear = 0;

    visited[startVertex] = true;
    queue[rear++] = startVertex;

    while (front < rear) {
        int currentVertex = queue[front++];
        printf("访问顶点 %d\n", currentVertex);

        struct Node* temp = adjList[currentVertex];
        while (temp) {
            int connectedVertex = temp->vertex;
            if (!visited[connectedVertex]) {
                queue[rear++] = connectedVertex;
                visited[connectedVertex] = true;
            }
            temp = temp->next;
        }
    }
}

int main() {
    addEdge(0, 1);
    addEdge(0, 4);
    addEdge(1, 2);
    addEdge(1, 3);
    addEdge(1, 4);
    addEdge(2, 3);
    addEdge(3, 4);

    printf("深度优先搜索 (DFS):\n");
    for (int i = 0; i < MAX_VERTICES; i++) {
        visited[i] = false;
    }
    DFS(0);

    printf("\n广度优先搜索 (BFS):\n");
    BFS(0);

    return 0;
}

在上面的代码中，我们实现了图的 DFS 和 BFS 算法，通过递归实现 DFS，通过队列实现 BFS，从而逐层或逐路径访问图中的节点。

图的连通性分析与强连通分量求解：连通性分析用于判断图中节点之间的连接情况。在有向图中，强连通分量（SCC）是指从任意节点可以到达其他节点的最大子图。使用 Kosaraju 算法或 Tarjan 算法可以有效求解图的强连通分量。

8.3 拓扑排序与应用

拓扑排序是一种对有向无环图（DAG）进行排序的方法，使得每一条边 (u, v) 都满足顶点 u 先于顶点 v。拓扑排序常用于任务调度、依赖管理等场景。

拓扑排序的实现与复杂度分析：拓扑排序可以通过 DFS 或 Kahn 算法实现。

DFS 实现：通过对节点进行深度优先搜索，并在递归返回时将节点加入栈中，最终从栈中依次取出节点即可得到拓扑序列。
Kahn 算法：使用入度为零的节点开始遍历，将其删除并更新邻接节点的入度，直到所有节点被处理。

代码示例：Kahn 算法实现拓扑排序

#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTICES 5

int adjMatrix[MAX_VERTICES][MAX_VERTICES];
int inDegree[MAX_VERTICES];

void addEdge(int src, int dest) {
    adjMatrix[src][dest] = 1;
    inDegree[dest]++;
}

void topologicalSort() {
    int queue[MAX_VERTICES];
    int front = 0, rear = 0;
    for (int i = 0; i < MAX_VERTICES; i++) {
        if (inDegree[i] == 0) {
            queue[rear++] = i;
        }
    }
    while (front < rear) {
        int current = queue[front++];
        printf("%d ", current);
        for (int i = 0; i < MAX_VERTICES; i++) {
            if (adjMatrix[current][i] == 1) {
                inDegree[i]--;
                if (inDegree[i] == 0) {
                    queue[rear++] = i;
                }
            }
        }
    }
    printf("\n");
}

int main() {
    addEdge(0, 1);
    addEdge(0, 2);
    addEdge(1, 3);
    addEdge(2, 3);
    addEdge(3, 4);

    printf("拓扑排序结果: ");
    topologicalSort();
    return 0;
}

在这个代码示例中，使用 Kahn 算法对一个有向无环图进行拓扑排序，得到符合依赖关系的节点序列。