Fix some codes and a figure.

codes/javascript/chapter_searching/binary_search_edge.js

@@ -5,8 +5,9 @@
  */
 
 /* 二分查找最左一个元素 */
-function binary_search_left_edge(nums, target) {
-    let i = 0, j = nums.length - 1;  // 初始化双闭区间 [0, n-1]
+function binarySearchLeftEdge(nums, target) {
+    let i = 0,
+        j = nums.length - 1; // 初始化双闭区间 [0, n-1]
     while (i <= j) {
         let m = Math.floor((i + j) / 2); // 计算中点索引 m
         if (nums[m] < target) {
@@ -24,8 +25,9 @@ function binary_search_left_edge(nums, target) {
 }
 
 /* 二分查找最右一个元素 */
-function binary_search_right_edge(nums, target) {
-    let i = 0, j = nums.length - 1;  // 初始化双闭区间 [0, n-1]
+function binarySearchRightEdge(nums, target) {
+    let i = 0,
+        j = nums.length - 1; // 初始化双闭区间 [0, n-1]
     while (i <= j) {
         let m = Math.floor((i + j) / 2); // 计算中点索引 m
         if (nums[m] < target) {
@@ -47,9 +49,9 @@ let target = 6;
 const nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15];
 
 // 二分查找最左一个元素
-let index_left = binary_search_left_edge(nums, target);
-console.log("数组中最左一个元素 6 的索引 = ", index_left);
+let index_left = binarySearchLeftEdge(nums, target);
+console.log('数组中最左一个元素 6 的索引 = ', index_left);
 
 // 二分查找最右一个元素
-let index_right = binary_search_right_edge(nums, target);
-console.log("数组中最右一个元素 6 的索引 = ", index_right);
+let index_right = binarySearchRightEdge(nums, target);
+console.log('数组中最右一个元素 6 的索引 = ', index_right);

codes/javascript/chapter_sorting/heap_sort.js

@@ -5,7 +5,7 @@
  */
 
 /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
-function sift_down(nums, n, i) {
+function siftDown(nums, n, i) {
     while (true) {
         // 判断节点 i, l, r 中值最大的节点，记为 ma
         let l = 2 * i + 1;
@@ -29,21 +29,21 @@ function sift_down(nums, n, i) {
 }
 
 /* 堆排序 */
-function heap_sort(nums) {
+function heapSort(nums) {
     // 建堆操作：堆化除叶节点以外的其他所有节点
     for (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {
-        sift_down(nums, nums.length, i);
+        siftDown(nums, nums.length, i);
     }
     // 从堆中提取最大元素，循环 n-1 轮
     for (let i = nums.length - 1; i > 0; i--) {
         // 交换根节点与最右叶节点（即交换首元素与尾元素）
         [nums[0], nums[i]] = [nums[i], nums[0]];
         // 以根节点为起点，从顶至底进行堆化
-        sift_down(nums, i, 0);
+        siftDown(nums, i, 0);
     }
 }
 
 /* Driver Code */
 const nums = [4, 1, 3, 1, 5, 2];
-heap_sort(nums);
-console.log("堆排序完成后 nums =", nums);
+heapSort(nums);
+console.log('堆排序完成后 nums =', nums);

codes/javascript/chapter_sorting/selection_sort.js

@@ -5,7 +5,7 @@
  */
 
 /* 选择排序 */
-function selection_sort(nums) {
+function selectionSort(nums) {
     let n = nums.length;
     // 外循环：未排序区间为 [i, n-1]
     for (let i = 0; i < n - 1; i++) {
@@ -23,5 +23,5 @@ function selection_sort(nums) {
 
 /* Driver Code */
 const nums = [4, 1, 3, 1, 5, 2];
-selection_sort(nums);
-console.log("选择排序完成后 nums =", nums);
+selectionSort(nums);
+console.log('选择排序完成后 nums =', nums);

codes/typescript/chapter_searching/binary_search_edge.ts

@@ -5,7 +5,7 @@
  */
 
 /* 二分查找最左一个元素 */
-function binary_search_left_edge(nums: number[], target: number): number {
+function binarySearchLeftEdge(nums: number[], target: number): number {
     let i = 0, j = nums.length - 1;  // 初始化双闭区间 [0, n-1]
     while (i <= j) {
         let m = Math.floor((i + j) / 2);  // 计算中点索引 m
@@ -24,7 +24,7 @@ function binary_search_left_edge(nums: number[], target: number): number {
 }
 
 /* 二分查找最右一个元素 */
-function binary_search_right_edge(nums: number[], target: number): number {
+function binarySearchRightEdge(nums: number[], target: number): number {
     let i = 0, j = nums.length - 1;  // 初始化双闭区间 [0, n-1]
     while (i <= j) {
         let m = Math.floor((i + j) / 2);  // 计算中点索引 m
@@ -47,9 +47,9 @@ let target: number = 6;
 const nums: number[] = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15];
 
 // 二分查找最左一个元素
-let index_left: number = binary_search_left_edge(nums, target);
+let index_left: number = binarySearchLeftEdge(nums, target);
 console.log("数组中最左一个元素 6 的索引 = ", index_left);
 
 // 二分查找最右一个元素
-let index_right: number = binary_search_right_edge(nums, target);
+let index_right: number = binarySearchRightEdge(nums, target);
 console.log("数组中最右一个元素 6 的索引 = ", index_right);

codes/typescript/chapter_sorting/heap_sort.ts

@@ -5,7 +5,7 @@
  */
 
 /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
-function sift_down(nums: number[], n: number, i: number): void {
+function siftDown(nums: number[], n: number, i: number): void {
     while (true) {
         // 判断节点 i, l, r 中值最大的节点，记为 ma
         let l = 2 * i + 1;
@@ -29,23 +29,23 @@ function sift_down(nums: number[], n: number, i: number): void {
 }
 
 /* 堆排序 */
-function heap_sort(nums: number[]): void {
+function heapSort(nums: number[]): void {
     // 建堆操作：堆化除叶节点以外的其他所有节点
     for (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {
-        sift_down(nums, nums.length, i);
+        siftDown(nums, nums.length, i);
     }
     // 从堆中提取最大元素，循环 n-1 轮
     for (let i = nums.length - 1; i > 0; i--) {
         // 交换根节点与最右叶节点（即交换首元素与尾元素）
         [nums[0], nums[i]] = [nums[i], nums[0]];
         // 以根节点为起点，从顶至底进行堆化
-        sift_down(nums, i, 0);
+        siftDown(nums, i, 0);
     }
 }
 
 /* Driver Code */
 const nums: number[] = [4, 1, 3, 1, 5, 2];
-heap_sort(nums);
-console.log("堆排序完成后 nums =", nums);
+heapSort(nums);
+console.log('堆排序完成后 nums =', nums);
 
-export { };
+export {};

codes/typescript/chapter_sorting/selection_sort.ts

@@ -5,7 +5,7 @@
  */
 
 /* 选择排序 */
-function selection_sort(nums: number[]): void {
+function selectionSort(nums: number[]): void {
     let n = nums.length;
     // 外循环：未排序区间为 [i, n-1]
     for (let i = 0; i < n - 1; i++) {
@@ -23,7 +23,7 @@ function selection_sort(nums: number[]): void {
 
 /* Driver Code */
 const nums: number[] = [4, 1, 3, 1, 5, 2];
-selection_sort(nums);
-console.log("选择排序完成后 nums =", nums);
+selectionSort(nums);
+console.log('选择排序完成后 nums =', nums);
 
-export { };
+export {};

docs/chapter_computational_complexity/time_complexity.md

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