图(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;
}