Moving Negative Elements to the end of the array

How I Understood Moving Negative Elements to the End of an Array
At first, this problem looked tricky because it asks us to move all negative numbers to the end while keeping the relative order of the other elements.
But after breaking it down, I realized the idea is simple: separate positives and negatives, then combine them.

Problem
Given an array of integers, move all negative numbers to the end without changing the relative order of positive and negative numbers.
Example:
Python
arr = [1, -1, 3, 2, -7, -5, 11, 6]
Expected output:
Python
[1, 3, 2, 11, 6, -1, -7, -5]
Notice that the relative order of positives and negatives remains the same.

What I Noticed
Instead of trying to swap elements in place and manage complicated pointer logic, I focused on a simpler idea:
First, collect all non-negative numbers in order
Then, collect all negative numbers in order
Finally, copy them back to the original array
This keeps the original order intact and is easy to implement.

** What Helped Me**
Using a temporary array made the solution straightforward:
Append all non-negative numbers to the temporary array
Append all negative numbers after that
Copy the temporary array back to the original array
No complicated swaps, no pointer juggling — just step by step.

Code (Python)
Python
class Solution:
def segregateElements(self, arr):
"""
Moves all negative elements to the end of the array
without changing the relative order of elements.
"""
n = len(arr)
temp = []

    # Step 1: Append non-negative numbers

    for x in arr:

        if x >= 0:

            temp.append(x)

# Step 2: Append negative numbers
for x in arr:
    if x < 0:
        temp.append(x)

# Step 3: Copy back to original array
for i in range(n):
    arr[i] = temp[i]



    

    

Example usage

arr = [1, -1, 3, 2, -7, -5, 11, 6]
solution = Solution()
solution.segregateElements(arr)
print(arr)
Output:
Plain text
[1, 3, 2, 11, 6, -1, -7, -5]

** Complexity**
Time: O(n) — iterate through the array twice
Space: O(n) — uses a temporary array

What I Learned
This problem isn’t about writing complex code.
It’s about:
Thinking clearly
Separating positives and negatives
Preserving order
Step-by-step processing
Sometimes a simple temporary array is easier than trying to do everything in-place.

_ Final Thought_
Initially, moving negative elements seemed tricky because of the order constraint.
But once I broke it down:

** “Let’s just collect positives first, then negatives.”**
…it became simple and easy to implement.
This problem is a good reminder that clarity beats overcomplication in array problems