Merge pull request #98 from justin-tse/dev-sorting-js

Add the TypeScript code and docs for Chapter of Sorting

codes/typescript/chapter_sorting/bubble_sort.ts

@@ -0,0 +1,51 @@
+/**
+ * File: quick_sort.ts
+ * Created Time: 2022-12-12
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* 冒泡排序 */
+function bubbleSort(nums: number[]): void {
+    // 外循环：待排序元素数量为 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;
+            }
+        }
+    }
+}
+
+/* 冒泡排序（标志优化）*/
+function bubbleSortWithFlag(nums: number[]): void {
+    // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+    for (let i = nums.length - 1; i > 0; i--) {
+        let flag = false; // 初始化标志位
+        // 内循环：冒泡操作
+        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;
+                flag = true; // 记录交换元素
+            }
+        }
+        if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出
+    }
+}
+
+/* Driver Code */
+const nums = [4, 1, 3, 1, 5, 2];
+bubbleSort(nums);
+console.log('排序后数组 nums =', nums);
+
+const nums1 = [4, 1, 3, 1, 5, 2];
+bubbleSortWithFlag(nums1);
+console.log('排序后数组 nums =', nums1);
+
+export {};

codes/typescript/chapter_sorting/insertion_sort.ts

@@ -0,0 +1,27 @@
+/**
+ * File: quick_sort.ts
+ * Created Time: 2022-12-12
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* 插入排序 */
+function insertionSort(nums: number[]): void {
+    // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+    for (let i = 1; i < nums.length; i++) {
+        const base = nums[i];
+        let j = i - 1;
+        // 内循环：将 base 插入到左边的正确位置
+        while (j >= 0 && nums[j] > base) {
+            nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
+            j--;
+        }
+        nums[j + 1] = base; // 2. 将 base 赋值到正确位置
+    }
+}
+
+/* Driver Code */
+const nums = [4, 1, 3, 1, 5, 2];
+insertionSort(nums);
+console.log('排序后数组 nums =', nums);
+
+export {};

codes/typescript/chapter_sorting/merge_sort.ts

@@ -0,0 +1,53 @@
+/**
+ * File: quick_sort.ts
+ * Created Time: 2022-12-12
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/**
+ * 合并左子数组和右子数组
+ * 左子数组区间 [left, mid]
+ * 右子数组区间 [mid + 1, right]
+ */
+function merge(nums: number[], left: number, mid: number, right: number): void {
+    // 初始化辅助数组
+    let tmp = nums.slice(left, right + 1);
+    // 左子数组的起始索引和结束索引
+    let leftStart = left - left, leftEnd = mid - left;
+    // 右子数组的起始索引和结束索引
+    let rightStart = mid + 1 - left, rightEnd = right - left;
+    // i, j 分别指向左子数组、右子数组的首元素
+    let i = leftStart, j = rightStart;
+    // 通过覆盖原数组 nums 来合并左子数组和右子数组
+    for (let k = left; k <= right; k++) {
+        // 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
+        if (i > leftEnd) {
+            nums[k] = tmp[j++];
+            // 否则，若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+        } else if (j > rightEnd || tmp[i] <= tmp[j]) {
+            nums[k] = tmp[i++];
+            // 否则，若 “左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+        } else {
+            nums[k] = tmp[j++];
+        }
+    }
+}
+
+/* 归并排序 */
+function mergeSort(nums: number[], left: number, right: number): void {
+    // 终止条件
+    if (left >= right) return; // 当子数组长度为 1 时终止递归
+    // 划分阶段
+    let mid = Math.floor((left + right) / 2); // 计算中点
+    mergeSort(nums, left, mid); // 递归左子数组
+    mergeSort(nums, mid + 1, right); // 递归右子数组
+    // 合并阶段
+    merge(nums, left, mid, right);
+}
+
+/* Driver Code */
+const nums = [7, 3, 2, 6, 0, 1, 5, 4];
+mergeSort(nums, 0, nums.length - 1);
+console.log('归并排序完成后 nums =', nums);
+
+export {};

codes/typescript/chapter_sorting/quick_sort.ts

@@ -0,0 +1,168 @@
+/**
+ * File: quick_sort.ts
+ * Created Time: 2022-12-12
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* 快速排序类 */
+class QuickSort {
+    /* 元素交换 */
+    swap(nums: number[], i: number, j: number): void {
+        let tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    /* 哨兵划分 */
+    partition(nums: number[], left: number, right: number): number {
+        // 以 nums[left] 作为基准数
+        let i = left, j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left]) {
+                j -= 1; // 从右向左找首个小于基准数的元素
+            }
+            while (i < j && nums[i] <= nums[left]) {
+                i += 1; // 从左向右找首个大于基准数的元素
+            }
+            // 元素交换
+            this.swap(nums, i, j); // 交换这两个元素
+        }
+        this.swap(nums, i, left); // 将基准数交换至两子数组的分界线
+        return i; // 返回基准数的索引
+    }
+
+    /* 快速排序 */
+    quickSort(nums: number[], left: number, right: number): void {
+        // 子数组长度为 1 时终止递归
+        if (left >= right) {
+            return;
+        }
+        // 哨兵划分
+        const pivot = this.partition(nums, left, right);
+        // 递归左子数组、右子数组
+        this.quickSort(nums, left, pivot - 1);
+        this.quickSort(nums, pivot + 1, right);
+    }
+}
+
+/* 快速排序类（中位基准数优化） */
+class QuickSortMedian {
+    /* 元素交换 */
+    swap(nums: number[], i: number, j: number): void {
+        let tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    /* 选取三个元素的中位数 */
+    medianThree(nums: number[], left: number, mid: number, right: number): number {
+        // 使用了异或操作来简化代码
+        // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
+        if (Number(nums[left] > nums[mid]) ^ Number(nums[left] > nums[right])) {
+            return left;
+        } else if (Number(nums[mid] < nums[left]) ^ Number(nums[mid] < nums[right])) {
+            return mid;
+        } else {
+            return right;
+        }
+    }
+
+    /* 哨兵划分（三数取中值） */
+    partition(nums: number[], left: number, right: number): number {
+        // 选取三个候选元素的中位数
+        let med = this.medianThree(nums, left, Math.floor((left + right) / 2), right);
+        // 将中位数交换至数组最左端
+        this.swap(nums, left, med);
+        // 以 nums[left] 作为基准数
+        let i = left, j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left]) {
+                j--; // 从右向左找首个小于基准数的元素
+            }
+            while (i < j && nums[i] <= nums[left]) {
+                i++; // 从左向右找首个大于基准数的元素
+            }
+            this.swap(nums, i, j); // 交换这两个元素
+        }
+        this.swap(nums, i, left); // 将基准数交换至两子数组的分界线
+        return i; // 返回基准数的索引
+    }
+
+    /* 快速排序 */
+    quickSort(nums: number[], left: number, right: number): void {
+        // 子数组长度为 1 时终止递归
+        if (left >= right) {
+            return;
+        }
+        // 哨兵划分
+        const pivot = this.partition(nums, left, right);
+        // 递归左子数组、右子数组
+        this.quickSort(nums, left, pivot - 1);
+        this.quickSort(nums, pivot + 1, right);
+    }
+}
+
+/* 快速排序类（尾递归优化） */
+class QuickSortTailCall {
+    /* 元素交换 */
+    swap(nums: number[], i: number, j: number): void {
+        let tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    /* 哨兵划分 */
+    partition(nums: number[], left: number, right: number): number {
+        // 以 nums[left] 作为基准数
+        let i = left, j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left]) {
+                j--; // 从右向左找首个小于基准数的元素
+            }
+            while (i < j && nums[i] <= nums[left]) {
+                i++; // 从左向右找首个大于基准数的元素
+            }
+            this.swap(nums, i, j); // 交换这两个元素
+        }
+        this.swap(nums, i, left); // 将基准数交换至两子数组的分界线
+        return i; // 返回基准数的索引
+    }
+
+    /* 快速排序（尾递归优化） */
+    quickSort(nums: number[], left: number, right: number): void {
+        // 子数组长度为 1 时终止
+        while (left < right) {
+            // 哨兵划分操作
+            let pivot = this.partition(nums, left, right);
+            // 对两个子数组中较短的那个执行快排
+            if (pivot - left < right - pivot) {
+                this.quickSort(nums, left, pivot - 1); // 递归排序左子数组
+                left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
+            } else {
+                this.quickSort(nums, pivot + 1, right); // 递归排序右子数组
+                right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
+            }
+        }
+    }
+}
+
+/* Driver Code */
+/* 快速排序  */
+const nums = [4, 1, 3, 1, 5, 2];
+const quickSort = new QuickSort();
+quickSort.quickSort(nums, 0, nums.length - 1);
+console.log('快速排序完成后 nums =', nums);
+
+/* 快速排序（中位基准数优化） */
+const nums1 = [4, 1, 3, 1, 5, 2];
+const quickSortMedian = new QuickSort();
+quickSortMedian.quickSort(nums1, 0, nums1.length - 1);
+console.log('快速排序（中位基准数优化）完成后 nums =', nums1);
+
+/* 快速排序（尾递归优化） */
+const nums2 = [4, 1, 3, 1, 5, 2];
+const quickSortTailCall = new QuickSort();
+quickSortTailCall.quickSort(nums2, 0, nums2.length - 1);
+console.log('快速排序（尾递归优化）完成后 nums =', nums2);
+
+export {};

docs/chapter_sorting/bubble_sort.md

@@ -150,7 +150,21 @@ comments: true
 === "TypeScript"
 
     ```typescript title="bubble_sort.ts"
-
+    /* 冒泡排序 */
+    function bubbleSort(nums: number[]): void {
+        // 外循环：待排序元素数量为 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;
+                }
+            }
+        }
+    }
     ```
 
 === "C"
@@ -297,7 +311,24 @@ comments: true
 === "TypeScript"
 
     ```typescript title="bubble_sort.ts"
-
+    /* 冒泡排序（标志优化）*/
+    function bubbleSortWithFlag(nums: number[]): void {
+        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        for (let i = nums.length - 1; i > 0; i--) {
+            let flag = false; // 初始化标志位
+            // 内循环：冒泡操作
+            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;
+                    flag = true;  // 记录交换元素
+                }
+            }
+            if (!flag) break;     // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
     ```
 
 === "C"

docs/chapter_sorting/insertion_sort.md

@@ -116,7 +116,20 @@ comments: true
 === "TypeScript"
 
     ```typescript title="insertion_sort.ts"
-
+    /* 插入排序 */
+    function insertionSort(nums: number[]): void {
+        // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+        for (let i = 1; i < nums.length; i++) {
+            const base = nums[i];
+            let j = i - 1;
+            // 内循环：将 base 插入到左边的正确位置
+            while (j >= 0 && nums[j] > base) {
+                nums[j + 1] = nums[j];  // 1. 将 nums[j] 向右移动一位
+                j--;
+            }
+            nums[j + 1] = base;         // 2. 将 base 赋值到正确位置
+        }
+    }
     ```
 
 === "C"

docs/chapter_sorting/merge_sort.md

@@ -246,7 +246,46 @@ comments: true
 === "TypeScript"
 
     ```typescript title="merge_sort.ts"
+    /**
+     * 合并左子数组和右子数组
+     * 左子数组区间 [left, mid]
+     * 右子数组区间 [mid + 1, right]
+     */
+    function merge(nums: number[], left: number, mid: number, right: number): void {
+        // 初始化辅助数组
+        let tmp = nums.slice(left, right + 1);
+        // 左子数组的起始索引和结束索引
+        let leftStart = left - left, leftEnd = mid - left;
+        // 右子数组的起始索引和结束索引
+        let rightStart = mid + 1 - left, rightEnd = right - left;
+        // i, j 分别指向左子数组、右子数组的首元素
+        let i = leftStart, j = rightStart;
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for (let k = left; k <= right; k++) {
+            // 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if (i > leftEnd) {
+                nums[k] = tmp[j++];
+                // 否则，若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+            } else if (j > rightEnd || tmp[i] <= tmp[j]) {
+                nums[k] = tmp[i++];
+                // 否则，若 “左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            } else {
+                nums[k] = tmp[j++];
+            }
+        }
+    }
 
+    /* 归并排序 */
+    function mergeSort(nums: number[], left: number, right: number): void {
+        // 终止条件
+        if (left >= right) return; // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        let mid = Math.floor((left + right) / 2); // 计算中点
+        mergeSort(nums, left, mid); // 递归左子数组
+        mergeSort(nums, mid + 1, right); // 递归右子数组
+        // 合并阶段
+        merge(nums, left, mid, right);
+    }
     ```
 
 === "C"

docs/chapter_sorting/quick_sort.md

@@ -161,7 +161,30 @@ comments: true
 === "TypeScript"
 
     ```typescript title="quick_sort.ts"
+    /* 元素交换 */
+    function swap(nums: number[], i: number, j: number): void {
+        let tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
 
+    /* 哨兵划分 */
+    function partition(nums: number[], left: number, right: number): number {
+        // 以 nums[left] 作为基准数
+        let i = left, j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left]) {
+                j -= 1; // 从右向左找首个小于基准数的元素
+            }
+            while (i < j && nums[i] <= nums[left]) {
+                i += 1; // 从左向右找首个大于基准数的元素
+            }
+            // 元素交换
+            swap(nums, i, j); // 交换这两个元素
+        }
+        swap(nums, i, left); // 将基准数交换至两子数组的分界线
+        return i; // 返回基准数的索引
+    }
     ```
 
 === "C"
@@ -274,7 +297,18 @@ comments: true
 === "TypeScript"
 
     ```typescript title="quick_sort.ts"
-
+    /* 快速排序 */
+    function quickSort(nums: number[], left: number, right: number): void {
+        // 子数组长度为 1 时终止递归
+        if (left >= right) {
+            return;
+        }
+        // 哨兵划分
+        const pivot = partition(nums, left, right);
+        // 递归左子数组、右子数组
+        quickSort(nums, left, pivot - 1);
+        quickSort(nums, pivot + 1, right);
+    }
     ```
 
 === "C"
@@ -447,7 +481,27 @@ comments: true
 === "TypeScript"
 
     ```typescript title="quick_sort.ts"
+    /* 选取三个元素的中位数 */
+    function medianThree(nums: number[], left: number, mid: number, right: number): number {
+        // 使用了异或操作来简化代码
+        // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
+        if (Number(nums[left] > nums[mid]) ^ Number(nums[left] > nums[right])) {
+            return left;
+        } else if (Number(nums[mid] < nums[left]) ^ Number(nums[mid] < nums[right])) {
+            return mid;
+        } else {
+            return right;
+        }
+    }
 
+    /* 哨兵划分（三数取中值） */
+    function partition(nums: number[], left: number, right: number): number {
+        // 选取三个候选元素的中位数
+        let med = medianThree(nums, left, Math.floor((left + right) / 2), right);
+        // 将中位数交换至数组最左端
+        swap(nums, left, med);
+        // 以 nums[left] 作为基准数
+        // 下同省略...
     ```
 
 === "C"
@@ -553,7 +607,7 @@ comments: true
 
     ```js title="quick_sort.js"
     /* 快速排序（尾递归优化） */
-    quickSort(nums, left, right) {
+    function quickSort(nums, left, right) {
         // 子数组长度为 1 时终止
         while (left < right) {
             // 哨兵划分操作
@@ -573,7 +627,22 @@ comments: true
 === "TypeScript"
 
     ```typescript title="quick_sort.ts"
-
+    /* 快速排序（尾递归优化） */
+    function quickSort(nums: number[], left: number, right: number): void {
+        // 子数组长度为 1 时终止
+        while (left < right) {
+            // 哨兵划分操作
+            let pivot = partition(nums, left, right);
+            // 对两个子数组中较短的那个执行快排
+            if (pivot - left < right - pivot) {
+                quickSort(nums, left, pivot - 1); // 递归排序左子数组
+                left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
+            } else {
+                quickSort(nums, pivot + 1, right); // 递归排序右子数组
+                right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
+            }
+        }
+    }
     ```
 
 === "C"