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?

Solution 1:

类似radix sort， 先扫描一次得知所有的值出现的次数，再依次setup它们即可

ref: http://blog.csdn.net/fightforyourdream/article/details/15025713

http://en.wikipedia.org/wiki/Radix_sort

Radix sort

From Wikipedia, the free encyclopedia

Radix sort

Class	Sorting algorithm
Data structure	Array
Worst case performance
Worst case space complexity

In computer science, radix sort is a non-comparative integer sorting algorithm that sorts data with integer keys by grouping keys by the individual digits which share the same significant position and value. A positional notation is required, but because integers can represent strings of characters (e.g., names or dates) and specially formatted floating point numbers, radix sort is not limited to integers. Radix sort dates back as far as 1887 to the work of Herman Hollerith on tabulating machines.^[1]

 public void sortColors1(int[] A) {
         if (A == null || A.length == ) {
             return;
         }

         int len = A.length;

         int red = ;
         int white = ;
         int blue = ;

         for (int i = ; i < len; i++) {
             if (A[i] == ) {
                 red++;
             } else if (A[i] == ) {
                 white++;
             } else {
                 blue++;
             }
         }

         for (int i = ; i < len; i++) {
             if (red > ) {
                 A[i] = ;
                 red--;
             } else if (white > ) {
                 A[i] = ;
                 white--;
             } else {
                 A[i] = ;
             }
         }
     }

Solution 2:

使用双指针指向左边排好的0和右边排好的1，再加一个指针cur扫描整个数组。一趟排序下来就完成了。相当快捷。

注意：与右边交换之后，cur不能移动，因为你有可能交换过来是1或是0，还需要与左边交换。而与左边交换后，cur就可以向右边移动了。

 public void sortColors(int[] A) {
         if (A == null || A.length == ) {
             return;
         }

         int len = A.length - ;
         int left = ;
         int right = len;

         int cur = ;
         while (cur <= right) {
             if (A[cur] == ) {
                 // 换到右边，换过来的有可能是0，也有可能是1，所以cur要停留

                 swap(A, cur, right);
                 right--;
             } else if (A[cur] == ) {
                 // 从左边换过来的只可能是1，所以可以直接cur++
                 // 因为所有的2全部换到右边去了。

                 swap(A, cur, left);
                 left++;
                 cur++;
             } else {
                 cur++;
             }
         }
     }

     public void swap(int[] A, int n1, int n2) {
         int tmp = A[n1];
         A[n1] = A[n2];
         A[n2] = tmp;
     }

 December 22nd, 2014 redo

补充一个例子如下：

注：非常要注意的是，我们要使用cur <= right作为边界值。因为right 指向的是未判断的值。所以当cur == right时，此值仍然需要继续判断。

 public class Solution {
     public void sortColors(int[] A) {
         if (A == null || A.length == 0) {
             return;
         }

         int left = 0;

         // Bug 1: right is wrong.
         int right = A.length - 1;

         int cur = 0;

         // left: the first one which is not 0
         // right: the first one which is not 2
         // So we should use <= because right may be not dealed with.
         while (cur <= right) {
             switch (A[cur]) {
                 case 0:
                     // Bug 0: Forget to add A.
                     swap(A, left, cur);
                     left++;
                     cur++;
                     break;
                 case 1:
                     cur++;
                     break;
                 case 2:
                     swap(A, cur, right);
                     right--;
                     // 这里不cur++的原因是，有可能从右边换过来有0，1还要继续处理
                     break;

                 default:
                     cur++;
                     break;
             }
         }
     }

     public void swap(int[] A, int n1, int n2) {
         int tmp = A[n1];
         A[n1] = A[n2];
         A[n2] = tmp;
     }
 }

Follow up:

附上写得不错的一个博客：

http://blog.csdn.net/kenden23/article/details/17440519

以及本题的后续: Lintcode: Sort Colors II 解题报告

GitHub:

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/sort/SortColors.java