c语言如何用邻接表创建有序图

C语言如何用邻接表创建有序图

在C语言中，利用邻接表创建有序图的步骤包括：选择适当的数据结构、初始化图、添加边、遍历图。邻接表是一种图的数据表示方式，适用于稀疏图，其存储效率高，并且方便进行图的各种操作，如添加或删除边、查找相邻顶点等。下面将详细阐述这些步骤及其实现方法。

一、数据结构选择与定义

选择适当的数据结构是创建邻接表的第一步。邻接表通常由一个数组和链表组成，数组存储图的顶点，链表存储与该顶点相连的边。

1. 顶点和边的结构定义

在C语言中，我们可以使用结构体来定义顶点和边。顶点可以包含一个唯一标识符和一个指向链表头的指针，链表中的节点表示边，包含目标顶点和下一个边的指针。

// 定义边的结构体
typedef struct Edge {
    int dest; // 目标顶点
    struct Edge* next; // 下一条边
} Edge;
// 定义顶点的结构体
typedef struct Vertex {
    int id; // 顶点标识符
    Edge* head; // 指向边链表的头指针
} Vertex;

2. 图的结构定义

图可以使用一个包含顶点数组和顶点数量的结构体来表示。

// 定义图的结构体
typedef struct Graph {
    int numVertices; // 顶点数量
    Vertex* vertices; // 顶点数组
} Graph;

二、初始化图

初始化图包括分配内存和初始化顶点数组及其链表头指针。

1. 创建图

创建图时需要分配内存，并初始化每个顶点的链表头指针为空。

// 创建图函数
Graph* createGraph(int numVertices) {
    Graph* graph = (Graph*)malloc(sizeof(Graph));
    graph->numVertices = numVertices;
    graph->vertices = (Vertex*)malloc(numVertices * sizeof(Vertex));
    for (int i = 0; i < numVertices; i++) {
        graph->vertices[i].id = i;
        graph->vertices[i].head = NULL;
    }
    return graph;
}

三、添加边

在邻接表中添加边意味着在相应顶点的链表中插入一个新的边节点。对于有序图，添加边时需确保链表中边节点按某种顺序排列，如按顶点编号排序。

1. 添加边函数

// 创建边节点函数
Edge* createEdge(int dest) {
    Edge* newEdge = (Edge*)malloc(sizeof(Edge));
    newEdge->dest = dest;
    newEdge->next = NULL;
    return newEdge;
}
// 添加边函数
void addEdge(Graph* graph, int src, int dest) {
    Edge* newEdge = createEdge(dest);
    Edge* current = graph->vertices[src].head;
    Edge* previous = NULL;
    // 按目标顶点编号排序插入
    while (current != NULL && current->dest < dest) {
        previous = current;
        current = current->next;
    }
    if (previous == NULL) {
        graph->vertices[src].head = newEdge;
    } else {
        previous->next = newEdge;
    }
    newEdge->next = current;
}

四、遍历图

遍历图通常包括深度优先搜索（DFS）和广度优先搜索（BFS）。在邻接表表示的图中，遍历操作需要访问每个顶点的链表。

1. 深度优先搜索（DFS）

DFS是从图的某个起始顶点开始，尽可能深地搜索图的每一个分支。

// DFS辅助函数
void DFSUtil(Graph* graph, int v, int* visited) {
    visited[v] = 1;
    printf("%d ", v);
    Edge* edge = graph->vertices[v].head;
    while (edge != NULL) {
        if (!visited[edge->dest]) {
            DFSUtil(graph, edge->dest, visited);
        }
        edge = edge->next;
    }
}
// DFS主函数
void DFS(Graph* graph, int startVertex) {
    int* visited = (int*)malloc(graph->numVertices * sizeof(int));
    for (int i = 0; i < graph->numVertices; i++) {
        visited[i] = 0;
    }
    DFSUtil(graph, startVertex, visited);
    free(visited);
}

2. 广度优先搜索（BFS）

BFS是从图的某个起始顶点开始，按照层次逐层访问图中的顶点。

// BFS函数
void BFS(Graph* graph, int startVertex) {
    int* visited = (int*)malloc(graph->numVertices * sizeof(int));
    for (int i = 0; i < graph->numVertices; i++) {
        visited[i] = 0;
    }
    int* queue = (int*)malloc(graph->numVertices * sizeof(int));
    int front = 0, rear = 0;
    visited[startVertex] = 1;
    queue[rear++] = startVertex;
    while (front < rear) {
        int currentVertex = queue[front++];
        printf("%d ", currentVertex);
        Edge* edge = graph->vertices[currentVertex].head;
        while (edge != NULL) {
            if (!visited[edge->dest]) {
                visited[edge->dest] = 1;
                queue[rear++] = edge->dest;
            }
            edge = edge->next;
        }
    }
    free(queue);
    free(visited);
}

五、应用示例

一个完整的示例可以展示如何创建图、添加边，并进行遍历操作。

int main() {
    int numVertices = 5;
    Graph* graph = createGraph(numVertices);
    addEdge(graph, 0, 1);
    addEdge(graph, 0, 4);
    addEdge(graph, 1, 2);
    addEdge(graph, 1, 3);
    addEdge(graph, 1, 4);
    addEdge(graph, 2, 3);
    addEdge(graph, 3, 4);
    printf("DFS starting from vertex 0:n");
    DFS(graph, 0);
    printf("nBFS starting from vertex 0:n");
    BFS(graph, 0);
    // 释放内存
    for (int i = 0; i < numVertices; i++) {
        Edge* edge = graph->vertices[i].head;
        while (edge != NULL) {
            Edge* temp = edge;
            edge = edge->next;
            free(temp);
        }
    }
    free(graph->vertices);
    free(graph);
    return 0;
}

六、总结

通过上述步骤，可以在C语言中利用邻接表创建有序图。选择适当的数据结构、初始化图、添加边、遍历图是关键步骤，每一步都需要仔细考虑其实现细节。此外，在实际应用中，还可以结合具体需求进行优化和扩展，例如支持更多的图操作、优化内存管理、提高算法效率等。