Sort Even and Odd Indices Independently - Practice Coding Problems

Sort Even and Odd Indices Independently - Problem

Array Sorting Easy

You're given a 0-indexed integer array nums and need to rearrange its values following two independent sorting rules:

Even indices (0, 2, 4, ...): Sort values in non-decreasing order (ascending)
Odd indices (1, 3, 5, ...): Sort values in non-increasing order (descending)

Example walkthrough:
Given nums = [4,1,2,3]
• Even indices: positions 0,2 have values [4,2] → sort ascending → [2,4]
• Odd indices: positions 1,3 have values [1,3] → sort descending → [3,1]
• Result: [2,3,4,1]

The key insight is that we're not sorting the entire array - we're treating even and odd positioned elements as two separate groups with different sorting rules!

Input & Output

example_1.py — Basic Case

$ Input: nums = [4,1,2,3]

› Output: [2,3,4,1]

💡 Note: Even indices (0,2) have values [4,2]. Sorted ascending: [2,4]. Odd indices (1,3) have values [1,3]. Sorted descending: [3,1]. Result: [2,3,4,1].

example_2.py — Already Sorted Case

$ Input: nums = [2,1]

› Output: [2,1]

💡 Note: Even index 0 has value [2] (already sorted). Odd index 1 has value [1] (already sorted). No changes needed.

example_3.py — Larger Array

$ Input: nums = [1,9,2,8,3,7,4,6,5]

› Output: [1,9,2,8,3,7,4,6,5]

💡 Note: Even indices (0,2,4,6,8) have values [1,2,3,4,5] - already sorted ascending. Odd indices (1,3,5,7) have values [9,8,7,6] - already sorted descending. Array remains unchanged.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
nums.length can be odd or even
All elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Separate Groups

Collect all people from even-numbered seats and odd-numbered seats separately

Sort Each Group

Sort even-seat people by height ascending, odd-seat people by height descending

Seat Assignment

Place sorted people back into their respective even/odd seats

Final Arrangement

Everyone is now properly arranged according to their seat group's rules

Key Takeaway

🎯 Key Insight: Transform one complex sorting problem into two simple, independent sorting operations by separating elements based on index parity!

Asked in

G Google 25 a Amazon 20 f Meta 15 ⊞ Microsoft 18

The optimal solution uses the Extract-Sort-Merge approach: separate elements by index parity into two arrays, sort even indices ascending and odd indices descending, then merge back. Time complexity: O(n log n), Space: O(n). This transforms one complex sorting problem into two simple, independent sorting operations.

Common Approaches

Approach	Time	Space	Notes
✓ Extract-Sort-Merge Approach	O(n log n)	O(n)	Extract even/odd elements, sort separately, then merge back
Brute Force (Selection Sort)	O(n²)	O(1)	Use selection sort separately for even and odd indices

Extract-Sort-Merge Approach — Algorithm Steps

Extract all elements at even indices into one array
Extract all elements at odd indices into another array
Sort the even-indexed array in ascending order
Sort the odd-indexed array in descending order
Merge sorted arrays back to their original even/odd positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Phase

Separate even and odd positioned elements into different arrays

Sort Phase

Sort even array ascending, odd array descending

Merge Phase

Place sorted elements back into their respective positions

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int compareAsc(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int compareDesc(const void* a, const void* b) {
    return (*(int*)b - *(int*)a);
}

void sortEvenOdd(int* nums, int n) {
    int* evenElements = malloc((n/2 + 1) * sizeof(int));
    int* oddElements = malloc((n/2 + 1) * sizeof(int));
    int evenCount = 0, oddCount = 0;
    
    // Extract elements at even and odd indices
    for (int i = 0; i < n; i++) {
        if (i % 2 == 0) {
            evenElements[evenCount++] = nums[i];
        } else {
            oddElements[oddCount++] = nums[i];
        }
    }
    
    // Sort even elements in ascending order
    qsort(evenElements, evenCount, sizeof(int), compareAsc);
    
    // Sort odd elements in descending order
    qsort(oddElements, oddCount, sizeof(int), compareDesc);
    
    // Merge back into original array
    int evenIdx = 0, oddIdx = 0;
    for (int i = 0; i < n; i++) {
        if (i % 2 == 0) {
            nums[i] = evenElements[evenIdx++];
        } else {
            nums[i] = oddElements[oddIdx++];
        }
    }
    
    free(evenElements);
    free(oddElements);
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // Read '['
    while (scanf("%d", &nums[n]) == 1) {
        n++;
        scanf("%c", &c); // Read ',' or ']'
        if (c == ']') break;
    }
    
    sortEvenOdd(nums, n);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        printf("%d", nums[i]);
        if (i < n - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting two arrays of size n/2 each takes O(n/2 log n/2) = O(n log n) time total

⚡ Linearithmic

Space Complexity

O(n)

Need two temporary arrays to store even and odd elements, totaling O(n) space

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~15 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Extract-Sort-Merge Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler