非独立思考。
    重点：循环不变量。

    1. class Solution {
    2.     public void sortColors(int[] nums) {
    3.         // 常规排序算法
    4. //        for (int cur = 0; cur < nums.length - 1; cur++) {
    5. //            for (int j = 0; j < nums.length - cur - 1; j++) {
    6. //                if (nums[j] > nums[j + 1]) {
    7. //                    int temp = nums[j];
    8. //                    nums[j] = nums[j + 1];
    9. //                    nums[j + 1] = temp;
    10. //                }
    11. //            }
    12. //        }
    13.         // 循环不变量
    14.         // 首先是一些特值处理
    15.         int len = nums.length;
    16.         if (len < 2) {
    17.             return;
    18.         }
    19.         // all in [0,zero) is 0
    20.         // all in [zero,cur) is 1
    21.         // all in [two,len-1) is
    22.         // 循环中止条件是 cur==two，那么循环可以继续的条件为 cur<two
    23.         // 保证初始化 [0,zero)为空，zero=0！重点：遍历到0，先交换，再++
    24.         // 保证初始化 [two,len-1)为空，two=len！重点：遍历到2，先--，再交换（取不到len下标）
    25.         int zero = 0;
    26.         int two = len;
    27.         int cur = 0;
    28.         // i==two时覆盖全部区间
    29.         while (cur < two) {
    30.             if (nums[cur] == 0) {
    31.                 // 和前面的cur交换
    32.                 swap(nums, cur, zero);
    33.                 cur++;
    34.                 zero++;
    35.             } else if (nums[cur] == 1) {
    36.                 // 直接往后移动
    37.                 cur++;
    38.             } else {
    39.                 // 和当前最后面的下标交换
    40.                 two--;
    41.                 swap(nums, cur, two);
    42.                 // 为什么不需要cur++?
    43.                 // 因为交换完之后，当前index[cur]的值已经不是原来的2了
    44.                 // 这个值是否需要进一步修改它的位置仍需要遍历一遍。嗯，很准确。。。                
    45.             }
    46.         }
    47.     }
    49.     private void swap(int[] nums, int index1, int index2) {
    50.         int temp = nums[index1];
    51.         nums[index1] = nums[index2];
    52.         nums[index2] = temp;
    53.     }
    54. }