LeetCode. 75. 颜色分类（荷兰国旗问题/双指针）

---

题目

• 75. 颜色分类

方法一：单指针

本题是经典的「荷兰国旗问题」，由计算机科学家 Edsger W. Dijkstra 首先提出

考虑对数组进行两次遍历。在第一次遍历中，将数组中所有的 0 交换到数组的头部。在第二次遍历中，将数组中所有的 1 交换到头部的 0 之后。此时，所有的 2 都出现在数组的尾部，这样就完成了排序。

算法流程：

• 使用一个指针 $\text{ptr}$ 表示「头部」的范围，ptr 中存储了一个整数，表示数组 nums 的[0,ptr-1]都属于「头部」。ptr 的初始值为 0，表示还没有数处于「头部」

• 第一次遍历：

  • 从左向右遍历整个数组，如果找到了 0，那么就需要将 0 与「头部」位置ptr的元素进行交换，并将「头部」向后扩充一个位置(即ptr++)。在遍历结束之后，所有的 0 都被交换到「头部」的范围，并且「头部」只包含 0

• 第二次遍历：

  • 从「头部」开始，从左向右遍历整个数组，如果找到了 1，那么就需要将 1 与「头部」位置的元素进行交换，并将「头部」向后扩充一个位置。在遍历结束之后，所有的 1 都被交换到「头部」的范围，并且都在 0 之后，此时 2 只出现在「头部」之外的位置，因此排序完成

class Solution {
    public void sortColors(int[] nums) {
        int n = nums.length;
        if (n == 1) {
            return ;
        }
        int ptr = 0;
        // 第一次遍历
        for (int i = 0; i < n; i++) {
            if (nums[i] == 0) {
                swap(nums, ptr, i);
                ptr++;
            }
        }
        // 第二次遍历
        for (int i = ptr; i < n; i++) {
            if (nums[i] == 1) {
                swap(nums, ptr, i);
                ptr++;
            }
        }
    }
    private void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度
• 空间复杂度：$O(1)$

方法二：双指针

借助两个指针，分别用来交换0和2，通过一次遍历，把数组分成三个部分

class Solution {
    public void sortColors(int[] nums) {
        int n = nums.length;
        if (n == 1) {
            return ;
        }
        
        // all in [0, zero) = 0
        // all in [zero, i) = 1
        // all in (two, len - 1] = 2

        int zero = 0, two = n - 1;
        int i = 0;
        while (i <= two) {
            if (nums[i] == 0) {
                swap(nums, i, zero);
                zero++;
                i++;
            } else if (nums[i] == 1) {
                i++;
            } else {
                swap(nums, i, two);
                two--;
            }
        }
    }
    private void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度
• 空间复杂度：$O(1)$

class Solution {
    public void sortColors(int[] nums) {
        int n = nums.length;
        // 0 往前挪，2往后挪
        int zero = 0, two = n - 1;
        for (int i = 0; i <= two; i++) {
            if (nums[i] == 0) {
                nums[i] = nums[zero];
                nums[zero] = 0;
                zero++;
            } 
            if (nums[i] == 2) {
                nums[i] = nums[two];
                nums[two] = 2;
                two--;
                if (nums[i] != 1) {
                    i--;
                }
            }
        }
    }
}

Reference

• 颜色分类

• 快速排序的子过程 partition