feat: add solutions to lc problem: No.0912

No.0912.Sort an Array

Author: yanglbme

solution/0900-0999/0912.Sort an Array/README.md

@@ -89,31 +89,29 @@ class Solution:
 ```python
 class Solution:
     def sortArray(self, nums: List[int]) -> List[int]:
-        def merge_sort(nums, left, right):
-            if left >= right:
+        def merge_sort(l, r):
+            if l >= r:
                 return
-            mid = (left + right) >> 1
-            merge_sort(nums, left, mid)
-            merge_sort(nums, mid + 1, right)
-            i, j = left, mid + 1
+            mid = (l + r) >> 1
+            merge_sort(l, mid)
+            merge_sort(mid + 1, r)
+            i, j = l, mid + 1
             tmp = []
-            while i <= mid and j <= right:
+            while i <= mid and j <= r:
                 if nums[i] <= nums[j]:
                     tmp.append(nums[i])
                     i += 1
                 else:
                     tmp.append(nums[j])
                     j += 1
-            while i <= mid:
-                tmp.append(nums[i])
-                i += 1
-            while j <= right:
-                tmp.append(nums[j])
-                j += 1
-            for i in range(left, right + 1):
-                nums[i] = tmp[i - left]
-
-        merge_sort(nums, 0, len(nums) - 1)
+            if i <= mid:
+                tmp.extend(nums[i:mid + 1])
+            if j <= r:
+                tmp.extend(nums[j: r + 1])
+            for i in range(l, r + 1):
+                nums[i] = tmp[i - l]
+        
+        merge_sort(0, len(nums) - 1)
         return nums
 ```
 
@@ -197,21 +195,24 @@ class Solution {
 
 ```java
 class Solution {
+    private int[] nums;
+
     public int[] sortArray(int[] nums) {
-        mergeSort(nums, 0, nums.length - 1);
+        this.nums = nums;
+        mergeSort(0, nums.length - 1);
         return nums;
     }
 
-    private void mergeSort(int[] nums, int left, int right) {
-        if (left >= right) {
+    private void mergeSort(int l, int r) {
+        if (l >= r) {
             return;
         }
-        int mid = (left + right) >> 1;
-        mergeSort(nums, left, mid);
-        mergeSort(nums, mid + 1, right);
-        int i = left, j = mid + 1, k = 0;
-        int[] tmp = new int[right - left + 1];
-        while (i <= mid && j <= right) {
+        int mid = (l + r) >> 1;
+        mergeSort(l, mid);
+        mergeSort(mid + 1, r);
+        int i = l, j = mid + 1, k = 0;
+        int[] tmp = new int[r - l + 1];
+        while (i <= mid && j <= r) {
             if (nums[i] <= nums[j]) {
                 tmp[k++] = nums[i++];
             } else {
@@ -221,11 +222,11 @@ class Solution {
         while (i <= mid) {
             tmp[k++] = nums[i++];
         }
-        while (j <= right) {
+        while (j <= r) {
             tmp[k++] = nums[j++];
         }
-        for (i = left; i <= right; ++i) {
-            nums[i] = tmp[i - left];
+        for (i = l; i <= r; ++i) {
+            nums[i] = tmp[i - l];
         }
     }
 }
@@ -269,26 +270,35 @@ public:
 class Solution {
 public:
     vector<int> sortArray(vector<int>& nums) {
-        merge_sort(nums, 0, nums.size() - 1);
+        function<void(int, int)> merge_sort = [&](int l, int r) {
+            if (l >= r) {
+                return;
+            }
+            int mid = (l + r) >> 1;
+            merge_sort(l, mid);
+            merge_sort(mid + 1, r);
+            int i = l, j = mid + 1, k = 0;
+            int tmp[r - l + 1];
+            while (i <= mid && j <= r) {
+                if (nums[i] <= nums[j]) {
+                    tmp[k++] = nums[i++];
+                } else {
+                    tmp[k++] = nums[j++];
+                }
+            }
+            while (i <= mid) {
+                tmp[k++] = nums[i++];
+            }
+            while (j <= r) {
+                tmp[k++] = nums[j++];
+            }
+            for (i = l; i <= r; ++i) {
+                nums[i] = tmp[i - l];
+            }
+        };
+        merge_sort(0, nums.size() - 1);
         return nums;
     }
-
-    void merge_sort(vector<int>& nums, int left, int right) {
-        if (left >= right) return;
-        int mid = left + right >> 1;
-        merge_sort(nums, left, mid);
-        merge_sort(nums, mid + 1, right);
-        int i = left, j = mid + 1, k = 0;
-        vector<int> tmp(right - left + 1);
-        while (i <= mid && j <= right)
-        {
-            if (nums[i] <= nums[j]) tmp[k++] = nums[i++];
-            else tmp[k++] = nums[j++];
-        }
-        while (i <= mid) tmp[k++] = nums[i++];
-        while (j <= right) tmp[k++] = nums[j++];
-        for (i = left; i <= right; ++i) nums[i] = tmp[i - left];
-    }
 };
 ```
 
@@ -302,12 +312,12 @@ func sortArray(nums []int) []int {
 	return nums
 }
 
-func quickSort(nums []int, left, right int) {
-	if left >= right {
+func quickSort(nums []int, l, r int) {
+	if l >= r {
 		return
 	}
-	i, j := left-1, right+1
-	x := nums[(left+right)>>1]
+	i, j := l-1, r+1
+	x := nums[(l+r)>>1]
 	for i < j {
 		for {
 			i++
@@ -325,8 +335,8 @@ func quickSort(nums []int, left, right int) {
 			nums[i], nums[j] = nums[j], nums[i]
 		}
 	}
-	quickSort(nums, left, j)
-	quickSort(nums, j+1, right)
+	quickSort(nums, l, j)
+	quickSort(nums, j+1, r)
 }
 ```
 
@@ -338,16 +348,16 @@ func sortArray(nums []int) []int {
 	return nums
 }
 
-func mergeSort(nums []int, left, right int) {
-	if left >= right {
+func mergeSort(nums []int, l, r int) {
+	if l >= r {
 		return
 	}
-	mid := (left + right) >> 1
-	mergeSort(nums, left, mid)
-	mergeSort(nums, mid+1, right)
-	i, j, k := left, mid+1, 0
-	tmp := make([]int, right-left+1)
-	for i <= mid && j <= right {
+	mid := (l + r) >> 1
+	mergeSort(nums, l, mid)
+	mergeSort(nums, mid+1, r)
+	i, j, k := l, mid+1, 0
+	tmp := make([]int, r-l+1)
+	for i <= mid && j <= r {
 		if nums[i] <= nums[j] {
 			tmp[k] = nums[i]
 			i++
@@ -357,22 +367,85 @@ func mergeSort(nums []int, left, right int) {
 		}
 		k++
 	}
-	for i <= mid {
+	for ; i <= mid; i++ {
 		tmp[k] = nums[i]
-		i++
 		k++
 	}
-	for j <= right {
+	for ; j <= r; j++ {
 		tmp[k] = nums[j]
-		j++
 		k++
 	}
-	for i = left; i <= right; i++ {
-		nums[i] = tmp[i-left]
+	for i = l; i <= r; i++ {
+		nums[i] = tmp[i-l]
 	}
 }
 ```
 
+### **TypeScript**
+
+快速排序：
+
+```ts
+function sortArray(nums: number[]): number[] {
+    function quickSort(l: number, r: number) {
+        if (l >= r) {
+            return;
+        }
+        let i = l - 1;
+        let j = r + 1;
+        const x = nums[(l + r) >> 1];
+        while (i < j) {
+            while (nums[++i] < x);
+            while (nums[--j] > x);
+            if (i < j) {
+                [nums[i], nums[j]] = [nums[j], nums[i]];
+            }
+        }
+        quickSort(l, j);
+        quickSort(j + 1, r);
+    }
+    const n = nums.length;
+    quickSort(0, n - 1);
+    return nums;
+}
+```
+
+归并排序：
+
+```ts
+function sortArray(nums: number[]): number[] {
+    function mergetSort(l: number, r: number) {
+        if (l >= r) {
+            return;
+        }
+        const mid = (l + r) >> 1;
+        mergetSort(l, mid);
+        mergetSort(mid + 1, r);
+        let [i, j, k] = [l, mid + 1, 0];
+        while (i <= mid && j <= r) {
+            if (nums[i] <= nums[j]) {
+                tmp[k++] = nums[i++];
+            } else {
+                tmp[k++] = nums[j++];
+            }
+        }
+        while (i <= mid) {
+            tmp[k++] = nums[i++];
+        }
+        while (j <= r) {
+            tmp[k++] = nums[j++];
+        }
+        for (i = l, j = 0; i <= r; ++i, ++j) {
+            nums[i] = tmp[j];
+        }
+    }
+    const n = nums.length;
+    let tmp = new Array(n).fill(0);
+    mergetSort(0, n - 1);
+    return nums;
+}
+```
+
 ### **JavaScript**
 
 快速排序：
@@ -383,22 +456,22 @@ func mergeSort(nums []int, left, right int) {
  * @return {number[]}
  */
 var sortArray = function (nums) {
-    function quickSort(left, right) {
-        if (left >= right) {
+    function quickSort(l, r) {
+        if (l >= r) {
             return;
         }
-        let i = left - 1;
-        let j = right + 1;
-        const x = nums[(left + right) >> 1];
+        let i = l - 1;
+        let j = r + 1;
+        const x = nums[(l + r) >> 1];
         while (i < j) {
             while (nums[++i] < x);
             while (nums[--j] > x);
             if (i < j) {
                 [nums[i], nums[j]] = [nums[j], nums[i]];
             }
         }
-        quickSort(left, j);
-        quickSort(j + 1, right);
+        quickSort(l, j);
+        quickSort(j + 1, r);
     }
     const n = nums.length;
     quickSort(0, n - 1);
@@ -414,15 +487,15 @@ var sortArray = function (nums) {
  * @return {number[]}
  */
 var sortArray = function (nums) {
-    function mergetSort(left, right) {
-        if (left >= right) {
+    function mergetSort(l, r) {
+        if (l >= r) {
             return;
         }
-        const mid = (left + right) >> 1;
-        mergetSort(left, mid);
-        mergetSort(mid + 1, right);
-        let [i, j, k] = [left, mid + 1, 0];
-        while (i <= mid && j <= right) {
+        const mid = (l + r) >> 1;
+        mergetSort(l, mid);
+        mergetSort(mid + 1, r);
+        let [i, j, k] = [l, mid + 1, 0];
+        while (i <= mid && j <= r) {
             if (nums[i] <= nums[j]) {
                 tmp[k++] = nums[i++];
             } else {
@@ -432,10 +505,10 @@ var sortArray = function (nums) {
         while (i <= mid) {
             tmp[k++] = nums[i++];
         }
-        while (j <= right) {
+        while (j <= r) {
             tmp[k++] = nums[j++];
         }
-        for (i = left, j = 0; i <= right; ++i, ++j) {
+        for (i = l, j = 0; i <= r; ++i, ++j) {
             nums[i] = tmp[j];
         }
     }