Rearrange Array Elements by Sign

Rearrange Array Elements by Sign - Problem

You are given a 0-indexed integer array nums of even length consisting of an equal number of positive and negative integers.

You should return the array of nums such that the array follows the given conditions:

Every consecutive pair of integers have opposite signs.
For all integers with the same sign, the order in which they were present in nums is preserved.
The rearranged array begins with a positive integer.

Return the modified array after rearranging the elements to satisfy the aforementioned conditions.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: Positive numbers [3,1,2] are placed at even indices (0,2,4), negative numbers [-2,-5,-4] at odd indices (1,3,5), preserving original order within each sign.

Example 2 — Simple Case

$ Input: nums = [-1,1]

› Output: [1,-1]

💡 Note: Only one positive (1) and one negative (-1). Result starts with positive at index 0, negative at index 1.

Example 3 — Multiple Elements

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

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

💡 Note: Positives [1,2,5] maintain order at indices 0,2,4. Negatives [-3,-4,-6] maintain order at indices 1,3,5.

Constraints

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

Visualization

Tap to expand

Asked in

M Microsoft 15 a Amazon 12 A Adobe 8

The key insight is to use two pointers to place positive numbers at even indices and negative numbers at odd indices in a single pass. The optimal approach uses direct placement with O(n) time and O(n) space complexity, maintaining the original relative order of elements with the same sign.

Common Approaches

✓ Separate and Merge

⏱️ Time: O(n) Space: O(n)

First pass collects all positive numbers, second pass collects negatives, then merge them alternating starting with positive at index 0.

Two Pointers Direct Placement

⏱️ Time: O(n) Space: O(n)

Iterate through the original array once, using two pointers to place positive numbers at even indices and negative numbers at odd indices directly in the result array.

Separate and Merge — Algorithm Steps

Step 1: Iterate through array to collect all positive numbers
Step 2: Iterate again to collect all negative numbers
Step 3: Merge arrays alternating positive-negative pattern

Visualization

Tap to expand

Step-by-Step Walkthrough

Separate

Collect positives: [3,1] and negatives: [-2,-5]

Merge

Alternate: positive, negative, positive, negative

Result

Final array: [3,-2,1,-5]

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int* returnSize) {
    int* positives = (int*)malloc(numsSize * sizeof(int));
    int* negatives = (int*)malloc(numsSize * sizeof(int));
    int posCount = 0, negCount = 0;
    
    // Collect positive numbers
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > 0) {
            positives[posCount++] = nums[i];
        }
    }
    
    // Collect negative numbers
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < 0) {
            negatives[negCount++] = nums[i];
        }
    }
    
    // Merge alternating positive-negative
    int* result = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < posCount; i++) {
        result[2 * i] = positives[i];
        result[2 * i + 1] = negatives[i];
    }
    
    *returnSize = numsSize;
    free(positives);
    free(negatives);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for array
    int nums[1000];
    int size = 0;
    char* ptr = strchr(line, '[') + 1;
    char* token = strtok(ptr, ",]");
    
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* result = solution(nums, size, &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)

Three passes through the array: collect positives, collect negatives, merge results

✓ Linear Growth

Space Complexity

O(n)

Two temporary arrays to store positive and negative numbers separately

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Separate and Merge — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler