Rearrange Array Elements by Sign - Practice Coding Problems

Rearrange Array Elements by Sign - Problem

Given an integer array nums with an even length containing an equal number of positive and negative integers, you need to rearrange the elements to create a perfectly alternating pattern.

Requirements:

🔄 Every consecutive pair must have opposite signs
📋 Preserve the relative order of positive numbers
📋 Preserve the relative order of negative numbers
➕ The result must start with a positive number

Example: [3, 1, -2, -5, 2, -4] becomes [3, -2, 1, -5, 2, -4]

Think of it like organizing a debate where speakers must alternate between supporting and opposing viewpoints, while maintaining their original speaking order within each side.

Input & Output

example_1.py — Basic Case

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

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

💡 Note: Positive numbers [3,1,2] go to even indices [0,2,4], negative numbers [-2,-5,-4] go to odd indices [1,3,5], maintaining their original relative order.

example_2.py — Different Order

$ Input: [-1,1]

› Output: [1,-1]

💡 Note: Simple case with one positive and one negative. Result starts with positive number at index 0.

example_3.py — Larger Array

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

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

💡 Note: All positive numbers [1,2,3] maintain their order at even indices, all negative numbers [-1,-2,-3] maintain their order at odd indices.

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

Leaders (positive) go to even positions, Followers (negative) to odd positions

Two Pointer Placement

Use two pointers to track next available position for each type

Direct Assignment

Place each person directly at their designated position in one pass

Key Takeaway

🎯 Key Insight: Since we know the exact alternating pattern and have equal counts, we can use two pointers to directly place elements at their final positions in O(n) time, avoiding the need for multiple scans or temporary storage.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element is processed once

✓ Linear Growth

Space Complexity

O(n)

Space for the result array, no additional data structures needed

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 2 × 10⁵
nums.length is even
1 ≤ |nums[i]| ≤ 10⁵
nums consists of equal number of positive and negative integers

Asked in

A Amazon 45 ⊞ Microsoft 32 G Google 28 f Meta 19

The optimal solution uses two pointers technique with O(n) time complexity. Key insight: since we need alternating positive/negative pattern starting with positive, we can directly place positive numbers at even indices (0,2,4...) and negative numbers at odd indices (1,3,5...) while preserving their relative order. This eliminates the need for multiple scans or complex data structures.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(n)	Use two pointers to track positions for positive and negative elements
Brute Force (Multiple Scans)	O(n²)	O(n)	Scan array multiple times to find next positive/negative element for each position

Two Pointers (Optimal) — Algorithm Steps

Initialize result array and two pointers: posIndex = 0, negIndex = 1
Iterate through original array once
If current element is positive, place at posIndex and increment by 2
If current element is negative, place at negIndex and increment by 2
Continue until all elements are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize pointers

posIndex = 0 (even), negIndex = 1 (odd)

Process elements

Place positive at posIndex, negative at negIndex

Increment by 2

Move pointers by 2 to maintain alternating pattern

Code -

solution.c — C

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

int* rearrangeArray(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    int posIndex = 0;  // Even indices for positive numbers
    int negIndex = 1;  // Odd indices for negative numbers
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > 0) {
            result[posIndex] = nums[i];
            posIndex += 2;
        } else {
            result[negIndex] = nums[i];
            negIndex += 2;
        }
    }
    
    return result;
}

int main() {
    int nums[] = {3, 1, -2, -5, 2, -4};
    int numsSize = 6;
    int returnSize;
    
    int* result = rearrangeArray(nums, numsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize-1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element is processed once

✓ Linear Growth

Space Complexity

O(n)

Space for the result array, no additional data structures needed

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 2 × 10⁵
nums.length is even
1 ≤ |nums[i]| ≤ 10⁵
nums consists of equal number of positive and negative integers

47.3K Views

Medium-High Frequency

~15 min Avg. Time

1.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler