diff --git a/.prettierrc b/.prettierrc
new file mode 100644
index 000000000..5a938ce18
--- /dev/null
+++ b/.prettierrc
@@ -0,0 +1,4 @@
+{
+  "tabWidth": 4,
+  "useTabs": false
+}
diff --git a/codes/javascript/chapter_computational_complexity/time_complexity.js b/codes/javascript/chapter_computational_complexity/time_complexity.js
new file mode 100644
index 000000000..2e4688dd2
--- /dev/null
+++ b/codes/javascript/chapter_computational_complexity/time_complexity.js
@@ -0,0 +1,155 @@
+/**
+ * File: time_complexity.js
+ * Created Time: 2023-01-02
+ * Author: RiverTwilight (contact@rene.wang)
+ */
+
+/* 常数阶 */
+function constant(n) {
+    let count = 0;
+    const size = 100000;
+    for (let i = 0; i < size; i++) count++;
+    return count;
+}
+
+/* 线性阶 */
+function linear(n) {
+    let count = 0;
+    for (let i = 0; i < n; i++) count++;
+    return count;
+}
+
+/* 线性阶（遍历数组） */
+function arrayTraversal(nums) {
+    let count = 0;
+    // 循环次数与数组长度成正比
+    for (let i = 0; i < nums.length; i++) {
+        count++;
+    }
+    return count;
+}
+
+/* 平方阶 */
+function quadratic(n) {
+    let count = 0;
+    // 循环次数与数组长度成平方关系
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+            count++;
+        }
+    }
+    return count;
+}
+
+/* 平方阶（冒泡排序） */
+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;
+}
+
+/* 指数阶（循环实现） */
+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;
+}
+
+/* 指数阶（递归实现） */
+function expRecur(n) {
+    if (n == 1) return 1;
+    return expRecur(n - 1) + expRecur(n - 1) + 1;
+}
+
+/* 对数阶（循环实现） */
+function logarithmic(n) {
+    let count = 0;
+    while (n > 1) {
+        n = n / 2;
+        count++;
+    }
+    return count;
+}
+
+/* 对数阶（递归实现） */
+function logRecur(n) {
+    if (n <= 1) return 0;
+    return logRecur(n / 2) + 1;
+}
+
+/* 线性对数阶 */
+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;
+}
+
+/* 阶乘阶（递归实现） */
+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;
+}
+
+/* Driver Code */
+// 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
+const n = 8;
+console.log("输入数据大小 n = " + n);
+
+let count = constant(n);
+console.log("常数阶的计算操作数量 = " + count);
+
+count = linear(n);
+console.log("线性阶的计算操作数量 = " + count);
+count = arrayTraversal(new Array(n));
+console.log("线性阶（遍历数组）的计算操作数量 = " + count);
+
+count = quadratic(n);
+console.log("平方阶的计算操作数量 = " + count);
+let nums = new Array(n);
+for (let i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
+count = bubbleSort(nums);
+console.log("平方阶（冒泡排序）的计算操作数量 = " + count);
+
+count = exponential(n);
+console.log("指数阶（循环实现）的计算操作数量 = " + count);
+count = expRecur(n);
+console.log("指数阶（递归实现）的计算操作数量 = " + count);
+
+count = logarithmic(n);
+console.log("对数阶（循环实现）的计算操作数量 = " + count);
+count = logRecur(n);
+console.log("对数阶（递归实现）的计算操作数量 = " + count);
+
+count = linearLogRecur(n);
+console.log("线性对数阶（递归实现）的计算操作数量 = " + count);
+
+count = factorialRecur(n);
+console.log("阶乘阶（递归实现）的计算操作数量 = " + count);
diff --git a/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js b/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js
new file mode 100644
index 000000000..949e50b04
--- /dev/null
+++ b/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js
@@ -0,0 +1,45 @@
+/*
+ * File: worst_best_time_complexity.js
+ * Created Time: 2023-01-05
+ * Author: RiverTwilight (contact@rene.wang)
+ */
+
+/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
+function randomNumbers(n) {
+    let 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++) {
+        let r = Math.floor(Math.random() * (i + 1));
+        let temp = nums[i];
+        nums[i] = nums[r];
+        nums[r] = temp;
+    }
+    return nums;
+}
+
+/* 查找数组 nums 中数字 1 所在索引 */
+function findOne(nums) {
+    for (let i = 0; i < nums.length; i++) {
+        if (nums[i] === 1) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+/* 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.join(", ") + "]"
+        );
+        console.log("数字 1 的索引为 " + index);
+    }
+}
diff --git a/codes/typescript/chapter_computational_complexity/time_complexity.ts b/codes/typescript/chapter_computational_complexity/time_complexity.ts
new file mode 100644
index 000000000..e5dde67c6
--- /dev/null
+++ b/codes/typescript/chapter_computational_complexity/time_complexity.ts
@@ -0,0 +1,155 @@
+/**
+ * File: time_complexity.ts
+ * Created Time: 2023-01-02
+ * Author: RiverTwilight (contact@rene.wang)
+ */
+
+/* 常数阶 */
+function constant(n: number): number {
+    let count = 0;
+    const size = 100000;
+    for (let i = 0; i < size; i++) count++;
+    return count;
+}
+
+/* 线性阶 */
+function linear(n: number): number {
+    let count = 0;
+    for (let i = 0; i < n; i++) count++;
+    return count;
+}
+
+/* 线性阶（遍历数组） */
+function arrayTraversal(nums: number[]): number {
+    let count = 0;
+    // 循环次数与数组长度成正比
+    for (let i = 0; i < nums.length; i++) {
+        count++;
+    }
+    return count;
+}
+
+/* 平方阶 */
+function quadratic(n: number): number {
+    let count = 0;
+    // 循环次数与数组长度成平方关系
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+            count++;
+        }
+    }
+    return count;
+}
+
+/* 平方阶（冒泡排序） */
+function bubbleSort(nums: number[]): 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;
+}
+
+/* 指数阶（循环实现） */
+function exponential(n: number): 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;
+}
+
+/* 指数阶（递归实现） */
+function expRecur(n: number): number {
+    if (n == 1) return 1;
+    return expRecur(n - 1) + expRecur(n - 1) + 1;
+}
+
+/* 对数阶（循环实现） */
+function logarithmic(n: number): number {
+    let count = 0;
+    while (n > 1) {
+        n = n / 2;
+        count++;
+    }
+    return count;
+}
+
+/* 对数阶（递归实现） */
+function logRecur(n: number): number {
+    if (n <= 1) return 0;
+    return logRecur(n / 2) + 1;
+}
+
+/* 线性对数阶 */
+function linearLogRecur(n: number): number {
+    if (n <= 1) return 1;
+    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
+    for (let i = 0; i < n; i++) {
+        count++;
+    }
+    return count;
+}
+
+/* 阶乘阶（递归实现） */
+function factorialRecur(n: number): number {
+    if (n == 0) return 1;
+    let count = 0;
+    // 从 1 个分裂出 n 个
+    for (let i = 0; i < n; i++) {
+        count += factorialRecur(n - 1);
+    }
+    return count;
+}
+
+/* Driver Code */
+// 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
+const n = 8;
+console.log("输入数据大小 n = " + n);
+
+let count = constant(n);
+console.log("常数阶的计算操作数量 = " + count);
+
+count = linear(n);
+console.log("线性阶的计算操作数量 = " + count);
+count = arrayTraversal(new Array(n));
+console.log("线性阶（遍历数组）的计算操作数量 = " + count);
+
+count = quadratic(n);
+console.log("平方阶的计算操作数量 = " + count);
+var nums = new Array(n);
+for (let i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
+count = bubbleSort(nums);
+console.log("平方阶（冒泡排序）的计算操作数量 = " + count);
+
+count = exponential(n);
+console.log("指数阶（循环实现）的计算操作数量 = " + count);
+count = expRecur(n);
+console.log("指数阶（递归实现）的计算操作数量 = " + count);
+
+count = logarithmic(n);
+console.log("对数阶（循环实现）的计算操作数量 = " + count);
+count = logRecur(n);
+console.log("对数阶（递归实现）的计算操作数量 = " + count);
+
+count = linearLogRecur(n);
+console.log("线性对数阶（递归实现）的计算操作数量 = " + count);
+
+count = factorialRecur(n);
+console.log("阶乘阶（递归实现）的计算操作数量 = " + count);
diff --git a/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts b/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts
new file mode 100644
index 000000000..a7318634f
--- /dev/null
+++ b/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts
@@ -0,0 +1,45 @@
+/*
+ * File: worst_best_time_complexity.ts
+ * Created Time: 2023-01-05
+ * Author: RiverTwilight (contact@rene.wang)
+ */
+
+/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
+function randomNumbers(n: number): number[] {
+    let 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++) {
+        let r = Math.floor(Math.random() * (i + 1));
+        let temp = nums[i];
+        nums[i] = nums[r];
+        nums[r] = temp;
+    }
+    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;
+}
+
+/* Driver Code */
+function main(): void {
+    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.join(", ") + "]"
+        );
+        console.log("数字 1 的索引为 " + index);
+    }
+}
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 42bf2c256..42d43624b 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -79,13 +79,31 @@ $$
 === "JavaScript"
 
     ```js title=""
-
+    // 在某运行平台下
+    function algorithm(n) {
+        var a = 2; // 1 ns
+        a = a + 1; // 1 ns
+        a = a * 2; // 10 ns
+        // 循环 n 次
+        for(let i = 0; i < n; i++) { // 1 ns ，每轮都要执行 i++
+            console.log(0); // 5 ns
+        }
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title=""
-
+    // 在某运行平台下
+    function algorithm(n: number): void {
+        var a: number = 2; // 1 ns
+        a = a + 1; // 1 ns
+        a = a * 2; // 10 ns
+        // 循环 n 次
+        for(let i = 0; i < n; i++) { // 1 ns ，每轮都要执行 i++
+            console.log(0); // 5 ns
+        }
+    }
     ```
 
 === "C"
@@ -229,13 +247,44 @@ $$
 === "JavaScript"
 
     ```js title=""
+    // 算法 A 时间复杂度：常数阶
+    function algorithm_A(n) {
+        console.log(0);
+    }
+    // 算法 B 时间复杂度：线性阶
+    function algorithm_B(n) {
+        for (let i = 0; i < n; i++) {
+            console.log(0);
+        }
+    }
+    // 算法 C 时间复杂度：常数阶
+    function algorithm_C(n) {
+        for (let i = 0; i < 1000000; i++) {
+            console.log(0);
+        }
+    }
 
     ```
 
 === "TypeScript"
 
     ```typescript title=""
-
+    // 算法 A 时间复杂度：常数阶
+    function algorithm_A(n: number): void {
+        console.log(0);
+    }
+    // 算法 B 时间复杂度：线性阶
+    function algorithm_B(n: number): void {
+        for (let i = 0; i < n; i++) {
+            console.log(0);
+        }
+    }
+    // 算法 C 时间复杂度：常数阶
+    function algorithm_C(n: number): void {
+        for (let i = 0; i < 1000000; i++) {
+            console.log(0);
+        }
+    }
     ```
 
 === "C"
@@ -322,7 +371,7 @@ $$
 
 ## 函数渐近上界
 
-设算法「计算操作数量」为 $T(n)$  ，其是一个关于输入数据大小 $n$ 的函数。例如，以下算法的操作数量为
+设算法「计算操作数量」为 $T(n)$ ，其是一个关于输入数据大小 $n$ 的函数。例如，以下算法的操作数量为
 
 $$
 T(n) = 3 + 2n
@@ -378,20 +427,38 @@ $$
         // 循环 n 次
         for i := 0; i < n; i++ {	// +1
             fmt.Println(a)	        // +1
-        }	
+        }
     }
     ```
 
 === "JavaScript"
 
     ```js title=""
+    function algorithm(n){
+        var a = 1; // +1
+        a += 1; // +1
+        a *= 2; // +1
+        // 循环 n 次
+        for(let i = 0; i < n; i++){ // +1（每轮都执行 i ++）
+            console.log(0); // +1
+        }
 
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title=""
+    function algorithm(n: number): void{
+        var a: number = 1; // +1
+        a += 1; // +1
+        a *= 2; // +1
+        // 循环 n 次
+        for(let i = 0; i < n; i++){ // +1（每轮都执行 i ++）
+            console.log(0); // +1
+        }
 
+    }
     ```
 
 === "C"
@@ -562,13 +629,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): void {
+        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"
@@ -730,13 +823,25 @@ $$
 === "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"
@@ -837,13 +942,23 @@ $$
 === "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"
@@ -948,13 +1063,29 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 线性阶（遍历数组） */
+    function arrayTraversal(nums) {
+        let count = 0;
+        // 循环次数与数组长度成正比
+        for (let i = 0; i < nums.length; i++) {
+            count++;
+        }
+        return count;
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 线性阶（遍历数组） */
+    function arrayTraversal(nums: number[]): number {
+        let count = 0;
+        // 循环次数与数组长度成正比
+        for (let i = 0; i < nums.length; i++) {
+            count++;
+        }
+        return count;
+    }
     ```
 
 === "C"
@@ -1069,13 +1200,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): number {
+        let count = 0;
+        // 循环次数与数组长度成平方关系
+        for (let i = 0; i < n; i++) {
+            for (let j = 0; j < n; j++) {
+                count++;
+            }
+        }
+        return count;
+    }
     ```
 
 === "C"
@@ -1230,13 +1381,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[]): 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"
@@ -1392,13 +1577,40 @@ $$
 === "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): 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"
@@ -1510,12 +1722,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): number {
+        if (n == 1) return 1;
+        return expRecur(n - 1) + expRecur(n - 1) + 1;
+    }
 
     ```
 
@@ -1617,13 +1838,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): number {
+        let count = 0;
+        while (n > 1) {
+            n = n / 2;
+            count++;
+        }
+        return count;
+    }
     ```
 
 === "C"
@@ -1721,13 +1958,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): number {
+        if (n <= 1) return 0;
+        return logRecur(n / 2) + 1;
+    }
     ```
 
 === "C"
@@ -1775,7 +2020,7 @@ $$
     /* 线性对数阶 */
     int linearLogRecur(float n) {
         if (n <= 1) return 1;
-        int count = linearLogRecur(n / 2) + 
+        int count = linearLogRecur(n / 2) +
                     linearLogRecur(n / 2);
         for (int i = 0; i < n; i++) {
             count++;
@@ -1790,7 +2035,7 @@ $$
     /* 线性对数阶 */
     int linearLogRecur(float n) {
         if (n <= 1) return 1;
-        int count = linearLogRecur(n / 2) + 
+        int count = linearLogRecur(n / 2) +
                     linearLogRecur(n / 2);
         for (int i = 0; i < n; i++) {
             count++;
@@ -1832,13 +2077,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): 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"
@@ -1966,13 +2227,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): 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"
@@ -2056,7 +2335,7 @@ $$
             }
             return res;
         }
-    
+
         /* 查找数组 nums 中数字 1 所在索引 */
         int findOne(int[] nums) {
             for (int i = 0; i < nums.length; i++) {
@@ -2065,7 +2344,7 @@ $$
             }
             return -1;
         }
-        
+
         /* Driver Code */
         public void main(String[] args) {
             for (int i = 0; i < 10; i++) {
@@ -2125,7 +2404,7 @@ $$
     ```python title="worst_best_time_complexity.py"
     """ 生成一个数组，元素为: 1, 2, ..., n ，顺序被打乱 """
     def random_numbers(n):
-        # 生成数组 nums =: 1, 2, 3, ..., n 
+        # 生成数组 nums =: 1, 2, 3, ..., n
         nums = [i for i in range(1, n + 1)]
         # 随机打乱数组元素
         random.shuffle(nums)
@@ -2190,13 +2469,89 @@ $$
 === "JavaScript"
 
     ```js title="worst_best_time_complexity.js"
+    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
+    function randomNumbers(n) {
+        let 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++) {
+            let r = Math.floor(Math.random() * (i + 1));
+            let temp = nums[i];
+            nums[i] = nums[r];
+            nums[r] = temp;
+        }
+        return nums;
+    }
 
+    /* 查找数组 nums 中数字 1 所在索引 */
+    function findOne(nums) {
+        for (let i = 0; i < nums.length; i++) {
+            if (nums[i] === 1) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /* 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.join(", ") + "]"
+            );
+            console.log("数字 1 的索引为 " + index);
+        }
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="worst_best_time_complexity.ts"
+    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
+    function randomNumbers(n: number): number[] {
+        let 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++) {
+            let r = Math.floor(Math.random() * (i + 1));
+            let temp = nums[i];
+            nums[i] = nums[r];
+            nums[r] = temp;
+        }
+        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;
+    }
+
+    /* Driver Code */
+    function main(): void {
+        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.join(", ") + "]"
+            );
+            console.log("数字 1 的索引为 " + index);
+        }
+    }
     ```
 
 === "C"