diff --git a/codes/go/chapter_graph/graph_adjacency_list.go b/codes/go/chapter_graph/graph_adjacency_list.go
index 3d07649df..9ff60a815 100644
--- a/codes/go/chapter_graph/graph_adjacency_list.go
+++ b/codes/go/chapter_graph/graph_adjacency_list.go
@@ -89,7 +89,6 @@ func (g *graphAdjList) removeVertex(vet Vertex) {
 func (g *graphAdjList) print() {
 	var builder strings.Builder
 	fmt.Printf("邻接表 = \n")
-	// 使邻接表有序输出
 	for k, v := range g.adjList {
 		builder.WriteString("\t\t" + strconv.Itoa(k.Val) + ": ")
 		for _, vet := range v {
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index c44c17527..2a05508f8 100755
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -1528,30 +1528,9 @@ $$
 === "C++"
 
     ```cpp title="worst_best_time_complexity.cpp"
-    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
-    vector<int> randomNumbers(int n) {
-        vector<int> nums(n);
-        // 生成数组 nums = { 1, 2, 3, ..., n }
-        for (int i = 0; i < n; i++) {
-            nums[i] = i + 1;
-        }
-        // 使用系统时间生成随机种子
-        unsigned seed = chrono::system_clock::now().time_since_epoch().count();
-        // 随机打乱数组元素
-        shuffle(nums.begin(), nums.end(), default_random_engine(seed));
-        return nums;
-    }
+    [class]{}-[func]{randomNumbers}
 
-    /* 查找数组 nums 中数字 1 所在索引 */
-    int findOne(vector<int>& nums) {
-        for (int i = 0; i < nums.size(); i++) {
-            // 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
-            // 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
-            if (nums[i] == 1)
-                return i;
-        }
-        return -1;
-    }
+    [class]{}-[func]{findOne}
     ```
 
 === "Python"
@@ -1565,129 +1544,33 @@ $$
 === "Go"
 
     ```go title="worst_best_time_complexity.go"
-    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
-    func randomNumbers(n int) []int {
-        nums := make([]int, n)
-        // 生成数组 nums = { 1, 2, 3, ..., n }
-        for i := 0; i < n; i++ {
-            nums[i] = i + 1
-        }
-        // 随机打乱数组元素
-        rand.Shuffle(len(nums), func(i, j int) {
-            nums[i], nums[j] = nums[j], nums[i]
-        })
-        return nums
-    }
+    [class]{}-[func]{randomNumbers}
 
-    /* 查找数组 nums 中数字 1 所在索引 */
-    func findOne(nums []int) int {
-        for i := 0; i < len(nums); i++ {
-            // 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
-            // 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
-            if nums[i] == 1 {
-                return i
-            }
-        }
-        return -1
-    }
+    [class]{}-[func]{findOne}
     ```
 
 === "JavaScript"
 
     ```javascript title="worst_best_time_complexity.js"
-    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
-    function randomNumbers(n) {
-        const nums = Array(n);
-        // 生成数组 nums = { 1, 2, 3, ..., n }
-        for (let i = 0; i < n; i++) {
-            nums[i] = i + 1;
-        }
-        // 随机打乱数组元素
-        for (let i = 0; i < n; i++) {
-            const r = Math.floor(Math.random() * (i + 1));
-            const temp = nums[i];
-            nums[i] = nums[r];
-            nums[r] = temp;
-        }
-        return nums;
-    }
+    [class]{}-[func]{randomNumbers}
 
-    /* 查找数组 nums 中数字 1 所在索引 */
-    function findOne(nums) {
-        for (let i = 0; i < nums.length; i++) {
-            // 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
-            // 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
-            if (nums[i] === 1) {
-                return i;
-            }
-        }
-        return -1;
-    }
+    [class]{}-[func]{findOne}
     ```
 
 === "TypeScript"
 
     ```typescript title="worst_best_time_complexity.ts"
-    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
-    function randomNumbers(n: number): number[] {
-        const nums = Array(n);
-        // 生成数组 nums = { 1, 2, 3, ..., n }
-        for (let i = 0; i < n; i++) {
-            nums[i] = i + 1;
-        }
-        // 随机打乱数组元素
-        for (let i = 0; i < n; i++) {
-            const r = Math.floor(Math.random() * (i + 1));
-            const temp = nums[i];
-            nums[i] = nums[r];
-            nums[r] = temp;
-        }
-        return nums;
-    }
+    [class]{}-[func]{randomNumbers}
 
-    /* 查找数组 nums 中数字 1 所在索引 */
-    function findOne(nums: number[]): number {
-        for (let i = 0; i < nums.length; i++) {
-            // 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
-            // 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
-            if (nums[i] === 1) {
-                return i;
-            }
-        }
-        return -1;
-    }
+    [class]{}-[func]{findOne}
     ```
 
 === "C"
 
     ```c title="worst_best_time_complexity.c"
-    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
-    int *randomNumbers(int n) {
-        // 分配堆区内存（创建一维可变长数组：数组中元素数量为n，元素类型为int）
-        int *nums = (int *)malloc(n * sizeof(int));
-        // 生成数组 nums = { 1, 2, 3, ..., n }
-        for (int i = 0; i < n; i++) {
-            nums[i] = i + 1;
-        }
-        // 随机打乱数组元素 
-        for (int i = n - 1; i > 0; i--) {
-            int j = rand() % (i + 1);
-            int temp = nums[i];
-            nums[i] = nums[j];
-            nums[j] = temp; 
-        }
-        return nums;
-    }
+    [class]{}-[func]{randomNumbers}
 
-    /* 查找数组 nums 中数字 1 所在索引 */
-    int findOne(int *nums, int n) {
-        for (int i = 0; i < n; i++) {
-            // 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
-            // 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
-            if (nums[i] == 1) return i;
-        }
-        return -1;
-    }
+    [class]{}-[func]{findOne}
     ```
 
 === "C#"
@@ -1701,26 +1584,9 @@ $$
 === "Swift"
 
     ```swift title="worst_best_time_complexity.swift"
-    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
-    func randomNumbers(n: Int) -> [Int] {
-        // 生成数组 nums = { 1, 2, 3, ..., n }
-        var nums = Array(1 ... n)
-        // 随机打乱数组元素
-        nums.shuffle()
-        return nums
-    }
+    [class]{}-[func]{randomNumbers}
 
-    /* 查找数组 nums 中数字 1 所在索引 */
-    func findOne(nums: [Int]) -> Int {
-        for i in nums.indices {
-            // 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
-            // 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
-            if nums[i] == 1 {
-                return i
-            }
-        }
-        return -1
-    }
+    [class]{}-[func]{findOne}
     ```
 
 === "Zig"