Merge 2ef65eaa6b into 4db5c19011

* translation: graph summary updates

* resolve grammar issues

codes/c/chapter_graph/graph_adjacency_list.c

@@ -38,11 +38,13 @@ GraphAdjList *newGraphAdjList() {
 void delGraphAdjList(GraphAdjList *graph) {
     for (int i = 0; i < graph->size; i++) {
         AdjListNode *cur = graph->heads[i];
+        if (cur == NULL) {
+            continue;
+        }
+        cur = cur->next;
         while (cur != NULL) {
             AdjListNode *next = cur->next;
-            if (cur != graph->heads[i]) {
+            free(cur);
-                free(cur);
-            }
             cur = next;
         }
         free(graph->heads[i]->vertex);
@@ -61,6 +63,14 @@ AdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {
     return NULL;
 }
 
+AdjListNode** findNodeV2(GraphAdjList *graph, Vertex *vet) {
+    for (int i = 0; i < graph->size; i++) {
+        if (graph->heads[i]->vertex == vet) {
+            return &(graph->heads[i]);
+        }
+    }
+}
+
 /* 添加边辅助函数 */
 void addEdgeHelper(AdjListNode *head, Vertex *vet) {
     AdjListNode *node = (AdjListNode *)malloc(sizeof(AdjListNode));
@@ -119,15 +129,17 @@ void addVertex(GraphAdjList *graph, Vertex *vet) {
 
 /* 删除顶点 */
 void removeVertex(GraphAdjList *graph, Vertex *vet) {
-    AdjListNode *node = findNode(graph, vet);
+    AdjListNode **node = findNodeV2(graph, vet);
     assert(node != NULL);
     // 在邻接表中删除顶点 vet 对应的链表
-    AdjListNode *cur = node, *pre = NULL;
+    AdjListNode **cur_ref = node, **pre_ref = NULL;
-    while (cur) {
+    while (*cur_ref) {
-        pre = cur;
+        pre_ref = cur_ref;
-        cur = cur->next;
+        *cur_ref = ((*cur_ref)->next);
-        free(pre);
+        free(*pre_ref);
+        *pre_ref = NULL;
     }
+    AdjListNode *cur = NULL, *pre = NULL;
     // 遍历其他顶点的链表，删除所有包含 vet 的边
     for (int i = 0; i < graph->size; i++) {
         cur = graph->heads[i];
@@ -145,7 +157,7 @@ void removeVertex(GraphAdjList *graph, Vertex *vet) {
     // 将该顶点之后的顶点向前移动，以填补空缺
     int i;
     for (i = 0; i < graph->size; i++) {
-        if (graph->heads[i] == node)
+        if (graph->heads[i] == *node)
             break;
     }
     for (int j = i; j < graph->size - 1; j++) {
@@ -160,6 +172,9 @@ void printGraph(const GraphAdjList *graph) {
     printf("邻接表 =\n");
     for (int i = 0; i < graph->size; ++i) {
         AdjListNode *node = graph->heads[i];
+        if (node == NULL) {
+            continue;
+        }
         printf("%d: [", node->vertex->val);
         node = node->next;
         while (node) {

en/docs/chapter_graph/summary.md

@@ -2,30 +2,30 @@
 
 ### Key review
 
-- A graph consists of vertices and edges and can be represented as a set comprising a group of vertices and a group of edges.
+- A graph is made up of vertices and edges. It can be described as a set of vertices and a set of edges.
-- Compared to linear relationships (linked lists) and divide-and-conquer relationships (trees), network relationships (graphs) have a higher degree of freedom and are therefore more complex.
+- Compared to linear relationships (like linked lists) and hierarchical relationships (like trees), network relationships (graphs) offer greater flexibility, making them more complex.
-- The edges of a directed graph have directionality, any vertex in a connected graph is reachable, and each edge in a weighted graph contains a weight variable.
+- In a directed graph, edges have directions. In a connected graph, any vertex can be reached from any other vertex. In a weighted graph, each edge has an associated weight variable.
-- Adjacency matrices use matrices to represent graphs, with each row (column) representing a vertex and matrix elements representing edges, using $1$ or $0$ to indicate the presence or absence of an edge between two vertices. Adjacency matrices are highly efficient for add, delete, find, and modify operations, but they consume more space.
+- An adjacency matrix is a way to represent a graph using matrix (2D array). The rows and columns represent the vertices. The matrix element value indicates whether there is an edge between two vertices, using $1$ for an edge or $0$ for no edge. Adjacency matrices are highly efficient for operations like adding, deleting, or checking edges, but they require more space.
-- Adjacency lists use multiple linked lists to represent graphs, with the $i^{th}$ list corresponding to vertex $i$, containing all its adjacent vertices. Adjacency lists save more space compared to adjacency matrices, but since it is necessary to traverse the list to find edges, their time efficiency is lower.
+- An adjacency list is another common way to represent a graph using a collection of linked lists. Each vertex in the graph has a list that contains all its adjacent vertices. The $i^{th}$ list represents vertex $i$. Adjacency lists use less space compared to adjacency matrices. However, since it requires traversing the list to find edges, the time efficiency is lower.
-- When the linked lists in the adjacency list are too long, they can be converted into red-black trees or hash tables to improve query efficiency.
+- When the linked lists in an adjacency list are long enough, they can be converted into red-black trees or hash tables to improve lookup efficiency.
-- From the perspective of algorithmic thinking, adjacency matrices embody the principle of "space for time," while adjacency lists embody "time for space."
+- From the perspective of algorithmic design, an adjacency matrix reflects the concept of "trading space for time", whereas an adjacency list reflects "trading time for space".
-- Graphs can be used to model various real systems, such as social networks, subway routes, etc.
+- Graphs can be used to model various real-world systems, such as social networks, subway routes.
 - A tree is a special case of a graph, and tree traversal is also a special case of graph traversal.
-- Breadth-first traversal of a graph is a search method that expands layer by layer from near to far, usually implemented with a queue.
+- Breadth-first traversal of a graph is a search method that expands layer by layer from near to far, typically using a queue.
-- Depth-first traversal of a graph is a search method that prefers to go as deep as possible and backtracks when no further paths are available, often based on recursion.
+- Depth-first traversal of a graph is a search method that prioritizes reaching the end before backtracking when no further path is available. It is often implemented using recursion.
 
 ### Q & A
 
 **Q**: Is a path defined as a sequence of vertices or a sequence of edges?
 
-Definitions vary between different language versions on Wikipedia: the English version defines a path as "a sequence of edges," while the Chinese version defines it as "a sequence of vertices." Here is the original text from the English version: In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.
+In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.
 
 In this document, a path is considered a sequence of edges, rather than a sequence of vertices. This is because there might be multiple edges connecting two vertices, in which case each edge corresponds to a path.
 
-**Q**: In a disconnected graph, are there points that cannot be traversed to?
+**Q**: In a disconnected graph, are there points that cannot be traversed?
 
-In a disconnected graph, starting from a certain vertex, there is at least one vertex that cannot be reached. Traversing a disconnected graph requires setting multiple starting points to traverse all connected components of the graph.
+In a disconnected graph, there is at least one vertex that cannot be reached from a specific point. To traverse a disconnected graph, you need to set multiple starting points to traverse all the connected components of the graph.
 
 **Q**: In an adjacency list, does the order of "all vertices connected to that vertex" matter?
 
-It can be in any order. However, in practical applications, it might be necessary to sort according to certain rules, such as the order in which vertices are added, or the order of vertex values, etc., to facilitate the quick search for vertices with certain extremal values.
+It can be in any order. However, in real-world applications, it might be necessary to sort them according to certain rules, such as the order in which vertices are added, or the order of vertex values. This can help find vertices quickly with certain extreme values.