Sort an array which contain 1 to n values

Given an array arr[] of size n consisting of distinct integers from 1 to n. Your task is to sort the array without using extra space.

Examples :

Input: arr[] = [2, 1, 5, 4, 3]
Output: [1, 2, 3, 4, 5]
Explanation: Sorting the array in ascending order rearranges the elements to [1, 2, 3, 4, 5].

Input: arr[] = [1, 2, 3, 4, 5, 6]
Output: [1, 2, 3, 4, 5, 6]
Explanation: The array is already sorted, so it remains unchanged.

[Native approach] Using Sort Function - O(n log n) Time O(1) Space

We use a O(n Log n) sorting algorithm and it is possible to achieve with O(1) space. In the below implementation, we have simply used a library function.

[1, 2, 3, 4, 5]

Time Complexity: O(n log n)
Auxiliary Space: O(1)

[Better Approach] Counting Sort - O(n) Time O(n) Space

We can use counting sort to achieve this in linear time. Note that the counting sort keeps array values only and does not copy values from 1 to n.

[Efficient Approach] Using Cyclic Sort - O(n) Time O(1) Space

Follow the steps mentioned below to solve the problem. The idea is based on Cycle Sort algorithm

• Traverse the array 
• If an element is at its correct position, do not do anything.
• Else swap the element with the element at its correct position

[1, 2, 3, 4, 5]

Time Complexity: O(n)
Auxiliary Space: O(1)

Illustration

arr[] = {3, 1, 2}

i = 0 : arr[0] = 3, Swap arr[0] and arr[2], arr[] = {2, 1, 3}

i = 0 : arr[0] = 2. Swap arr[0] and arr[1]. arr[] = {1, 2, 3}

i = 0 : arr[0] is already in its correct position, i = 1
i = 1 : arr[1] is already in its correct position, i = 2
i = 2 : arr[0] is already in its correct position, i = 3

Why is this linear or O(n) Time? For every element in the array, the algorithm swaps it to its correct position only once. So we do at most n swaps And if we do not do a swap, we increment i. So the total work done is around 2n

[Alternate Approach] Using Mathematical Formula - O(n) Time O(1) Space

The idea is to traverse the input array and for each element arr[i], place it at its correct index, that is (arr[i] - 1). To avoid overwriting, we ind the maximum value in the array, that is (n + 1) and use it to store the original as well as the updated value at each index.

Let's say for any index i, we have the current element as arr[i]. We know that the correct index for arr[i], say correctIdx is (arr[i] - 1). Now, instead of overwriting arr[correctIdx], we add (arr[i] * (n + 1)) to arr[correctIdx]. This is because we can get the original value by arr[i] % (n + 1) and updated value by arr[i] / (n + 1).

After traversing the array and modifying each index, traverse again and update arr[i] to arr[i] / (n + 1) to get the original values back.

The key idea is encoding two values in one array cell:

• Original value = arr[i] % (n + 1)
• New (sorted) value = arr[i] / (n + 1)

[1, 2, 3, 4, 5]

Time Complexity: O(n)
Auxiliary Space: O(1)