Lintcode: Sort Colors II

Given an array of n objects with k different colors (numbered from 1 to k), sort them so that objects of the same color are adjacent, with the colors in the order 1, 2, ... k.

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

Example
GIven colors=[3, 2, 2, 1, 4], k=4, your code should sort colors in-place to [1, 2, 2, 3, 4]. 

Challenge
A rather straight forward solution is a two-pass algorithm using counting sort. That will cost O(k) extra memory.

Can you do it without using extra memory?

先写了个O(kN)时间复杂度，O（1）空间复杂度的， 这个算法适合颜色数比较少的情况（k is constant）

 class Solution {
     /**
      * @param colors: A list of integer
      * @param k: An integer
      * @return: nothing
      */
     public void sortColors2(int[] colors, int k) {
         // write your code here
         if (colors==null || colors.length==0 || k<=1) return;
         int l=0, r=colors.length-1;
         int cnt = 1;
         for (; cnt<k; cnt++) {
             while (true) {
                 while (l<r && colors[l]==cnt) {
                     l++;
                 }
                 while (l<r && colors[r]!=cnt) {
                     r--;
                 }
                 if (l == r) break;
                 swap(colors, l, r);
             }
             r = colors.length-1;
             if (l == r) break;
         }
     }

     public void swap(int[] colors, int l, int r) {
         int temp = colors[l];
         colors[l] = colors[r];
         colors[r] = temp;
     }
 }

K->N的话，上面时间复杂度就大了，所以干脆用Quick Sort

 class Solution {
     /**
      * @param colors: A list of integer
      * @param k: An integer
      * @return: nothing
      */
     public void sortColors2(int[] colors, int k) {
         // write your code here
         if (colors==null || colors.length==0 || k<=1) return;
         quickSort(colors, 0, colors.length-1);
     }

     public void quickSort(int[] colors, int l, int r) {
         if (l >= r) return;
         int pivot = r;
         int pos = partition(colors, l, r, pivot);
         quickSort(colors, l, pos-1);
         quickSort(colors, pos+1, r);
     }

     public int partition(int[] colors, int start, int end, int pivot) {
         int l=start, r=end;
         while (true) {
             while (l<r && colors[l]<colors[pivot]) {
                 l++;
             }
             while (l<r && colors[r]>=colors[pivot]) {
                 r--;
             }
             if (l == r) break;
             swap(colors, l, r);
         }
         swap(colors, l, end);
         return l;
     }

     public void swap(int[] colors, int l, int r) {
         int temp = colors[l];
         colors[l] = colors[r];
         colors[r] = temp;
     }
 }

有人给出了O（N）的解法(better solution)

inplace，并且O(N)时间复杂度的算法。

O(n): use the array itself as space to store counts. We use A[k-1] to store the count of color k. We use negtive number to store count, in order to be distnct with the color value. This method ASSUMES that every color between 1 and k will appear.

At position i, if A[i] is positive, we check the value of A[A[i]-1], if it is a positive number, i.e., not counted yet, we then put A[A[i]-1] to A[i], and set A[A[i]-1] as -1 to indicate that there is one of this color.

If A[A[i]-1] is a negtive or zero value, we then simply decrease it by one and set A[i] as 0 to indicate that this position is couted already.

At position i, we repeat this procedure until A[i] becomes 0 or negtive, we then move to i+1.

At counting, we draw colors into array.

3 2 2 1 4

2 2 -1 1 4

2 -1 -1 1 4

0 -2 -1 1 4

-1 -2 -1 0 4

-1 -2 -1 -1 0

 class Solution {
     /**
      * @param colors: A list of integer
      * @param k: An integer
      * @return: nothing
      */
    public void sortColors2(int[] colors, int k) {
         //The method assumes that every color much appear in the array.
         int len = colors.length;
         if (len<k) return;

         //count the number of each color.
         for (int i=0;i<len;i++){
             while (colors[i]>0){
                 int key = colors[i]-1;
                 if (colors[key]<=0){
                     colors[key]--;
                     colors[i]=0;
                 }
                 else {
                     colors[i] = colors[key];
                     colors[key] = -1;
                 }
             }
         }

         //draw colors.
         int index = len - 1;
         for (int i = k - 1; i >= 0; i--) {
             int cnt = -colors[i];

             // Empty number.
             if (cnt == 0) {
                 continue;
             }

             while (cnt > 0) {
                 colors[index--] = i + 1;
                 cnt--;
             }
         }
    }
 }

若k事先不知道，一样的，就是开始维护一个counter, 在过程中算一下。

 class Solution {
     /**
      * @param colors: A list of integer
      * @param k: An integer
      * @return: nothing
      */
     public void sortColors2(int[] colors) {
         // write your code here
         int len = colors.length;

         int count = 0;
         for (int i=0; i<len; i++) {
             while (colors[i] > 0) {
                 count++;
                 int pos = colors[i]-1; //最好搞个变量存一下，之后方便
                 if (colors[pos] > 0) {
                     colors[i] = colors[pos];
                     colors[pos] = -1;
                 }
                 else {
                     colors[pos]--;
                     colors[i] = 0;
                 }
             }
         }

         //sort
         int index = colors.length-1;
         for (int j=count; j>0; j--) {
             int num = -colors[j-1];
             while (num > 0) {
                 colors[index--] = j;
                 num--;
             }
         }
     }
 }