Segregate Negatives and Positives - Problem

Given an array of integers containing both negative and positive numbers, rearrange the array so that all negative numbers appear before all positive numbers.

The relative order of negative numbers among themselves should be maintained, and the relative order of positive numbers among themselves should also be maintained.

Example:

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

Note: Zero (if present) can be treated as a positive number.

Input & Output

Example 1 — Basic Mixed Array

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

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

💡 Note: All negatives (-1, -3, -6) come first in their original order, followed by all positives (2, 4, 5) in their original order

Example 2 — All Negatives First

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

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

💡 Note: Already properly arranged - negatives are already before positives

Example 3 — Including Zero

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

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

💡 Note: Zero is treated as positive, so negatives (-1, -2) come first, then positives (0, 3)

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁶ ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

M Microsoft 35 a Amazon 28 G Google 22

The key insight is to maintain relative order while separating negatives and positives. The two separate arrays approach is simplest with O(n) time and O(n) space, while the in-place approach uses O(1) space but O(n²) time due to shifting.

Common Approaches

✓ Two Separate Arrays

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

Scan through the array once to collect all negative numbers in order, then scan again to collect all positive numbers in order. Finally, combine both arrays.

Two-Pointer In-Place

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

Use a write pointer to track where the next negative number should go. Scan through the array, and when we find a negative number, move it to the front while shifting positive numbers to the right.

Two Separate Arrays — Algorithm Steps

Create two empty arrays: negatives and positives
Iterate through original array
Add negative numbers to negatives array, positive numbers to positives array
Concatenate negatives array with positives array

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Original

Go through each element in original array

Separate

Put negatives in one array, positives in another

Merge

Combine negatives first, then positives

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int* returnSize) {
    int* result = (int*)malloc(numsSize * sizeof(int));
    int negCount = 0, posCount = 0;
    
    // Count negatives first
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < 0) negCount++;
    }
    
    int negIdx = 0, posIdx = negCount;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < 0) {
            result[negIdx++] = nums[i];
        } else {
            result[posIdx++] = nums[i];
        }
    }
    
    *returnSize = numsSize;
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    
    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++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array to separate elements, O(n) to copy back

✓ Linear Growth

Space Complexity

O(n)

Two additional arrays to store separated negative and positive numbers

⚡ Linearithmic Space

34.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Segregate Negatives and Positives - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two Separate Arrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler