Translate all code to English (#1836)

* Review the EN heading format. * Fix pythontutor headings. * Fix pythontutor headings. * bug fixes * Fix headings in **/summary.md * Revisit the CN-to-EN translation for Python code using Claude-4.5 * Revisit the CN-to-EN translation for Java code using Claude-4.5 * Revisit the CN-to-EN translation for Cpp code using Claude-4.5. * Fix the dictionary. * Fix cpp code translation for the multipart strings. * Translate Go code to English. * Update workflows to test EN code. * Add EN translation for C. * Add EN translation for CSharp. * Add EN translation for Swift. * Trigger the CI check. * Revert. * Update en/hash_map.md * Add the EN version of Dart code. * Add the EN version of Kotlin code. * Add missing code files. * Add the EN version of JavaScript code. * Add the EN version of TypeScript code. * Fix the workflows. * Add the EN version of Ruby code. * Add the EN version of Rust code. * Update the CI check for the English version code. * Update Python CI check. * Fix cmakelists for en/C code. * Fix Ruby comments
2026-07-24 12:06:07 +00:00 · 2025-12-31 07:44:52 +08:00
parent 45e1295241
commit 2778a6f9c7
1284 changed files with 71557 additions and 3275 deletions
@@ -14,7 +14,7 @@ If we view vertices as nodes and edges as references (pointers) connecting the n

 ![Relationships among linked lists, trees, and graphs](graph.assets/linkedlist_tree_graph.png)

-## Common types and terminology of graphs
+## Common Types and Terminology of Graphs

 Graphs can be divided into <u>undirected graphs</u> and <u>directed graphs</u> based on whether edges have direction, as shown in the figure below.

@@ -40,11 +40,11 @@ Graph data structures include the following commonly used terms.
 - <u>Path</u>: The sequence of edges from vertex A to vertex B is called a "path" from A to B. In the figure above, the edge sequence 1-5-2-4 is a path from vertex 1 to vertex 4.
 - <u>Degree</u>: The number of edges a vertex has. For directed graphs, <u>in-degree</u> indicates how many edges point to the vertex, and <u>out-degree</u> indicates how many edges point out from the vertex.

-## Representation of graphs
+## Representation of Graphs

 Common representations of graphs include "adjacency matrices" and "adjacency lists". The following uses undirected graphs as examples.

-### Adjacency matrix
+### Adjacency Matrix

 Given a graph with $n$ vertices, an <u>adjacency matrix</u> uses an $n \times n$ matrix to represent the graph, where each row (column) represents a vertex, and matrix elements represent edges, using $1$ or $0$ to indicate whether an edge exists between two vertices.

@@ -60,7 +60,7 @@ Adjacency matrices have the following properties.

 When using adjacency matrices to represent graphs, we can directly access matrix elements to obtain edges, resulting in highly efficient addition, deletion, lookup, and modification operations, all with a time complexity of $O(1)$. However, the space complexity of the matrix is $O(n^2)$, which consumes significant memory.

-### Adjacency list
+### Adjacency List

 An <u>adjacency list</u> uses $n$ linked lists to represent a graph, with linked list nodes representing vertices. The $i$-th linked list corresponds to vertex $i$ and stores all adjacent vertices of that vertex (vertices connected to that vertex). The figure below shows an example of a graph stored using an adjacency list.

@@ -70,7 +70,7 @@ Adjacency lists only store edges that actually exist, and the total number of ed

 Observing the figure above, **the structure of adjacency lists is very similar to "chaining" in hash tables, so we can adopt similar methods to optimize efficiency**. For example, when linked lists are long, they can be converted to AVL trees or red-black trees, thereby optimizing time efficiency from $O(n)$ to $O(\log n)$; linked lists can also be converted to hash tables, thereby reducing time complexity to $O(1)$.

-## Common applications of graphs
+## Common Applications of Graphs

 As shown in the table below, many real-world systems can be modeled using graphs, and corresponding problems can be reduced to graph computation problems.

@@ -1,8 +1,8 @@
-# Basic operations on graphs
+# Basic Operations on Graphs

 Basic operations on graphs can be divided into operations on "edges" and operations on "vertices". Under the two representation methods of "adjacency matrix" and "adjacency list", the implementation methods differ.

-## Implementation based on adjacency matrix
+## Implementation Based on Adjacency Matrix

 Given an undirected graph with $n$ vertices, the various operations are implemented as shown in the figure below.

@@ -32,7 +32,7 @@ The following is the implementation code for graphs represented using an adjacen
 [file]{graph_adjacency_matrix}-[class]{graph_adj_mat}-[func]{}
 ```

-## Implementation based on adjacency list
+## Implementation Based on Adjacency List

 Given an undirected graph with a total of $n$ vertices and $m$ edges, the various operations can be implemented as shown in the figure below.

@@ -68,7 +68,7 @@ Additionally, we use the `Vertex` class to represent vertices in the adjacency l
 [file]{graph_adjacency_list}-[class]{graph_adj_list}-[func]{}
 ```

-## Efficiency comparison
+## Efficiency Comparison

 Assuming the graph has $n$ vertices and $m$ edges, the table below compares the time efficiency and space efficiency of adjacency matrices and adjacency lists. Note that the adjacency list (linked list) corresponds to the implementation in this text, while the adjacency list (hash table) refers specifically to the implementation where all linked lists are replaced with hash tables.

@@ -1,16 +1,16 @@
-# Graph traversal
+# Graph Traversal

 Trees represent "one-to-many" relationships, while graphs have a higher degree of freedom and can represent any "many-to-many" relationships. Therefore, we can view trees as a special case of graphs. Clearly, **tree traversal operations are also a special case of graph traversal operations**.

 Both graphs and trees require the application of search algorithms to implement traversal operations. Graph traversal methods can also be divided into two types: <u>breadth-first traversal</u> and <u>depth-first traversal</u>.

-## Breadth-first search
+## Breadth-First Search

 **Breadth-first search is a near-to-far traversal method that, starting from a certain node, always prioritizes visiting the nearest vertices and expands outward layer by layer**. As shown in the figure below, starting from the top-left vertex, first traverse all adjacent vertices of that vertex, then traverse all adjacent vertices of the next vertex, and so on, until all vertices have been visited.

 ![Breadth-first search of a graph](graph_traversal.assets/graph_bfs.png)

-### Algorithm implementation
+### Algorithm Implementation

 BFS is typically implemented with the help of a queue, as shown in the code below. The queue has a "first in, first out" property, which aligns with the BFS idea of "near to far".

@@ -67,19 +67,19 @@ The code is relatively abstract; it is recommended to refer to the figure below

    Not unique. Breadth-first search only requires traversing in a "near to far" order, **and the traversal order of vertices at the same distance can be arbitrarily shuffled**. Taking the figure above as an example, the visit order of vertices $1$ and $3$ can be swapped, as can the visit order of vertices $2$, $4$, and $6$.

-### Complexity analysis
+### Complexity Analysis

 **Time complexity**: All vertices will be enqueued and dequeued once, using $O(|V|)$ time; in the process of traversing adjacent vertices, since it is an undirected graph, all edges will be visited $2$ times, using $O(2|E|)$ time; overall using $O(|V| + |E|)$ time.

 **Space complexity**: The list `res`, hash set `visited`, and queue `que` can contain at most $|V|$ vertices, using $O(|V|)$ space.

-## Depth-first search
+## Depth-First Search

 **Depth-first search is a traversal method that prioritizes going as far as possible, then backtracks when no path remains**. As shown in the figure below, starting from the top-left vertex, visit an adjacent vertex of the current vertex, continuing until reaching a dead end, then return and continue going as far as possible before returning again, and so on, until all vertices have been traversed.

 ![Depth-first search of a graph](graph_traversal.assets/graph_dfs.png)

-### Algorithm implementation
+### Algorithm Implementation

 This "go as far as possible then return" algorithm paradigm is typically implemented using recursion. Similar to breadth-first search, in depth-first search we also need a hash set `visited` to record visited vertices and avoid revisiting.

@@ -133,7 +133,7 @@ To deepen understanding, it is recommended to combine the figure below with the

    Taking tree traversal as an example, "root $\rightarrow$ left $\rightarrow$ right", "left $\rightarrow$ root $\rightarrow$ right", and "left $\rightarrow$ right $\rightarrow$ root" correspond to pre-order, in-order, and post-order traversals, respectively. They represent three different traversal priorities, yet all three belong to depth-first search.

-### Complexity analysis
+### Complexity Analysis

 **Time complexity**: All vertices will be visited $1$ time, using $O(|V|)$ time; all edges will be visited $2$ times, using $O(2|E|)$ time; overall using $O(|V| + |E|)$ time.

@@ -1,6 +1,6 @@
 # Summary

-### Key review
+### Key Review

 - Graphs consist of vertices and edges and can be represented 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.