feat: add solutions to lc problem: No.0075

No.0075.Sort Colors

Author: yanglbme

solution/0000-0099/0075.Sort Colors/README.md

@@ -53,20 +53,19 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**计数：**
+**方法一：三指针**
 
--   遍历 `nums`，记录其中 `0`、`1` 和 `2` 出现的次数。
--   依照记录的数字，按照顺序重新填充 `nums`。
+我们定义三个指针 $i$, $j$ 和 $k$，其中指针 $i$ 用于指向数组中元素值为 $0$ 的最右边界，指针 $j$ 用于指向数组中元素值为 $2$ 的最左边界，初始时 $i=-1$, $j=n$。指针 $k$ 用于指向当前遍历的元素，初始时 $k=0$。
 
-**双指针：**
+当 $k \lt j$ 时，我们执行如下操作：
 
-数组元素只存在 `0`、`1` 和 `2` 三种，因此将 `0` 移动至数组头部，`2` 移动至数组尾部，排序便完成了。
+-   若 $nums[k]=0$，则将其与 $nums[i+1]$ 交换，然后 $i$ 和 $k$ 都加 $1$；
+-   若 $nums[k]=2$，则将其与 $nums[j-1]$ 交换，然后 $j$ 减 $1$；
+-   若 $nums[k]=1$，则 $k$ 加 $1$。
 
--   安排两个变量，分别指向数组头部与尾部。
--   遍历数组，分三种情况：
-    -   `0`：与头指针数值交换，并向前一步，遍历指针向前。
-    -   `2`：与尾指针数值交换，并向后一步。**遍历指针不变**（还需要处理交换上来的数值）。
-    -   `1`：遍历指针向前。
+遍历结束后，数组中的元素就被分成了 $[0,i]$, $[i+1,j-1]$ 和 $[j,n-1]$ 三个部分。
+
+时间复杂度 $O(n)$，其中 $n$ 是数组的长度。只需要遍历一遍数组即可。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -77,21 +76,17 @@
 ```python
 class Solution:
     def sortColors(self, nums: List[int]) -> None:
-        """
-        Do not return anything, modify nums in-place instead.
-        """
-        i, j = -1, len(nums)
-        cur = 0
-        while cur < j:
-            if nums[cur] == 0:
+        i, j, k = -1, len(nums), 0
+        while k < j:
+            if nums[k] == 0:
                 i += 1
-                nums[cur], nums[i] = nums[i], nums[cur]
-                cur += 1
-            elif nums[cur] == 1:
-                cur += 1
-            else:
+                nums[i], nums[k] = nums[k], nums[i]
+                k += 1
+            elif nums[k] == 2:
                 j -= 1
-                nums[cur], nums[j] = nums[j], nums[cur]
+                nums[j], nums[k] = nums[k], nums[j]
+            else:
+                k += 1
 ```
 
 ### **Java**
@@ -101,92 +96,40 @@ class Solution:
 ```java
 class Solution {
     public void sortColors(int[] nums) {
-        int i = -1, j = nums.length;
-        int cur = 0;
-        while (cur < j) {
-            if (nums[cur] == 0) {
-                swap(nums, cur++, ++i);
-            } else if (nums[cur] == 1) {
-                ++cur;
+        int i = -1, j = nums.length, k = 0;
+        while (k < j) {
+            if (nums[k] == 0) {
+                swap(nums, ++i, k++);
+            } else if (nums[k] == 2) {
+                swap(nums, --j, k);
             } else {
-                swap(nums, cur, --j);
+                ++k;
             }
         }
     }
 
     private void swap(int[] nums, int i, int j) {
         int t = nums[i];
-        nums[i] = nums[j];
+        nums[i]  = nums[j];
         nums[j] = t;
     }
 }
 ```
 
-### **TypeScript**
-
-```ts
-/**
- Do not return anything, modify nums in-place instead.
- */
-function sortColors(nums: number[]): void {
-    let n = nums.length;
-    if (n < 2) return;
-    let p0 = 0,
-        p2 = n - 1;
-    let p1 = 0;
-    while (p1 <= p2) {
-        if (nums[p1] == 0) {
-            [nums[p0], nums[p1]] = [nums[p1], nums[p0]];
-            p0++;
-            p1++;
-        } else if (nums[p1] == 1) {
-            p1++;
-        } else {
-            [nums[p1], nums[p2]] = [nums[p2], nums[p1]];
-            p2--;
-        }
-    }
-}
-```
-
-```ts
-/**
- Do not return anything, modify nums in-place instead.
- */
-function sortColors(nums: number[]): void {
-    const n = nums.length;
-    let l = -1;
-    let r = n;
-    let i = 0;
-    while (i < r) {
-        if (nums[i] === 2) {
-            r--;
-            [nums[r], nums[i]] = [nums[i], nums[r]];
-        } else {
-            if (nums[i] === 0) {
-                l++;
-                [nums[l], nums[i]] = [nums[i], nums[l]];
-            }
-            i++;
-        }
-    }
-}
-```
-
 ### **C++**
 
 ```cpp
 class Solution {
 public:
     void sortColors(vector<int>& nums) {
-        int i = -1, j = nums.size(), cur = 0;
-        while (cur < j) {
-            if (nums[cur] == 0) {
-                swap(nums[++i], nums[cur++]);
-            } else if (nums[cur] == 1) {
-                ++cur;
+        int i = -1, j = nums.size(), k = 0;
+        while (k < j) {
+            if (nums[k] == 0) {
+                swap(nums[++i], nums[k++]);
+            } else if (nums[k] == 2) {
+                swap(nums[--j], nums[k]);
             } else {
-                swap(nums[cur], nums[--j]);
+                ++k;
             }
         }
     }
@@ -197,71 +140,92 @@ public:
 
 ```go
 func sortColors(nums []int) {
-	i, j, cur := -1, len(nums), 0
-	for cur < j {
-		if nums[cur] == 0 {
+	i, j, k := -1, len(nums), 0
+	for k < j {
+		if nums[k] == 0 {
 			i++
-			nums[cur], nums[i] = nums[i], nums[cur]
-			cur++
-		} else if nums[cur] == 1 {
-			cur++
-		} else {
+			nums[i], nums[k] = nums[k], nums[i]
+			k++
+		} else if nums[k] == 2 {
 			j--
-			nums[cur], nums[j] = nums[j], nums[cur]
+			nums[j], nums[k] = nums[k], nums[j]
+		} else {
+			k++
 		}
 	}
 }
 ```
 
+### **TypeScript**
+
+```ts
+/**
+ Do not return anything, modify nums in-place instead.
+ */
+function sortColors(nums: number[]): void {
+    let i = -1;
+    let j = nums.length;
+    let k = 0;
+    while (k < j) {
+        if (nums[k] === 0) {
+            ++i;
+            [nums[i], nums[k]] = [nums[k], nums[i]];
+            ++k;
+        } else if (nums[k] === 2) {
+            --j;
+            [nums[j], nums[k]] = [nums[k], nums[j]];
+        } else {
+            ++k;
+        }
+    }
+}
+```
+
 ### **Rust**
 
 ```rust
 impl Solution {
     pub fn sort_colors(nums: &mut Vec<i32>) {
-        let mut l = 0;
-        let mut r = nums.len() - 1;
-        let mut i = 0;
-        while i <= r {
-            match nums[i] {
-                2 => {
-                    nums.swap(i, r);
-                    match r {
-                        0 => return,
-                        _ => r -= 1,
-                    }
-                }
-                n => {
-                    if n == 0 {
-                        nums.swap(i, l);
-                        l += 1;
-                    }
-                    i += 1;
-                }
+        let mut i = -1;
+        let mut j = nums.len();
+        let mut k = 0;
+        while k < j {
+            if nums[k] == 0 {
+                i += 1;
+                nums.swap(i as usize, k as usize);
+                k += 1;
+            } else if nums[k] == 2 {
+                j -= 1;
+                nums.swap(j, k);
+            } else {
+                k += 1;
             }
         }
     }
 }
 ```
 
-```rust
-impl Solution {
-    pub fn sort_colors(nums: &mut Vec<i32>) {
-        let mut count = [0, 0, 0];
-        for num in nums.iter() {
-            count[*num as usize] += 1;
+### **C#**
+
+```cs
+public class Solution {
+    public void SortColors(int[] nums) {
+        int i = -1, j = nums.Length, k = 0;
+        while (k < j) {
+            if (nums[k] == 0) {
+                swap(nums, ++i, k++);
+            } else if (nums[k] == 2) {
+                swap(nums, --j, k);
+            } else {
+                ++k;
+            }
         }
-        count[1] += count[0];
-        count[2] += count[1];
+    }
 
-        for i in 0..count[0] {
-            nums[i] = 0;
-        }
-        for i in count[0]..count[1] {
-            nums[i] = 1;
-        }
-        for i in count[1]..count[2] {
-            nums[i] = 2;
-        }
+    private void swap(int[] nums, int i, int j) {
+        int t = nums[i];
+        nums[i] = nums[j];
+        nums[j] = t;
     }
 }
 ```