【探索-中级算法】颜色分类

初级解法一

首先，使用最简单的解法，可以拆分成两步。

第一步：扫描数组，先把 0 放在最前面，把 1 和 2 放在最后面（即使是混淆的也没关系）。

第二步：再在混淆的 1 和 2 中进行排序。

每一步的排序，都需要借助两个指针。

public void sortColors(int[] nums) {
    if (nums == null || nums.length == 0) return;
    int p0 = -1, px = -1;
    for (int i = nums.length - 1; i >= 0; i--) {
        if (nums[i] == 0) {
            p0 = i;
            break;
        }
    }
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] != 0) {
            px = i;
            break;
        }
    }
    // 第一步
    if (p0 != -1 && px != -1) {
        while (p0 > px) {
            swap(nums, p0, px);
            while (nums[p0] != 0) --p0;
            while (nums[px] == 0) ++px;
        }
    }
    int p1 = -1, p2 = -1;
    for (int i = p0 + 1; i < nums.length; i++) {
        if (nums[i] == 2) {
            p2 = i;
            break;
        }
    }
    for (int i = nums.length - 1; i >= 0; i--) {
        if (nums[i] == 1) {
            p1 = i;
            break;
        }
    }
    // 第二步
    if (p1 != -1 && p2 != -1) {
        while (p1 > p2) {
            swap(nums, p1, p2);
            while (nums[p1] != 1) --p1;
            while (nums[p2] != 2) ++p2;
        }
    }
}

public void swap(int[] nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

这样做简单直观，但是效率不是很高。

---

初级解法二

按照题目给的提示，首先，迭代计算出 0、1 和 2 元素的个数，然后按照0、1、2的排序，重写当前数组。

首先，需要明确一个概念，假设 0、1 和 2 元素的个数分别为 num1、num2、num3，则在排序之后，有如下规则：

   0 所在的范围为 [0, num1 - 1]，设该范围的小段组为 g1
   1 所在的范围为 [num1, num1 + num 2 - 1]，设该范围的小段组为 g2
   2 所在的范围为 [num1 + num 2, num1 - 1]，设该范围的小段组为 g3

而对于未排序的、混乱的数组，对于 g1 内的非 0 元素都需要被交换成 0 元素，g2 的非 1 元素都需要交换成 1 元素，g3 的非 2 元素都需要交换成 2 元素，且有通常情况下，有如下交换规则（<--> 符号表示相互交换位置，g1_2 代表 g1 小组内的为 2 的元素）：

g1_1 <--> g2_0，即 g1 小组范围内的元素 1 直接与 g2 小组范围内的元素 0 交换
g1_2 <--> g3_0
g2_2 <--> g3_1

即直接把 g2、g3 中的元素 0 都交换到 g1 内，其余组内的同理。
（需要注意，这里说的是直接，还有一种特殊情况，不能直接交换，在下面的代码种有注释说明）

如图所示，更加直观：

具体的算法如下 （需要注意的是几种特殊情况）：

public static void sortColors2(int[] nums) {
    if (nums == null || nums.length == 0) return;
    int[] counts = new int[3];
    // 分别记录各个元素的个数
    for (int i = 0; i < nums.length; i++) {
        counts[nums[i]]++;
    }
    
    // 三个指针，分别指向各个小组非小组对应的元素，如 g1 就指向 g1 小组内的元素 1 和 2
    int g1 = (counts[0] > 0 ? 0 : -1);
    int g2 = (counts[1] > 0 ? counts[0] : -1);
    int g3 = (counts[2] > 0 ? nums.length - counts[2] : -1);
    
    int f1 = g1;
    int f2 = g2;
    int f3 = g3;
    
    while (true) {
        if (g1 > -1 && g2 > -1 && nums[g1] == 1 && nums[g2] == 0) {
            swap(nums, g1, g2);
            ++g1;
            ++g2;
        } else if (g1 > -1 && g3 > -1 && nums[g1] == 2 && nums[g3] == 0) {
            swap(nums, g1, g3);
            ++g1;
            ++g3;
        } else if (g2 > -1 && g3 > -1 && nums[g2] == 2 && nums[g3] == 1) {
            swap(nums, g2, g3);
            ++g2;
            ++g3;
        } else if (g1 > -1 && g2 > -1) {
            // 特殊的处理，如对于 nums = [2, 0 ,1]，
            // 此时不能直接把两个元素交换到对应的小组内，即不属于前面三种情况，
            // 则先交换一下当前 g1 和 g2 指向的元素
            // 这样间接处理之后，就会使得重新符合前面三种情况之一了
            swap(nums, g1, g2);
        }
        
        // 如果元素本身就在其对应的小组内，则跳过
        while (g1 > -1 && g1 < nums.length && nums[g1] == 0) ++g1;
        while (g2 > -1 && g2 < nums.length && nums[g2] == 1) ++g2;
        while (g3 > -1 && g3 < nums.length && nums[g3] == 2) ++g3;
		
		 // 排序完成，则退出
        if ((g1 == -1 || g1 - f1 == counts[0])
                && (g2 == -1 || g2 - f2 == counts[1])
                && (g3 == -1 || g3 - f3 == counts[2])) break;
    }
}

---

初级解法三

其实，还可以从另外一个角度来看，因为只有 0、1、2 三种值，所以第一遍先计算每个值的个数，然后再按照每个值的数量遍历数组，依次设置对应下标的值即可。

---

进阶解法

参考自：https://blog.youkuaiyun.com/twt727/article/details/80101396

还是利用三个指针，p0、p1、p2 在 nums(0, m-1) 内，总是分别指向排序之后的序列的最后一个 0、1、2 元素，因此，对于 mums[m]，需要插入到 nums(0, m-1) 中，从而形成新的有序的 nums(0, m) 序列。

而在 nums(0, m-1) 中插入 nums[m] 的时候，假设 nums[m] == 0，则需要将原来的 p0 往后移动一位（即 ++p0），来表示新的 0 元素需要插入的位置 nums[p0]，而因为新插入了元素，因为在 index = p0 之后的元素需要往后移动一位。

此时就可以使用一个技巧，直接 nums[m] == 0 覆盖到 nums[++p0] 的位置，此时被覆盖的元素（元素值为 1）则又转移到 nums[++p1] 的位置（相当于转移到 1 组成序列的末尾），而又会产生被覆盖的元素（元素值为 2），则又转移到 nums[++p2] 的位置（相当于转移到 2 组成序列的末尾）。

可以看演示截图（虚线箭头代表指针的移动，圆圈包围的元素代表被覆盖的元素，弧线箭头代表转移）：

public void sortColors(int[] nums) {
    int p0 = -1,p1 = -1,p2 = -1;
    int m = 0;
    for(; m < nums.length;m++) {
        if(nums[m] == 0){
            nums[++p2] = 2;
            nums[++p1] = 1;
            nums[++p0] = 0;
        }
        else if(nums[m] == 1){
            nums[++p2] = 2;
            nums[++p1] = 1;
        }
        else {
            ++p2;
        }
    }
}