【中等】75. 颜色分类给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums ，原地** 对它们进行排序，使得相

给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums ，原地** 对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

必须在不使用库内置的 sort 函数的情况下解决这个问题。

示例 1：

输入： nums = [2,0,2,1,1,0]
输出： [0,0,1,1,2,2]

示例 2：

输入： nums = [2,0,1]
输出： [0,1,2]

提示：

n == nums.length
1 <= n <= 300
nums[i] 为 0、1 或 2

进阶：

你能想出一个仅使用常数空间的一趟扫描算法吗？

1. 核心逻辑：生活中的“插队”艺术

想象你有一串数字卡片排成一行，比如 [1, 2, 7, 4, 3, 1]。

你想通过交换卡片的位置，得到一个比现在大、但又是所有大数中最小的组合（就像字典序里的下一个单词）。

生活案例： 就像在一排人里，你想找一个稍微高一点的人往前站，但为了让增加的身高“尽量小”，你得从**最右边（个位数）**开始观察，寻找第一个破坏“从大到小”规律的人。

2. 算法三部曲

从后往前找“倒霉蛋” (i)： 寻找第一个比右边邻居小的数。因为如果右边全是降序的（比如 7, 4, 3, 1），这块已经大到极限了，没法再变大了。
找个“接班人” (j)： 在这个“倒霉蛋”的右边，找一个比他大但又最小的数，把他们俩互换。
重整旗鼓： 互换后，右边的部分还是降序的，为了让整体数值最小，要把右边反转成升序。

3. 完整代码实现（带详尽注释）

JavaScript

/**
 * @param {number[]} nums
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var nextPermutation = function(nums) {
    // 从倒数第二个元素开始往前找
    let i = nums.length - 2;

    // --- 第一步：寻找第一个“升序对” ---
    // 目标：找到第一个 nums[i] < nums[i+1] 的位置
    // 此时 nums[i+1...end] 必然是降序的
    while (i >= 0 && nums[i] >= nums[i + 1]) {
        i--;
    }

    // 如果 i < 0，说明整个数组都是降序（如 [3,2,1]），直接跳到第三步反转即可
    if (i >= 0) {
        // --- 第二步：寻找“稍微大一点”的数 ---
        // 在 nums[i] 的右边寻找第一个大于 nums[i] 的数 nums[j]
        let j = nums.length - 1;
        while (j >= 0 && nums[j] <= nums[i]) {
            j--;
        }
        // 交换这两个数，让高位变大一点点
        [nums[i], nums[j]] = [nums[j], nums[i]];
    }

    // --- 第三步：反转右侧，保持“贪心”思想 ---
    // 为了让变大后的数字增加幅度最小，我们需要把 i 之后的降序部分变成升序
    reverse(nums, i + 1);
};

/**
 * 辅助函数：反转数组指定范围
 */
function reverse(nums, start) {
    let left = start;
    let right = nums.length - 1;
    while (left < right) {
        [nums[left], nums[right]] = [nums[right], nums[left]];
        left++;
        right--;
    }
}

4. 为什么要 reverse？

当我们在第 i 位换了一个更大的数后，后面剩下的数字依然是降序排列的。降序代表这部分是当前组合下的最大值。

为了让整体增加的幅度最小，我们需要把后面这块变回最小值（也就是升序）。

复杂度分析：

时间复杂度： $O(n)$ ，我们最多遍历数组两三遍。
空间复杂度： $O(1)$ ，直接在原数组上操作，不需要额外空间。