Improvement

begeekmyfriend · begeekmyfriend · commit 0e4fa45e8e34 · 2025-05-13T09:13:12.000+08:00
Signed-off-by: begeekmyfriend &lt;begeekmyfriend@gmail.com&gt;
diff --git a/0031_next_permutation/next_permutation.c b/0031_next_permutation/next_permutation.c
@@ -21,22 +21,22 @@ static void reverse(int *a, int size)
 
 static void nextPermutation(int* nums, int numsSize)
 {
-    if (numsSize <= 1) {
-        return;
-    }
-
+    // find the first smaller element in decreasing sequence from back to forth.
     int i = numsSize - 2;
     while (i >= 0 && nums[i] >= nums[i + 1]) {
         i--;
     }
 
+    // if found, find the first bigger element from back to forth and swap them.
     if (i >= 0) {
         int j = numsSize - 1;
         while (j >= 0 && nums[j] <= nums[i]) {
             j--;
         }
         swap(nums + i, nums + j);
     }
+
+    // reverse the subsequence into increasing one.
     reverse(nums + i + 1, numsSize - i - 1);
 }
 
diff --git a/0031_next_permutation/next_permutation.cc b/0031_next_permutation/next_permutation.cc
@@ -5,11 +5,15 @@ using namespace std;
 class Solution {
 public:
     void nextPermutation(vector<int>& nums) {
+        // find the first smaller element in decreasing sequence from back to
+        // forth.
         int i = nums.size() - 2;
         while (i >= 0 && nums[i] >= nums[i + 1]) {
             i--;
         }
 
+        // if found, find the first bigger element from back to forth and swap
+        // them.
         if (i >= 0) {
             int j = nums.size() - 1;
             while (j >= 0 && nums[i] >= nums[j]) {
@@ -18,6 +22,7 @@ class Solution {
             swap(nums[i], nums[j]);
         }
 
+        // reverse the subsequence into increasing one.
         reverse(nums.begin() + i + 1, nums.end());
     }
 };
diff --git a/0912_sort_an_array/sort.c b/0912_sort_an_array/sort.c
@@ -26,7 +26,7 @@ static void quick_sort(int *nums, int lo, int hi)
         return;
     }
 
-    /* shuffle the pivot */
+    /* shuffle the pivot as it is a must for performance */
     mid = lo + (hi - lo) / 2;
     swap(&nums[mid], &nums[hi]);
 
@@ -38,11 +38,15 @@ static void quick_sort(int *nums, int lo, int hi)
          * shall make the partition in the middle of the array as far as
          * possible. If the partition is located in the head or tail, the
          * performance might well be very bad for it.
+         *
+         * Note: Do NOT use nums[++i] <= pivot or nums[--j] >= pivot as the
+         * loop condition because it leads to redundant operations in each
+         * recusive iteration when there are many duplicate elements.
          */
-        while (i < hi && nums[++i] < pivot) {}
-        while (j > lo && nums[--j] > pivot) {}
+        while (i < j && nums[++i] < pivot) {}
+        while (i < j && nums[--j] > pivot) {}
         if (i < j) {
-        swap(&nums[i], &nums[j]);
+            swap(&nums[i], &nums[j]);
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -21,22 +21,22 @@ static void reverse(int *a, int size)`
`21`	`21`
`22`	`22`	`static void nextPermutation(int* nums, int numsSize)`
`23`	`23`	`{`
`24`		`- if (numsSize <= 1) {`
`25`		`- return;`
`26`		`- }`
`27`		`-`
	`24`	`+ // find the first smaller element in decreasing sequence from back to forth.`
`28`	`25`	`int i = numsSize - 2;`
`29`	`26`	`while (i >= 0 && nums[i] >= nums[i + 1]) {`
`30`	`27`	`i--;`
`31`	`28`	`}`
`32`	`29`
	`30`	`+ // if found, find the first bigger element from back to forth and swap them.`
`33`	`31`	`if (i >= 0) {`
`34`	`32`	`int j = numsSize - 1;`
`35`	`33`	`while (j >= 0 && nums[j] <= nums[i]) {`
`36`	`34`	`j--;`
`37`	`35`	`}`
`38`	`36`	`swap(nums + i, nums + j);`
`39`	`37`	`}`
	`38`	`+`
	`39`	`+ // reverse the subsequence into increasing one.`
`40`	`40`	`reverse(nums + i + 1, numsSize - i - 1);`
`41`	`41`	`}`
`42`	`42`