75. 颜色分类 2+1指针和三指针两种方法，算法原理分析

75. 颜色分类

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

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

注意:
不能使用代码库中的排序函数来解决这道题。

示例:

输入: [2,0,2,1,1,0]
输出: [0,0,1,1,2,2]
进阶：

一个直观的解决方案是使用计数排序的两趟扫描算法。
首先，迭代计算出0、1 和 2 元素的个数，然后按照0、1、2的排序，重写当前数组。
你能想出一个仅使用常数空间的一趟扫描算法吗？

解法1：先双指针，走不动时引入第三指针

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int len = nums.size();
        if (len < 2)
            return;
        
        int left = 0, right = len-1;
        while (left < right) {
            if (nums[left] == 0) {                              //先两边符合条件的数值
                ++left;
                continue;
            } else if (nums[right] == 2) {
                --right;
                continue;
            }

            if (nums[left] == 2) {
                swap(nums[left], nums[right]);
                --right;
            } else if (nums[right] == 0) {
                swap(nums[left], nums[right]);
                ++left;
            } else if (nums[left] == 1 && nums[right] == 1) {  //双指针寸步难行
                int mid = left+1;                              //引入第三指针
                while (mid < right && nums[mid] == 1)          //找中间不符合条件的数值
                    ++mid;
                if (mid == right)
                    return;

                if (nums[mid] == 0) {
                    swap(nums[left], nums[mid]);
                    ++left;
                } else {
                    swap(nums[right], nums[mid]);
                    --right;
                }
            }
        }
    }
};

          这种方法思路较为简单，数值有相对稳定性。最后面的2始终在最后边，不会换来换去。并且只在必要的时候（区间边界都是1时）引入第三个辅助指针，不用一直维护三个指针，操作较为简单，思路也比较明晰。

          当右边有1且左边很多1，中间夹着些许0/2时，算法会频繁引入第三指针，且第三指针会重复从左边界1往右边遍历。

解法2：直接三指针

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int len = nums.size();
        if (len < 2)
            return;
        
        int left = 0, cur = 0, right = len-1;
        while (cur <= right) {                    //需要同步跟新left, 所以有等号
            if (nums[cur] == 0) {
                if (left != cur)
                    swap(nums[left], nums[cur]);
                ++left;
                ++cur;                            //从前往后，一步为0可以往下走
            } else if (nums[cur] == 2) {
                if (right != cur)
                    swap(nums[right], nums[cur]);
                --right;
                //++cur;                          //cur不能往前走，从后换到当前的值不知道是0/1/2
            } else {
                ++cur;                            //当cur指的数为1时，会落下left指向第一个为1的数
            }
        }
    }
};

          这种解法一直维护三个指针，算法没有稳定性。末尾的数值即使已经符合条件，也会被换到cur上，再把一开始遇到的2换到末尾，数值的稳定性相当于倒了个序。

          原始数组一开始有2且最后的2大致有序时，该算法最糟糕。