Sort an array which contain 1 to n values

Try it on GfG Practice

We are given an array that contains 1 to n elements, our task is to sort this array in an efficient way. We are not allowed to simply copy the numbers from 1 to n.
Examples : 

Input : arr[] = {2, 1, 3};
Output : {1, 2, 3}

Input : arr[] = {2, 1, 4, 3};
Output : {1, 2, 3, 4} 

Native approach - O(n Log n) Time and 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.

#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

int main()
{
    // Input array containing elements from 1 to n
    vector<int> arr = { 3, 1, 4, 2, 5 };

    sort(arr.begin(), arr.end());

    for (int x : arr) {
        cout << x << " ";
    }
    return 0;
}

import java.util.Arrays;

public class Main {
    public static void main(String[] args)
    {
        // Input array containing elements from 1 to n
        int[] arr = { 3, 1, 4, 2, 5 };

        Arrays.sort(arr);

        System.out.print("Sorted array is : ");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

# Input list containing elements from 1 to n
arr = [3, 1, 4, 2, 5]

arr.sort()

print("Sorted array is :", *arr)

# This code is contributed by Ayush Mishra

// Function to sort an array
function main() {
    // Input array containing elements from 1 to n
    let arr = [3, 1, 4, 2, 5];

    // Sorting the array
    arr.sort((a, b) => a - b);

    // Print the sorted array
    process.stdout.write("Sorted array is : ");
    arr.forEach(num => process.stdout.write(num + " "));
}

// Execute the main function
main();

1 2 3 4 5 

Better Approach - Counting Sort - O(n) Time and 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 1 - O(n) Time and O(1) Space

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

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

#include <bits/stdc++.h>
using namespace std;

// Function to sort the array 
void sort(vector<int>& arr) {
    int i = 0;
    while (i < arr.size()) {
      
        // If element is not at its correct 
        // position, swap it
        if (arr[arr[i] - 1] != arr[i]) {
            swap(arr[i], arr[arr[i] - 1]);  
          
        } else {
            i++;
        }
    }
}

// Driver Code
int main() {
    vector<int> arr = {3, 2, 5, 6, 1, 4};
    sort(arr);
    for (int x : arr) 
        cout << x << " ";
    return 0;
}

/*package whatever //do not write package name here */

import java.io.*;
import java.util.Arrays;
class GFG {

      // Driver Code
    public static void main(String[] args)
    {
        int[] arr = { 3, 2, 5, 6, 1, 4 };
        
          // Function call
          sort(arr);

        // Printing the answer
        System.out.println(Arrays.toString(arr));
    }
    static void sort(int[] arr)
    {
        int i = 0;
        while (i < arr.length) {

            // Finding the correct index
            int correct = arr[i] - 1;

            // Element index and value not match
            // then swapping
            if (arr[correct] != arr[i]) {

                // Calling swap function
                swap(arr, i, correct);
            }
            else {
                i++;
            }
        }
    }

    // Function to swap values
    static void swap(int[] arr, int first, int second)
    {
        int temp = arr[first];
        arr[first] = arr[second];
        arr[second] = temp;
    }
}
// This code is contributed by Karan Hora

# Function to sort the array
def sort(arr, n):
    i = 0
    while(i < n):
        # finding the corrent index
        correct = arr[i]-1

        # Element index and value not match
        # then swapping
        if arr[correct] != arr[i]:
            # calling swap function
            swap(arr, i, correct)
        else:
            i = i + 1

# function to swap values
def swap(arr, first, second):
    temp = arr[first]
    arr[first] = arr[second]
    arr[second] = temp

# Driver Code
arr = [3, 2, 5, 6, 1, 4]
n = len(arr)

# function call
sort(arr, n)

# printing the answer
for i in range(0, n):
    print(arr[i], end=" ")

# This code is contributed by Yash Agarwal(yashagarwal2852002)

// C# code of the above approach
using System;

class MainClass
{
    // Function to sort the array
    static void sort(int[] arr, int n)
    {
        int i = 0;
      
        while (i < n)
        {
             // Finding the correct index
             int correct = arr[i] - 1;

             // Element index and value not match 
             // then swapping
             if (arr[correct] != arr[i])
             {
                // Calling swap function
                 swap(ref arr[i], ref arr[correct]);
             }
             else
             {
                 i++;
             }
        }
    }

    // Function to swap values
    static void swap(ref int a, ref int b)
    {
        int temp = a;
        a = b;
        b = temp;
    }

    // Driver Code
    public static void Main()
    {
        int[] arr = { 3, 2, 5, 6, 1, 4 };
        int n = arr.Length;

        // Function call
        sort(arr, n);

        // Printing the answer
        for (int i = 0; i < n; i++)
            Console.Write(arr[i] + " ");
    }
}

// This code is contributed by nikhilsainiofficial546

 // Function to sort the array
      function sort(arr, n) {
        var i = 0;
        while (i < n) {
          // Finding the correct index
          var correct = arr[i] - 1;

          // Element index and value not match
          // then swapping
          if (arr[correct] != arr[i]) {
            // Calling swap function
            swap(arr, i, correct);
          } else {
            i++;
          }
        }
      }

      // Function to swap values
      function swap(arr, i, correct) {
        var temp = arr[i];
        arr[i] = arr[correct];
        arr[correct] = temp;
      }

      // Driver Code

      var arr = [3, 2, 5, 6, 1, 4];
      var n = 6;

      // Function call
      sort(arr, n);

      // Printing the answer
      for (var i = 0; i < n; i++) {
        console.log(arr[i]);
      }

1 2 3 4 5 6 

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

Efficient Approach 2 - O(n) Time and O(1) Space

We can also solve this problem by storing old and new values together at an index with the help of remainder. 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 sorted values. Please refer the below link for detailed implementation.

Sort an array which contains 1 to n values – Set 2