Sorting all array elements except one (original) (raw)

Last Updated : 7 Jun, 2026

Given an array **arr[] and an integer **k, sort the array in **ascending order while keeping the element at index **k fixed at its original position. Return the resulting array.

**Examples:

**Input: arr[] = [10, 4, 11, 7, 6, 20], k = 2
**Output: [4, 6, 11, 7, 10, 20]
**Explanation: The element 11 at index 2 remains fixed, while all other elements are sorted in ascending order.

**Input: arr[] = [30, 20, 10], k = 0
**Output: [30, 10, 20]
**Explanation: The element 30 at index 0 remains fixed, while the remaining elements are sorted in ascending order.

Try It Yourself

Table of Content

• [Naive Approach] Using Temporary Array - O(n log n) Time O(n) Space
• [Expected Approach] Move to End and Sort In-Place - O(n log n) Time O(1) Space

[Naive Approach] Using Temporary Array - O(n log n) Time O(n) Space

The idea is to keep the element at index k fixed and store all the remaining elements in a temporary array. Sort the temporary array and place the sorted elements back into the original array while skipping index k. This ensures that the element at index k remains unchanged and all other elements are sorted in ascending order.

C++ `

#include #include #include using namespace std;

void sortExceptK(vector &arr, int k) { vector temp;

// Store all elements except arr[k]
for (int i = 0; i < arr.size(); i++)
{
    if (i != k)
    {
        temp.push_back(arr[i]);
    }
}

// Sort remaining elements
sort(temp.begin(), temp.end());

// Place sorted elements back
int idx = 0;
for (int i = 0; i < arr.size(); i++)
{
    if (i != k)
    {
        arr[i] = temp[idx++];
    }
}

}

// Driver Code int main() { vector arr = {30, 20, 10}; int k = 0;

sortExceptK(arr, k);

cout << "[";

for (int i = 0; i < arr.size(); i++)
{
    cout << arr[i];

    if (i != arr.size() - 1)
    {
        cout << ", ";
    }
}

cout << "]";

return 0;

}

Java

import java.util.Arrays;

public class GfG { public static void sortExceptK(int[] arr, int k) { int[] temp = new int[arr.length - 1];

    // Store all elements except arr[k]
    int idx = 0;
    for (int i = 0; i < arr.length; i++) {
        if (i != k) {
            temp[idx++] = arr[i];
        }
    }

    // Sort remaining elements
    Arrays.sort(temp);

    // Place sorted elements back
    idx = 0;
    for (int i = 0; i < arr.length; i++) {
        if (i != k) {
            arr[i] = temp[idx++];
        }
    }
}

public static void main(String[] args)
{
    int[] arr = { 30, 20, 10 };
    int k = 0;

    sortExceptK(arr, k);

    System.out.print("[");

    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i]);

        if (i != arr.length - 1) {
            System.out.print(", ");
        }
    }

    System.out.print("]");
}

}

Python

from typing import List

def sortExceptK(arr: List[int], k: int): temp = []

# Store all elements except arr[k]
for i in range(len(arr)):
    if i != k:
        temp.append(arr[i])

# Sort remaining elements
temp.sort()

# Place sorted elements back
idx = 0
for i in range(len(arr)):
    if i != k:
        arr[i] = temp[idx]
        idx += 1

Driver Code

if name == "main": arr = [30, 20, 10] k = 0

sortExceptK(arr, k)

print("[", end="")

for i in range(len(arr)):
    print(arr[i], end="")

    if i != len(arr) - 1:
        print(", ", end="")

print("]")

C#

using System; using System.Collections.Generic;

class GfG { static void sortExceptK(List arr, int k) { List temp = new List();

    // Store all elements except arr[k]
    for (int i = 0; i < arr.Count; i++) {
        if (i != k) {
            temp.Add(arr[i]);
        }
    }

    // Sort remaining elements
    temp.Sort();

    // Place sorted elements back
    int idx = 0;
    for (int i = 0; i < arr.Count; i++) {
        if (i != k) {
            arr[i] = temp[idx++];
        }
    }
}

// Driver Code
static void Main()
{
    List<int> arr = new List<int>{ 30, 20, 10 };
    int k = 0;

    sortExceptK(arr, k);

    Console.Write("[");

    for (int i = 0; i < arr.Count; i++) {
        Console.Write(arr[i]);

        if (i != arr.Count - 1) {
            Console.Write(", ");
        }
    }

    Console.Write("]");
}

}

JavaScript

function sortExceptK(arr, k) { var temp = [];

// Store all elements except arr[k]
for (var i = 0; i < arr.length; i++) {
    if (i !== k) {
        temp.push(arr[i]);
    }
}

// Sort remaining elements
temp.sort(function(a, b) { return a - b });

// Place sorted elements back
var idx = 0;
for (var i = 0; i < arr.length; i++) {
    if (i !== k) {
        arr[i] = temp[idx++];
    }
}

}

// Driver Code var arr = [ 30, 20, 10 ]; var k = 0;

sortExceptK(arr, k);

console.log("[");

for (var i = 0; i < arr.length; i++) { console.log(arr[i]);

if (i !== arr.length - 1) {
    console.log(", ");
}

}

console.log("]");

`

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

[Expected Approach] Move to End and Sort In-Place - O(n log n) Time O(1) Space

The idea is to temporarily move the element at index k to the end.. Then, sort the first n - 1 elements. Finally, move the fixed element back to its original position by repeatedly swapping it with its previous element. This sorts all elements except the one at index k while using constant extra space.

C++ `

#include #include #include using namespace std;

void sortExceptK(vector &arr, int k) { int n = arr.size();

// Move the element at index k to the end to keep it unmoved
swap(arr[n - 1], arr[k]);

// Sort the array except the last element (formerly at index k)
sort(arr.begin(), arr.end() - 1);

// Shift sorted elements to restore the original position of k
for (int i = n - 2; i >= k; --i)
{
    swap(arr[i], arr[i + 1]);
}

}

// Driver Code int main() { vector arr = {30, 20, 10}; int k = 0;

sortExceptK(arr, k);

cout << "[";

for (int i = 0; i < arr.size(); i++)
{
    cout << arr[i];

    if (i != arr.size() - 1)
    {
        cout << ", ";
    }
}

cout << "]";

return 0;

}

Java

import java.util.Arrays;

public class GfG { static void sortExceptK(int[] arr, int k) { int n = arr.length;

    // Move the element at index k to the end
    int temp = arr[n - 1];
    arr[n - 1] = arr[k];
    arr[k] = temp;

    // Sort the array except the last element
    Arrays.sort(arr, 0, n - 1);

    // Shift sorted elements to restore the original
    // position of k
    for (int i = n - 2; i >= k; --i) {
        temp = arr[i];
        arr[i] = arr[i + 1];
        arr[i + 1] = temp;
    }
}

// Driver Code
public static void main(String[] args)
{
    int[] arr = { 30, 20, 10 };
    int k = 0;

    sortExceptK(arr, k);

    System.out.print("[");

    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i]);

        if (i != arr.length - 1) {
            System.out.print(", ");
        }
    }

    System.out.print("]");
}

}

Python

def sortExceptK(arr, k): n = len(arr)

# Move the element at index k to the end
arr[n - 1], arr[k] = arr[k], arr[n - 1]

# Sort the array except the last element
arr[:n - 1] = sorted(arr[:n - 1])

# Shift sorted elements to restore the original position of k
for i in range(n - 2, k - 1, -1):
    arr[i], arr[i + 1] = arr[i + 1], arr[i]

Driver Code

if name == "main": arr = [30, 20, 10] k = 0

sortExceptK(arr, k)

print("[", end="")

for i in range(len(arr)):
    print(arr[i], end="")

    if i != len(arr) - 1:
        print(", ", end="")

print("]")

C#

using System; using System.Collections.Generic;

class GfG { static void sortExceptK(List arr, int k) { int n = arr.Count;

    // Move the element at index k to the end
    int temp = arr[n - 1];
    arr[n - 1] = arr[k];
    arr[k] = temp;

    // Sort the array except the last element
    arr.Sort(0, n - 1, Comparer<int>.Default);

    // Shift sorted elements to restore the original
    // position of k
    for (int i = n - 2; i >= k; --i) {
        int t = arr[i];
        arr[i] = arr[i + 1];
        arr[i + 1] = t;
    }
}

// Driver Code
static void Main()
{
    List<int> arr = new List<int>{ 30, 20, 10 };
    int k = 0;

    sortExceptK(arr, k);

    Console.Write("[");

    for (int i = 0; i < arr.Count; i++) {
        Console.Write(arr[i]);

        if (i != arr.Count - 1) {
            Console.Write(", ");
        }
    }

    Console.Write("]");
}

}

JavaScript

function sortExceptK(arr, k) { const n = arr.length;

// Move the element at index k to the end to keep it
// unmoved
[arr[n - 1], arr[k]] = [ arr[k], arr[n - 1] ];

// Sort the array except the last element (formerly at
// index k)
arr.slice(0, n - 1).sort((a, b) => a - b);

// Shift sorted elements to restore the original
// position of k
for (let i = n - 2; i >= k; --i) {
    [arr[i], arr[i + 1]] = [ arr[i + 1], arr[i] ];
}

}

// Driver Code const arr = [ 30, 20, 10 ]; const k = 0;

sortExceptK(arr, k);

console.log("[" + arr.join(", ") + "]");

`

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