build

chapter_array_and_linkedlist/list.md

@@ -867,7 +867,7 @@ comments: true
 
         /* 列表扩容 */
         public void extendCapacity() {
-            // 新建一个长度为 size 的数组，并将原数组拷贝到新数组
+            // 新建一个长度为原数组 extendRatio 倍的新数组，并将原数组拷贝到新数组
             nums = Arrays.copyOf(nums, capacity() * extendRatio);
             // 更新列表容量
             capacity = nums.length;
@@ -976,7 +976,7 @@ comments: true
 
         /* 列表扩容 */
         void extendCapacity() {
-            // 新建一个长度为 size * extendRatio 的数组，并将原数组拷贝到新数组
+            // 新建一个长度为原数组 extendRatio 倍的新数组
             int newCapacity = capacity() * extendRatio;
             int *tmp = nums;
             nums = new int[newCapacity];
@@ -1072,7 +1072,7 @@ comments: true
 
         def extend_capacity(self) -> None:
             """列表扩容"""
-            # 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组
+            # 新建一个长度为原数组 __extend_ratio 倍的新数组，并将原数组拷贝到新数组
             self.__nums = self.__nums + [0] * self.capacity() * (self.__extend_ratio - 1)
             # 更新列表容量
             self.__capacity = len(self.__nums)
@@ -1177,7 +1177,7 @@ comments: true
 
     /* 列表扩容 */
     func (l *myList) extendCapacity() {
-        // 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组
+        // 新建一个长度为原数组 extendRatio 倍的新数组，并将原数组拷贝到新数组
         l.nums = append(l.nums, make([]int, l.numsCapacity*(l.extendRatio-1))...)
         // 更新列表容量
         l.numsCapacity = len(l.nums)
@@ -1271,7 +1271,7 @@ comments: true
 
         /* 列表扩容 */
         extendCapacity() {
-            // 新建一个长度为 size 的数组，并将原数组拷贝到新数组
+            // 新建一个长度为原数组 extendRatio 倍的新数组，并将原数组拷贝到新数组
             this.#nums = this.#nums.concat(
                 new Array(this.capacity() * (this.#extendRatio - 1))
             );
@@ -1690,7 +1690,7 @@ comments: true
 
         /* 列表扩容 */
         func extendCapacity() {
-            // 新建一个长度为 size 的数组，并将原数组拷贝到新数组
+            // 新建一个长度为原数组 extendRatio 倍的新数组，并将原数组拷贝到新数组
             nums = nums + Array(repeating: 0, count: _capacity * (extendRatio - 1))
             // 更新列表容量
             _capacity = nums.count
@@ -1803,7 +1803,7 @@ comments: true
 
             // 列表扩容
             pub fn extendCapacity(self: *Self) !void {
-                // 新建一个长度为 size * extend_ratio 的数组，并将原数组拷贝到新数组
+                // 新建一个长度为原数组 extendRatio 倍的新数组，并将原数组拷贝到新数组
                 var newCapacity = self.capacity() * self.extend_ratio;
                 var extend = try self.mem_allocator.alloc(T, newCapacity);
                 std.mem.set(T, extend, @as(T, 0));
@@ -1900,7 +1900,7 @@ comments: true
 
       /* 列表扩容 */
       void extendCapacity() {
-        // 新建一个长度为 _capacity * _extendRatio 的数组
+        // 新建一个长度为原数组 _extendRatio 倍的新数组
         final _newNums = List.filled(_capacity * _extendRatio, 0);
         // 将原数组拷贝到新数组
         List.copyRange(_newNums, 0, _nums);

chapter_computational_complexity/time_complexity.md

@@ -600,7 +600,7 @@ $T(n)$ 是一次函数，说明时间增长趋势是线性的，因此可以得
 
 根据定义，确定 $f(n)$ 之后，我们便可得到时间复杂度 $O(f(n))$ 。那么如何确定渐近上界 $f(n)$ 呢？总体分为两步：首先统计操作数量，然后判断渐近上界。
 
-### 1) 统计操作数量
+### 第一步：统计操作数量
 
 针对代码，逐行从上到下计算即可。然而，由于上述 $c \cdot f(n)$ 中的常数项 $c$ 可以取任意大小，**因此操作数量 $T(n)$ 中的各种系数、常数项都可以被忽略**。根据此原则，可以总结出以下计数简化技巧：
 
@@ -816,7 +816,7 @@ $$
     }
     ```
 
-### 2) 判断渐近上界
+### 第二步：判断渐近上界
 
 **时间复杂度由多项式 $T(n)$ 中最高阶的项来决定**。这是因为在 $n$ 趋于无穷大时，最高阶的项将发挥主导作用，其他项的影响都可以被忽略。