LeetCode-Sort Colors

Sort Colors

题目描述

Given an array with n objects colored red, white or blue, sort them so that objects of the same color are adjacent, with the colors in the order red, white and blue.

Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.

Note:
You are not suppose to use the library’s sort function for this problem.

click to show follow up.

Follow up:
A rather straight forward solution is a two-pass algorithm using counting sort.
First, iterate the array counting number of 0’s, 1’s, and 2’s, then overwrite array with total number of 0’s, then 1’s and followed by 2’s.

Could you come up with an one-pass algorithm using only constant space?

解题思路

1、对于两遍遍历，在follow up中已经说得比较明白
2、对于一遍遍历，其关键在于交换，而不是覆盖。思想类似于快速排序，开始我没太想明白，但是只要举例走一遍就能够理解了（我的举例是2 1 2 1 0）

public class Solution {

    //遍历两遍
    public void twoPass(int[] A)
    {
        int red = 0;
        int white = 0;
        int blue = 0;
        for(int loc = 0; loc <= A.length - 1; ++loc)
        {
            if(0 == A[loc])
            {
                ++red;
            }
            else if(1 == A[loc])
            {
                ++white;
            }
            else
            {
                ++blue;
            }
        }
        //红色
        dye(A,0,red,0);
        //白色
        dye(A,red,white,1);
        //蓝色
        dye(A,red + white,blue,2);
    }

    public void dye(int[] A, int from ,int len, int color)
    {
        for(int loc = from ; loc <= len - 1 + from ; ++loc)
        {
            A[loc] = color;
        }
    }

    //遍历一遍的方法
    public void onePass(int[] A)
    {
        if(null == A || 1 == A.length)
        {
            return;
        }

        int red = 0;
        int blue = A.length - 1;
        int loc = 0;

        while(loc <= A.length - 1)
        {
            switch(A[loc])
            {
                case 0:
                    if(loc == red)
                    {
                        ++loc;
                    }
                    else
                    {
                        swap(A,loc,red);
                    }
                    ++red;
                    break;

                case 1:
                    ++loc;
                    break;

                case 2:
                    if(loc >= blue)
                    {//已经填满
                        return;
                    }
                    else
                    {
                        swap(A,blue,loc);
                    }
                    --blue;
                    break;
            }
        }
    }

    //此种数字交换的方法较为高效
    public void swap(int[] A, int from , int to)
    {
        A[from] ^= A[to];
        A[to] ^= A[from];
        A[from] ^= A[to];
    }

    public void sortColors(int[] A) {
        //twoPass(A);
        onePass(A);
    }
}