第六章-图

图（Graph）是由节点（Vertex）和边（Edge）组成的非线性数据结构。图用于表示对象之间的关系，其中节点表示对象，边表示对象之间的连接或关联。图可以用于解决许多实际问题，如网络路由、社交网络分析等。

图的存储结构：
图的存储结构有两种主要形式：邻接矩阵和邻接表。

1. 邻接矩阵（Adjacency Matrix）：
   邻接矩阵是一个二维数组，其中行和列表示图中的节点，矩阵的元素表示节点之间的连接关系。如果节点 i 和节点 j 之间存在边，则矩阵中的元素 matrix[i][j]（或 matrix[j][i]）为 1 或具体的权重值。如果节点 i 和节点 j 之间不存在边，则矩阵中的元素为 0。邻接矩阵适用于稠密图（边数接近节点数的平方）。

2. 邻接表（Adjacency List）：
   邻接表是一种链表的数组，数组的每个元素表示图中的一个节点。每个节点对应一个链表，链表中存储了该节点与其他节点之间的边。邻接表适用于稀疏图（边数远小于节点数的平方）。

图的遍历算法：
图的遍历算法用于按照一定规则访问图中的所有节点。常见的图遍历算法有深度优先搜索（DFS）和广度优先搜索（BFS）。

1. 深度优先搜索（Depth-First Search，DFS）：
   DFS 从起始节点开始，沿着一条路径尽可能深入地访问节点，直到无法继续深入为止，然后回溯到前一个节点，继续探索其他路径。DFS 使用栈来保存待访问的节点。

2. 广度优先搜索（Breadth-First Search，BFS）：
   BFS 从起始节点开始，逐层地访问节点，先访问起始节点的所有邻居节点，然后再逐层访问邻居节点的邻居节点。BFS 使用队列来保存待访问的节点。

最短路径算法：
最短路径算法用于找到图中两个节点之间的最短路径。其中最常用的算法是迪杰斯特拉算法（Dijkstra's Algorithm）和贝尔曼-福特算法（Bellman-Ford Algorithm）。

1. 迪杰斯特拉算法：
   迪杰斯特拉算法用于解决单源最短路径问题，即找到一个节点到其他所有节点的最短路径。算法使用贪心策略，逐步确定起始节点到其他节点的最短路径。迪杰斯特拉算法适用于非负权重的图。

2. 贝尔曼-福特算法：
   贝尔曼-福特算法用于解决单源最短路径问题，与迪杰斯特拉算法不同，贝尔曼-福特算法可以处理带有负权重的图。算法通过多次松弛操作逐步更新节点之间的最短路径。

最小生成树算法：
最小生成树算法用于在连通图中找到一个生成树，使得生成树中的所有边的权重之和最小。其中最常用的算法是普里姆算法（Prim's Algorithm）和克鲁斯卡尔算法（Kruskal's Algorithm）。

1. 普里姆算法：
   普里姆算法从一个起始节点开始，逐步选择与当前生成树连接的权重最小的边，并将其加入生成树中，直到生成树包含图中的所有节点。

2. 克鲁斯卡尔算法：
   克鲁斯卡尔算法将图中的所有边按照权重从小到大进行排序，然后逐个添加边到生成树中，如果添加边不会形成环路，则将其加入生成树中。

以上是关于图的存储结构、遍历算法、最短路径算法和最小生成树算法的简要介绍。实现这些算法的代码可以根据具体的编程语言进行编写，可以使用邻接矩阵或邻接表表示图，并结合栈、队列等数据结构来实现遍历和算法操作。具体的代码实现可以参考相关的算法教材或在线资源。

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

#define MAX_NODES 100

// 邻接表中的边节点
typedef struct EdgeNode {
    int dest;
    int weight;
    struct EdgeNode* next;
} EdgeNode;

// 邻接表中的顶点节点
typedef struct VertexNode {
    EdgeNode* head;
} VertexNode;

// 图结构
typedef struct Graph {
    VertexNode vertices[MAX_NODES];
    int numNodes;
} Graph;

// 创建新的边节点
EdgeNode* createEdgeNode(int dest, int weight) {
    EdgeNode* newNode = (EdgeNode*)malloc(sizeof(EdgeNode));
    newNode->dest = dest;
    newNode->weight = weight;
    newNode->next = NULL;
    return newNode;
}

// 添加边
void addEdge(Graph* graph, int src, int dest, int weight) {
    EdgeNode* newEdge = createEdgeNode(dest, weight);
    newEdge->next = graph->vertices[src].head;
    graph->vertices[src].head = newEdge;

    newEdge = createEdgeNode(src, weight);
    newEdge->next = graph->vertices[dest].head;
    graph->vertices[dest].head = newEdge;
}

// 深度优先搜索
void DFS(Graph* graph, int node, bool visited[]) {
    visited[node] = true;
    printf("%d ", node);

    EdgeNode* edge = graph->vertices[node].head;
    while (edge != NULL) {
        int neighbor = edge->dest;
        if (!visited[neighbor]) {
            DFS(graph, neighbor, visited);
        }
        edge = edge->next;
    }
}

// 广度优先搜索
void BFS(Graph* graph, int start) {
    bool visited[MAX_NODES] = { false };
    int queue[MAX_NODES];
    int front = 0, rear = 0;

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

    while (front < rear) {
        int node = queue[front++];
        printf("%d ", node);

        EdgeNode* edge = graph->vertices[node].head;
        while (edge != NULL) {
            int neighbor = edge->dest;
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                queue[rear++] = neighbor;
            }
            edge = edge->next;
        }
    }
}

// 迪杰斯特拉算法
void Dijkstra(Graph* graph, int start, int distances[]) {
    bool visited[MAX_NODES] = { false };

    for (int i = 0; i < graph->numNodes; i++) {
        distances[i] = INT_MAX;
    }

    distances[start] = 0;

    for (int count = 0; count < graph->numNodes - 1; count++) {
        int minDist = INT_MAX;
        int minNode = -1;

        for (int i = 0; i < graph->numNodes; i++) {
            if (!visited[i] && distances[i] < minDist) {
                minDist = distances[i];
                minNode = i;
            }
        }

        visited[minNode] = true;

        EdgeNode* edge = graph->vertices[minNode].head;
        while (edge != NULL) {
            int neighbor = edge->dest;
            int weight = edge->weight;
            int newDist = distances[minNode] + weight;

            if (!visited[neighbor] && newDist < distances[neighbor]) {
                distances[neighbor] = newDist;
            }

            edge = edge->next;
        }
    }
}

// 普里姆算法
void Prim(Graph* graph, int parent[]) {
    bool visited[MAX_NODES] = { false };
    int key[MAX_NODES];

    for (int i = 0; i < graph->numNodes; i++) {
        key[i] = INT_MAX;
    }

    key[0] = 0;
    parent[0] = -1;

    for (int count = 0; count < graph->numNodes - 1; count++) {
        int minKey = INT_MAX;
        int minNode = -1;

        for (int i = 0; i < graph->numNodes; i++) {
            if (!visited[i] && key[i] < minKey) {
                minKey = key[i];
                minNode = i;
            }
        }

        visited[minNode] = true;

        EdgeNode* edge = graph->vertices[minNode].head;
        while (edge != NULL) {
            int neighbor = edge->dest;
            int weight = edge->weight;

            if (!visited[neighbor] && weight < key[neighbor]) {
                parent[neighbor] = minNode;
                key[neighbor] = weight;
            }

            edge = edge->next;
        }
    }
}

int main() {
    Graph graph;
    graph.numNodes = 5;

    // 添加边
    addEdge(&graph, 0, 1, 4);
    addEdge(&graph, 0, 2, 1);
    addEdge(&graph, 1, 2, 2);
    addEdge(&graph, 1, 3, 5);
    addEdge(&graph, 2, 3, 8);
    addEdge(&graph, 2, 4, 10);
    addEdge(&graph, 3, 4, 2);

    // 深度优先搜索
    printf("DFS traversal: ");
    bool visited[MAX_NODES] = { false };
    DFS(&graph, 0, visited);
    printf("\n");

    // 广度优先搜索
    printf("BFS traversal: ");
    BFS(&graph, 0);
    printf("\n");

    // 迪杰斯特拉算法
    int distances[MAX_NODES];
    Dijkstra(&graph, 0, distances);
    printf("Shortest distances from node 0:\n");
    for (int i = 0; i < graph.numNodes; i++) {
        printf("Node: %d, Distance: %d\n", i, distances[i]);
    }
    printf("\n");

    // 普里姆算法
    int parent[MAX_NODES];
    Prim(&graph, parent);
    printf("Minimum Spanning Tree:\n");
    for (int i = 1; i < graph.numNodes; i++) {
        printf("Node %d -- Node %d, Weight: %d\n", parent[i], i, graph.vertices[i].head->weight);
    }

    return 0;
}