Sort Array By Parity II - Practice Coding Problems

Sort Array By Parity II - Problem

Imagine you're organizing a dance where partners need to be arranged in a specific pattern! You have an array of integers nums where exactly half are even and exactly half are odd numbers.

Your goal is to rearrange the array so that:

Every even number sits at an even index (0, 2, 4, ...)
Every odd number sits at an odd index (1, 3, 5, ...)

For example: [4,2,5,7] becomes [4,5,2,7] where 4 and 2 (even) are at positions 0 and 2, while 5 and 7 (odd) are at positions 1 and 3.

Note: Any valid arrangement that satisfies the condition is acceptable!

Input & Output

example_1.py — Python

$ Input: [4,2,5,7]

› Output: [4,5,2,7]

💡 Note: Even numbers 4,2 go to even indices 0,2. Odd numbers 5,7 go to odd indices 1,3. The result satisfies the parity requirement.

example_2.py — Python

$ Input: [2,3]

› Output: [2,3]

💡 Note: Already correctly arranged: 2 (even) at index 0 (even), 3 (odd) at index 1 (odd). No changes needed.

example_3.py — Python

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

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

💡 Note: Original has odd numbers at even positions. After rearranging: evens (2,4) at positions (0,2), odds (1,3) at positions (1,3).

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Partners are randomly mixed. We need even-numbered partners at even positions (0,2,4...) and odd-numbered at odd positions (1,3,5...)

Two Organizers

Two organizers work simultaneously - one checks even positions, another checks odd positions for misplaced partners

Find Mismatches

When both organizers find misplaced partners, they coordinate a swap to fix both positions at once

Perfect Arrangement

Continue until all partners are in their correct positions - dance can begin!

Key Takeaway

🎯 Key Insight: The two-pointer technique leverages the constraint that we have equal numbers of even and odd elements, allowing us to fix misplacements in pairs with a single swap operation!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each pointer traverses the array at most once, and each element is examined at most twice

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for the two pointer variables

✓ Linear Space

Constraints

2 ≤ nums.length ≤ 2 × 10⁴
nums.length is even
Half of the integers in nums are even, and half are odd
-1000 ≤ nums[i] ≤ 1000

Asked in

⊞ Microsoft 15 a Amazon 12 G Google 8 Apple 6

The optimal solution uses the two pointers technique with O(n) time complexity. Maintain two pointers scanning even and odd positions separately. When finding misplaced elements (odd number at even index, even number at odd index), swap them directly. This approach is efficient because it guarantees each element moves at most once, and we're guaranteed to have equal numbers of even and odd elements.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Use two pointers to scan even and odd positions simultaneously
Brute Force (Find and Swap)	O(n²)	O(1)	For each position, search for correct parity element and swap

Two Pointers (Optimal) — Algorithm Steps

Initialize two pointers: evenIdx = 0, oddIdx = 1
While evenIdx < n, find the first even index with an odd number
While oddIdx < n, find the first odd index with an even number
Swap the misplaced elements at evenIdx and oddIdx
Increment both pointers and repeat until array is sorted

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set evenIdx=0 for even positions, oddIdx=1 for odd positions

Find Misplaced Elements

Move pointers to find odd number at even index and even number at odd index

Swap and Continue

Swap the misplaced elements and advance both pointers

Complete

All elements are now correctly positioned

Code -

solution.c — C

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

void sortArrayByParityII(int* nums, int numsSize) {
    int evenIdx = 0; // Points to even indices
    int oddIdx = 1;  // Points to odd indices
    
    while (evenIdx < numsSize) {
        // Find misplaced odd number at even index
        while (evenIdx < numsSize && nums[evenIdx] % 2 == 0) {
            evenIdx += 2;
        }
        
        // Find misplaced even number at odd index
        while (oddIdx < numsSize && nums[oddIdx] % 2 == 1) {
            oddIdx += 2;
        }
        
        // Swap if both misplaced elements found
        if (evenIdx < numsSize && oddIdx < numsSize) {
            int temp = nums[evenIdx];
            nums[evenIdx] = nums[oddIdx];
            nums[oddIdx] = temp;
            evenIdx += 2;
            oddIdx += 2;
        }
    }
}

int main() {
    int nums[] = {4, 2, 5, 7};
    int numsSize = 4;
    
    sortArrayByParityII(nums, numsSize);
    
    printf("[");
    for (int i = 0; i < numsSize; i++) {
        printf("%d", nums[i]);
        if (i < numsSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each pointer traverses the array at most once, and each element is examined at most twice

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for the two pointer variables

✓ Linear Space

Constraints

2 ≤ nums.length ≤ 2 × 10⁴
nums.length is even
Half of the integers in nums are even, and half are odd
-1000 ≤ nums[i] ≤ 1000

32.4K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler