MOVE ALL NEGATIVE ELEMENTS TO END

 

Segregating Positive and Negative Elements in an Array (Stable Order)

Introduction

In this problem, we are given an array containing both positive and negative integers. The goal is to rearrange the array such that all positive elements appear first, followed by negative elements without changing their original order.

This condition makes the problem slightly more challenging because we must maintain the relative order of elements.

Problem Statement

Given an array arr[], rearrange it so that:

  • All positive elements come first

  • All negative elements come at the end

  • The order of elements must be preserved

Example

Input:

arr = [1, -1, 3, 2, -7, -5, 11, 6]

Output:

[1, 3, 2, 11, 6, -1, -7, -5]

Solution Code

class Solution {
    public void segregateElements(int[] arr) {
        int n = arr.length;
        int[] temp = new int[n];
        int index = 0;

       
        for (int i = 0; i < n; i++) {
            if (arr[i] >= 0) {
                temp[index++] = arr[i];
            }
        }

        for (int i = 0; i < n; i++) {
            if (arr[i] < 0) {
                temp[index++] = arr[i];
            }
        }

       
        for (int i = 0; i < n; i++) {
            arr[i] = temp[i];
        }
    }
}

Approach Used: Using Auxiliary Array (Stable Partition)

Idea

We use a temporary array to:

  1. First store all positive elements in order

  2. Then store all negative elements in order

  3. Copy the result back to the original array

How It Works

  1. Create a new array temp[]

  2. Traverse original array:

    • Add all non-negative (≥ 0) elements

  3. Traverse again:

    • Add all negative elements

  4. Copy elements from temp back to arr

Why This Approach Was Chosen

  • Maintains the original order of elements (stable)

  • Simple and easy to understand

  • Avoids complex in-place shifting logic

Alternative Approaches

  • In-place partition (like quicksort)
     Does not maintain order

  • Two-pointer approach
     Difficult to maintain stability

Why not used?
Because the problem specifically requires maintaining the order, which is easier with an auxiliary array.

Time and Space Complexity

  • Time Complexity: O(n)

  • Space Complexity: O(n)

Important Observation

  • arr[i] >= 0 is used to include zero as a positive number

  • Order is preserved because elements are added sequentially

Conclusion

Using an auxiliary array is an effective way to segregate positive and negative elements while maintaining order. Although it uses extra space, it ensures correctness and simplicity, making it a preferred approach for this problem.

Comments

Post a Comment

Popular posts from this blog

THE DELIVERY MAN

  The Delivery Man – Python List Operations  Introduction Lists in Python are used to store multiple items in a single variable. They are flexible, allowing us to add, remove, update, and manipulate elements easily. In this task, different list operations are performed to simulate a delivery man's workflow. 1. Creating a list and accessing an item items = ["Notebook", "Pencil", "Eraser", "Ruler", "Marker"] print(items[2]) Approach: Indexing Why: Lists use zero-based indexing, so the third item is accessed using index 2. 2. Adding a new item items.append("Glue Stick") print(items) Approach: append() method Why: It adds an item at the end of the list, which is ideal for adding new deliveries. 3. Inserting an item items.insert(2, "Highlighter") print(items) Approach: insert() method Why: Used when we need to add an item at a specific position instead of the end. 4. Removing an item items.remove("Ruler...
Read more

EC2 LAUNCHING

  EC2 Step 1: Launch EC2 Instance Go to: AWS Console --> EC2 --> Launch Instance Configure: Name : my-web-server AMI : Amazon Linux 2 (easy for beginners) Instance Type : t2.micro (free tier) Step 2: Key Pair Create or select a key pair. Step 3: Network Settings  Allow these: SSH (port 22) --> for login  HTTP (port 80) --> for web access Step 4: Launch Instance Click Launch Instance Step 5: Connect to Instance Use: EC2 --> Connect --> EC2 Instance Connect (easiest) OR via terminal: with this command. for this you have to download the pem files while selecting the key pair.  ssh -i your-key.pem ec2-user@<public-ip> Step 6: Install Web Server For Amazon Linux: sudo yum update -y sudo yum install httpd -y Step 7: Start Web Server sudo systemctl start httpd sudo systemctl enable httpd Step 8: Add a Web Page echo "Hello from EC2" | sudo tee /var/www/html/index.html Step 9: Get Public IP Go to EC2 d...
Read more

SORT A LINKED LIST USING MERGE SORT

  Sort a Linked List using Merge Sort Introduction Sorting a linked list efficiently is a common problem in data structures. Unlike arrays, linked lists do not allow direct access to elements, so algorithms like quicksort are not ideal. Merge Sort is the best choice for linked lists because: It does not require random access It works efficiently with node-based structures Problem Statement Given the head of a linked list: Sort the list in ascending order Return the sorted linked list Example Input: 10 -> 30 -> 20 -> 40 -> 60 -> 50 Output: 10 -> 20 -> 30 -> 40 -> 50 -> 60 Solution Code class Solution: def mergeSort(self, head): if not head or not head.next: return head mid = self.getMiddle(head) next_to_mid = mid.next mid.next = None left = self.mergeSort(head) right = self.mergeSort(next_to_mid) return self.merge(left, right) def getMiddle(self,...
Read more