# Sort an array of size N made of numbers from 0 to K

## Problem statement

In this article we will be discussing another (see the previous article) very popular programming interview question. This time we are asked to sort an array of size `N`

whose elements are in the range `[0,K)`

.

## Problem statement

Given an array $A=[a_1,a_2,…a_n],\: 1 \leq a_i \leq K$

modify A s.t. it is sorted.

As usual you should ask your interviewer some clarifying questions. For example a sensible question to ask could be:

- What is the maximum value of $K$ and of $N$? Let's assume that $N \leq 10^7$ and $K\leq 10^3$

## Example

Input : A={1,8,9,66,2,1,45,12} Output : A={1,1,2,8,9,12,45,66}

## Solution

First start noticing that the question seems rather simple at first. After all all you are asked to do is to sort an array. This is an easy peasy task that can be accomplished in a one-liner in C++.

## Simple sort solution

bool sort_range_K(vector<int>& A) { sort(begin(A), end(A)); }

But at this point you should also notice that you are not using the information about the range of the elements, and this should make your eyebrows raise and make you think a bit harder. This means that there is a better way of solving this problem.

The complexity of the above code is of $O(n \times log_2(n))$

## Linear time Solution

You might not be aware of this (and if you are not I highly encourage you to get familiar with the topic) that it is possible to achieve better asymptotic complexity for sorting than $O(n \times log_2(n))$.

If you know the range of the elements you are dealing with, sorting can be done in linear time using Counting sort.

The idea behind is really simple. For each number in the range `[0,K)`

you count how many times it appears in the original array in an array `F`

of size `K`

.

W.r.t. to the example above for instance:

A={1,8,9,66,2,1,45,12} F ={0,2,1,0,0,0,0,0,1,1,....}

`F[0]`

=`0`

because`0`

appears`0`

times in`A`

`F[1]`

=`2`

because`1`

appears`2`

times in`A`

- $…$
`F[9]`

=`2`

because`9`

appears`1`

times in`A`

With that information we can easily produce the output array by putting all the zeros first, then the ones, and so on.

## C++ code

The idea above can be coded as follows:

template<class T> void sort_range_K(vector<T>& A, const int K) { vector<int> F(K,0); for(const auto&x : A) F[x]++; int p = 0; for(int i = 0 ; i < K ; i++) for(int j = 0 ; j < F[i] ; j++) A[p++] = i; }

The complexity of the code above is linear the length of $\Theta(A)$.

The space complexity is $\Theta(K)$

You can try the above code online on Wandbox.

## Conclusions

In this article we discussed a common coding interview question asked by many tech companies. The takeaways from this exercise are:

- If
an information is provided in the problem statement, it needs to be used - If you know the range of the element you want to sort, you can sort them in linear time. The space complexity is linear in the biggest possible value an element of the array can take.

If you like this article check the previous article of the series (determine if a number is an Armstrong number).