Update time_complexity.md

增加对应的 js 和 ts 代码，方便前端学习的同学阅读代码。

docs/chapter_computational_complexity/time_complexity.md

@@ -79,13 +79,31 @@ $$
 === "JavaScript"
 
     ```js title=""
-
+    // 在某运行平台下
+    function algorithm(n){
+        let a = 2 // 1 ns
+        a = a + 1 // 1 ns
+        a = a * 2 // 10 ns
+        // 循环 n 次
+        for(let i = 0; i < n; i++){ // 1 ns
+            a = a + i // 5 ns
+        }
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title=""
-
+    // 在某运行平台下
+    function algorithm(n: number): void {
+      let a = 2 // 1 ns
+      a = a + 1 // 1 ns
+      a = a * 2 // 10 ns
+      // 循环 n 次
+      for (let i = 0; i < n; i++) { // 1 ns
+        a = a + i // 5 ns
+      }
+    }
     ```
 
 === "C"
@@ -194,13 +212,47 @@ $$
 === "JavaScript"
 
     ```js title=""
+    // 算法 A 时间复杂度：常数阶
+    function algorithmA(n) {
+        console.log(0);
+    }
 
+    // 算法 B 时间复杂度：线性阶
+    function algorithmB(n) {
+        for (let i = 0; i < n; i++) {
+            console.log(0);
+        }
+    }
+
+    // 算法 C 时间复杂度：常数阶
+    function algorithmC(n) {
+        for (let i = 0; i < 1000000; i++) {
+            console.log(0);
+        }
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title=""
+    // 算法 A 时间复杂度：常数阶
+    function algorithmA(n: number) {
+      console.log(0)
+    }
 
+    // 算法 A 时间复杂度：常数阶
+    function algorithmB(n: number) {
+      for (let i = 0; i < n; i++) {
+        console.log(0)
+      }
+    }
+
+    // 算法 C 时间复杂度：常数阶
+    function algorithmC(n: number) {
+      for (let i = 0; i < 1000000; i++) {
+        console.log(0)
+      }
+    }
     ```
 
 === "C"
@@ -292,13 +344,31 @@ $$
 === "JavaScript"
 
     ```js title=""
-
+    function algorithm(n) {
+      let a = 1 // +1
+      a = a + 1 // +1
+      a = a * 2 // +1
+      // 循环 n 次
+      for (let i = 0; i < n; i++) {
+        // +1（每轮都执行 i ++）
+        console.log(0) // +1
+      }
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title=""
-
+    function algorithm(n: number) {
+      let a = 1 // +1
+      a = a + 1 // +1
+      a = a * 2 // +1
+      // 循环 n 次
+      for (let i = 0; i < n; i++) {
+        // +1（每轮都执行 i ++）
+        console.log(0) // +1
+      }
+    }
     ```
 
 === "C"
@@ -439,13 +509,39 @@ $$
 === "JavaScript"
 
     ```js title=""
-
+    function algorithm(n) {
+      let a = 1 // +0（技巧 1）
+      a = a + n // +0（技巧 1）
+      // +n（技巧 2）
+      for (let i = 0; i < 5 * n + 1; i++) {
+        console.log(0)
+      }
+      // +n*n（技巧 3）
+      for (let i = 0; i < 2 * n; i++) {
+        for (let j = 0; j < n + 1; j++) {
+          console.log(0)
+        }
+      }
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title=""
-
+    function algorithm(n: number) {
+      let a = 1 // +0（技巧 1）
+      a = a + n // +0（技巧 1）
+      // +n（技巧 2）
+      for (let i = 0; i < 5 * n + 1; i++) {
+        console.log(0)
+      }
+      // +n*n（技巧 3）
+      for (let i = 0; i < 2 * n; i++) {
+        for (let j = 0; j < n + 1; j++) {
+          console.log(0)
+        }
+      }
+    }
     ```
 
 === "C"
@@ -558,13 +654,29 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 常数阶 */
+    function constant(n) {
+      let count = 0
+      const size = 100000
+      for (let i = 0; i < size; i++) {
+        count++
+      }
+      return count
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 常数阶 */
+    function constant(n: number): number {
+      let count = 0
+      const size = 100000
+      for (let i = 0; i < size; i++) {
+        count++
+      }
+      return count
+    }
     ```
 
 === "C"
@@ -634,13 +746,26 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 线性阶 */
+    function linear(n) {
+      let count = 0
+      for (let i = 0; i < n; i++) {
+        count++
+      }
+      return count
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    function linear(n: number): number {
+      let count = 0
+      for (let i = 0; i < n; i++) {
+        count++
+      }
+      return count
+    }
     ```
 
 === "C"
@@ -718,13 +843,29 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 线性阶（遍历数组） */
+    function arrayTraversal(nums) {
+      let count = 0
+      // 循环次数与数组长度成正比
+      for (let num of nums) {
+        count++
+      }
+      return count
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 线性阶（遍历数组） */
+    function arrayTraversal(nums: number[]) {
+      let count = 0
+      // 循环次数与数组长度成正比
+      for (let num of nums) {
+        count++
+      }
+      return count
+    }
     ```
 
 === "C"
@@ -807,13 +948,33 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 平方阶 */
+    function quadratic(n) {
+      let count = 0
+      // 循环次数与数组长度成平方关系
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+          count++
+        }
+      }
+      return count
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 平方阶 */
+    function quadratic(n: number) {
+      let count = 0
+      // 循环次数与数组长度成平方关系
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+          count++
+        }
+      }
+      return count
+    }
     ```
 
 === "C"
@@ -929,13 +1090,47 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 平方阶（冒泡排序） */
+    function bubbleSort(nums) {
+      let count = 0 // 计数器
+      // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+      for (let i = nums.length - 1; i > 0; i--) {
+        // 内循环：冒泡操作
+        for (let j = 0; j < i; j++) {
+          if (nums[j] > nums[j + 1]) {
+            // 交换 nums[j] 与 nums[j + 1]
+            let tmp = nums[j]
+            nums[j] = nums[j + 1]
+            nums[j + 1] = tmp
+            count += 3 // 元素交换包含 3 个单元操作
+          }
+        }
+      }
+      return count
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 平方阶（冒泡排序） */
+    function bubbleSort(nums: number[]) {
+      let count = 0 // 计数器
+      // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+      for (let i = nums.length - 1; i > 0; i--) {
+        // 内循环：冒泡操作
+        for (let j = 0; j < i; j++) {
+          if (nums[j] > nums[j + 1]) {
+            // 交换 nums[j] 与 nums[j + 1]
+            let tmp = nums[j]
+            nums[j] = nums[j + 1]
+            nums[j + 1] = tmp
+            count += 3 // 元素交换包含 3 个单元操作
+          }
+        }
+      }
+      return count
+    }
     ```
 
 === "C"
@@ -1030,13 +1225,39 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 指数阶（循环实现） */
+    function exponential(n) {
+      let count = 0,
+        base = 1
+      // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < base; j++) {
+          count++
+        }
+        base *= 2
+      }
+      // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+      return count
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 指数阶（循环实现） */
+    function exponential(n: number) {
+      let count = 0,
+        base = 1
+      // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < base; j++) {
+          count++
+        }
+        base *= 2
+      }
+      // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+      return count
+    }
     ```
 
 === "C"
@@ -1101,13 +1322,21 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 指数阶（递归实现）*/
+    function expRecur(n) {
+      if (n == 1) return 1
+      return expRecur(n - 1) + expRecur(n - 1) + 1
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 指数阶（递归实现）*/
+    function expRecur(n: number) {
+      if (n == 1) return 1
+      return expRecur(n - 1) + expRecur(n - 1) + 1
+    }
     ```
 
 === "C"
@@ -1187,13 +1416,29 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 对数阶（循环实现） */
+    function logarithmic(n) {
+      let count = 0
+      while (n > 1) {
+        n = n / 2
+        count++
+      }
+      return count
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 对数阶（循环实现） */
+    function logarithmic(n: number) {
+      let count = 0
+      while (n > 1) {
+        n = n / 2
+        count++
+      }
+      return count
+    }
     ```
 
 === "C"
@@ -1258,13 +1503,21 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 对数阶（递归实现）*/
+    function logRecur(n) {
+      if (n <= 1) return 0
+      return logRecur(n / 2) + 1
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 对数阶（递归实现）*/
+    function logRecur(n: number) {
+      if (n <= 1) return 0
+      return logRecur(n / 2) + 1
+    }
     ```
 
 === "C"
@@ -1348,13 +1601,29 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 线性对数阶 */
+    function linearLogRecur(n) {
+      if (n <= 1) return 1
+      let count = linearLogRecur(n / 2) + linearLogRecur(n / 2)
+      for (let i = 0; i < n; i++) {
+        count++
+      }
+      return count
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 线性对数阶 */
+    function linearLogRecur(n: number) {
+      if (n <= 1) return 1
+      let count = linearLogRecur(n / 2) + linearLogRecur(n / 2)
+      for (let i = 0; i < n; i++) {
+        count++
+      }
+      return count
+    }
     ```
 
 === "C"
@@ -1446,13 +1715,31 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 阶乘阶（递归实现） */
+    function factorialRecur(n) {
+      if (n == 0) return 1
+      let count = 0
+      // 从 1 个分裂出 n 个
+      for (let i = 0; i < n; i++) {
+        count += factorialRecur(n - 1)
+      }
+      return count
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 阶乘阶（递归实现） */
+    function factorialRecur(n: number) {
+      if (n == 0) return 1
+      let count = 0
+      // 从 1 个分裂出 n 个
+      for (let i = 0; i < n; i++) {
+        count += factorialRecur(n - 1)
+      }
+      return count
+    }
     ```
 
 === "C"
@@ -1634,13 +1921,81 @@ $$
 === "JavaScript"
 
     ```js title="worst_best_time_complexity.js"
+    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
+    function randomNumbers(n) {
+        // 生成数组 nums = { 1, 2, 3, ..., n }
+        let nums = [...Array(n).keys()].map(i => i + 1);
+        shuffle(nums);
+        return nums;
+    }
 
+    /* 查找数组 nums 中数字 1 所在索引 */
+    function findOne(nums) {
+        for (let i = 0; i < nums.length; i++) {
+            if (nums[i] === 1) return i;
+        }
+        return -1;
+    }
+
+    /* 随机打乱数组元素 */
+    function shuffle(arr) {
+        let n = arr.length;
+        for (let i = 0; i < n; i++) {
+            let j = Math.floor(Math.random() * n);
+            [arr[i], arr[j]] = [arr[j], arr[i]];
+        }
+    }
+
+    /* Driver Code */
+    ;(function main() {
+        for (let i = 0; i < 10; i++) {
+            let n = 100;
+            let nums = randomNumbers(n);
+            let index = findOne(nums);
+            console.log("\n数组 [ 1, 2, ..., n ] 被打乱后 =", nums);
+            console.log("数字 1 的索引为", index);
+        }
+    })()
     ```
 
 === "TypeScript"
 
     ```typescript title="worst_best_time_complexity.ts"
+    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
+    function randomNumbers(n: number): number[] {
+      // 生成数组 nums = { 1, 2, 3, ..., n }
+      let nums = [...Array(n).keys()].map((i) => i + 1)
+      shuffle(nums)
+      return nums
+    }
 
+    /* 查找数组 nums 中数字 1 所在索引 */
+    function findOne(nums: number[]): number {
+      for (let i = 0; i < nums.length; i++) {
+        if (nums[i] === 1) return i
+      }
+      return -1
+    }
+
+    /* 随机打乱数组元素 */
+    function shuffle(arr: number[]) {
+      let n = arr.length
+      for (let i = 0; i < n; i++) {
+        let j = Math.floor(Math.random() * n)
+        ;[arr[i], arr[j]] = [arr[j], arr[i]]
+      }
+    }
+
+    /* Driver Code */
+    ;(function main() {
+      for (let i = 0; i < 10; i++) {
+        let n = 100
+        let nums = randomNumbers(n)
+        let index = findOne(nums)
+        console.log('\n数组 [ 1, 2, ..., n ] 被打乱后 =', nums)
+        console.log('数字 1 的索引为', index)
+      }
+    })()
     ```
 
 === "C"