Sort Array By Parity - Practice Coding Problems

Sort Array By Parity - Problem

You are given an integer array nums and need to rearrange it so that all even integers come before all odd integers.

Your task is to move all even numbers to the beginning of the array followed by all odd numbers. The relative order within even or odd numbers doesn't matter - any valid arrangement is acceptable.

Example: [3,1,2,4] could become [2,4,3,1] or [4,2,1,3]

Return any array that satisfies this condition where evens come first, then odds.

Input & Output

example_1.py — Basic Case

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

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

💡 Note: The even numbers 2 and 4 are moved to the beginning, followed by odd numbers 3 and 1. Note that [4,2,1,3] would also be a correct answer.

example_2.py — All Odds

$ Input: [0]

› Output: [0]

💡 Note: Single element array with an even number remains unchanged since 0 is even.

example_3.py — Mixed Case

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

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

💡 Note: All even numbers [2,4,6] come first, then all odd numbers [1,3,5]. The relative order within each group can vary.

Constraints

1 ≤ nums.length ≤ 5000
0 ≤ nums[i] ≤ 5000
Any valid arrangement where evens come before odds is acceptable

Visualization

Tap to expand

Understanding the Visualization

Setup Two Organizers

One organizer (left pointer) reserves spots at the front for couples, another (right pointer) scans the line

Find and Move Couples

When the scanner finds a couple, swap them to the front position and advance the front organizer

Continue Process

Keep scanning until the entire line is processed - all couples will be at the front

Perfect Organization

The line is now perfectly organized with couples first, singles after

Key Takeaway

🎯 Key Insight: Two pointers allow us to rearrange elements in a single pass by maintaining one pointer for placement and another for discovery, eliminating the need for extra space or multiple iterations.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses the two pointers technique to rearrange elements in-place with O(1) space and O(n) time. Keep one pointer for the next even position and scan with another pointer, swapping evens to the front as you find them.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (In-Place)	O(n)	O(1)	Use two pointers to rearrange elements in-place by swapping
Brute Force (Multiple Passes)	O(n)	O(n)	Create new arrays for evens and odds, then concatenate them

Two Pointers (In-Place) — Algorithm Steps

Initialize left pointer at index 0 (beginning of array)
Initialize right pointer at index 0 (will scan through array)
While right pointer is within bounds:
If element at right pointer is even, swap it with element at left pointer and increment left
Always increment right pointer to continue scanning
Continue until right pointer reaches the end

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Left pointer at 0 (even position), right pointer scanning

Find Even Number

Right pointer finds even number, swap with left position

Continue Process

Increment left after swap, continue with right pointer

Final State

All evens on left, odds on right

Code -

solution.c — C

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

int* sortArrayByParity(int* nums, int numsSize, int* returnSize) {
    int left = 0; // Points to position where next even should go
    
    // Right pointer scans through entire array
    for (int right = 0; right < numsSize; right++) {
        // If current element is even
        if (nums[right] % 2 == 0) {
            // Swap it to the left position
            int temp = nums[left];
            nums[left] = nums[right];
            nums[right] = temp;
            left++; // Move left pointer forward
        }
    }
    
    *returnSize = numsSize;
    return nums;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing for format [1,2,3,4]
    int nums[100];
    int size = 0;
    char* token = strtok(input, "[],\n");
    
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int returnSize;
    int* result = sortArrayByParity(nums, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with right pointer, left pointer moves at most n times total

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables, modifying the input array in-place

✓ Linear Space

85.2K Views

Medium Frequency

~15 min Avg. Time

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

Two Pointers (In-Place) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler