分类算法的复杂性

Question

Here is a sorting algorithm, not a clever one. In this version, it works well when elements are non-negative and occur at most once. I'm confused about its time complexity. Is it O(n)? So is it better than quick sort in terms of that notation? Thanks. Here is the code:

public int[] stupidSort( int[] array ){

// Variables
int max = array[0];
int index = 0;
int[] lastArray = new int[array.length];

// Find max element in input array
for( int i = 0; i < array.length; i++ ){
  if ( array[i] > max )
    max = array[i];
}

// Create a new array. In this array, element n will represent number of n's in input array
int[] newArray = new int[max + 1];

for ( int j = 0; j < array.length; j++ )
  newArray[array[j]]++;

// If element is bigger than 0, it means that number occured in input. So put it in output array
for( int k = 0; k < newArray.length; k++ ){
  if( newArray[k] > 0 )
    lastArray[index++] = k;
}
return lastArray;
}

Answer 1

What you wrote is the counting sort , and it has O(n) complexity indeed. However, it cannot be compared to QuickSort because QuickSort is an algorithm based on comparisons. These 2 algorithms belong to different categories (yours is a non-comparison, quicksort is a comparison algorithm). Your algorithm (counting sort) makes the assumption that the range of numbers in the array is known and that all numbers are integer, whereas QuickSort works for every number.

You can learn more for sorting algorithms here . In that link you can see the complexity for sorting algorithms divided in the 2 categories: comparison and non-comparison.

EDIT

As Paul Hankin pointed out the complexity isn't always O(n). It is O(n+k) where k is the max of the input array. Quoted below is the time complexity as explained in the wikipedia article for the counting sort :

Because the algorithm uses only simple for loops, without recursion or subroutine calls, it is straightforward to analyze. The initialization of the count array, and the second for loop which performs a prefix sum on the count array, each iterate at most k + 1 times and therefore take O(k) time. The other two for loops, and the initialization of the output array, each take O(n) time. Therefore, the time for the whole algorithm is the sum of the times for these steps, O(n + k).

Answer 2

The given algorithm is very much similar to Count sort . Whereas QuickSort is a comparison model based sorting algorithm. Only in the worst case QuickSort gives O(n^2) time complexity, otherwise it is O(nlogn). Also the QuickSort is used with it's randomized version that is pivot is selected randomly and hence the worst-case is avoided most often this way.

Edit: Correction as pointed by paulhankin in comment complexity=O(n+k):

The code you have put forth is using counting based sort, that is count sort and your code's time complexity is O(n+k). But what you must realize is that this algorithm is dependent on the range of the input and that range could be anything. Furthermore this algorithm is not InPlace but Stable . In many cases the data you want to sort is not only integer rather the data can be anything with a key that is required to be sorted with the help of the key. If Stable algorithm is not used than in such a case sorting can be problematic.

Just in case if someone does not know:

InPlace Algorithm : Is the one in which additional space required is not dependent on the given input.

Stable Algorithm : Is the one in which for example if there were two 5's in the data set before sorting, the 5 that came first before sorting comes first than the second even after the sorting.

EDIT: (Regarding aladinsane7's comment): Yes the formal version of countSort does handle this aspect also. It would be good if you have a look at CountSort . And its time complexity is O(n+k) . Where K accounts for the range of data and n is complexity for remaining algorithm.