Positive elements at even and negative at odd positions (Relative order not maintained)

You have been given an array and you have to make a program to convert that array such that positive elements occur at even numbered places in the array and negative elements occur at odd numbered places in the array. We have to do it in place.

There can be unequal number of positive and negative values and the extra values have to left as it is.

The idea is to use Hoare’s partition process of Quick Sort.
We take two pointers positive and negative. We set the positive pointer at start of the array and the negative pointer at 1st position of the array.
We move positive pointer two steps forward till it finds a negative element. Similarly we move negative pointer forward by two places till it finds a positive value at its position.
If the positive and negative pointers are in the array then we will swap the values at these indexes otherwise we will stop executing the process.

C++

filter_none

editclose

play_arrow

linkbrightness_4code

// C++ program to rearrange positive and negative

// numbers

#include <bits/stdc++.h>

usingnamespacestd;

voidrearrange(inta[], intsize)

{

intpositive = 0, negative = 1;

while(true) {

/* Move forward the positive pointer till

negative number number not encountered */

while(positive < size && a[positive] >= 0)

positive += 2;

/* Move forward the negative pointer till

positive number number not encountered */

while(negative < size && a[negative] <= 0)

negative += 2;

// Swap array elements to fix their position.

if(positive < size && negative < size)

swap(a[positive], a[negative]);

/* Break from the while loop when any index

exceeds the size of the array */

else

break;

}

}

// Driver code

intmain()

{

intarr[] = { 1, -3, 5, 6, -3, 6, 7, -4, 9, 10 };

intn = (sizeof(arr) / sizeof(arr[0]));

rearrange(arr, n);

for(inti = 0; i < n; i++)

cout << arr[i] << " ";

return0;

}

chevron_right

filter_none

Java

filter_none

editclose

play_arrow

linkbrightness_4code

// Java program to rearrange positive

// and negative numbers

importjava.io.*;

classGFG {

staticvoidrearrange(inta[], intsize)

{

intpositive = 0, negative = 1, temp;

while(true) {

/* Move forward the positive pointer till

negative number number not encountered */

while(positive < size && a[positive] >= 0)

positive += 2;

/* Move forward the negative pointer till

positive number number not encountered */

while(negative < size && a[negative] <= 0)

negative += 2;

// Swap array elements to fix their position.

if(positive < size && negative < size) {

temp = a[positive];

a[positive] = a[negative];

a[negative] = temp;

}

/* Break from the while loop when any index

exceeds the size of the array */

else

break;

}

}

// Driver code

publicstaticvoidmain(String args[]) {

intarr[] = {1, -3, 5, 6, -3, 6, 7, -4, 9, 10};

intn = arr.length;

rearrange(arr, n);

for(inti = 0; i < n; i++)

System.out.print(arr[i] + " ");

}

}

/*This code is contributed by Nikita Tiwari.*/

chevron_right

filter_none

Python3

filter_none

editclose

play_arrow

linkbrightness_4code

# Python 3 program to rearrange

# positive and negative numbers

defrearrange(a, size) :

positive =0

negative =1

while(True) :

# Move forward the positive

# pointer till negative number

# number not encountered

while(positive < size anda[positive] >=0) :

positive =positive +2

# Move forward the negative

# pointer till positive number

# number not encountered

while(negative < size anda[negative] <=0) :

negative =negative +2

# Swap array elements to fix

# their position.

if(positive < size andnegative < size) :

temp =a[positive]

a[positive] =a[negative]

a[negative] =temp

# Break from the while loop when

# any index exceeds the size of

# the array

else:

break

# Driver code

arr =[ 1, -3, 5, 6, -3, 6, 7, -4, 9, 10]

n =len(arr)

rearrange(arr, n)

fori inrange(0, n) :

print(arr[i], end =" ")

# This code is contributed by Nikita Tiwari.

chevron_right

filter_none

C#

filter_none

editclose

play_arrow

linkbrightness_4code

// C# program to rearrange positive

// and negative numbers

usingSystem;

classGFG {

// Function to rearrange

staticvoidrearrange(int[]a, intsize)

{

intpositive = 0, negative = 1, temp;

while(true) {

// Move forward the positive pointer till

// negative number number not encountered

while(positive < size && a[positive] >= 0)

positive += 2;

// Move forward the negative pointer till

// positive number number not encountered

while(negative < size && a[negative] <= 0)

negative += 2;

// Swap array elements to fix their position.

if(positive < size && negative < size) {

temp = a[positive];

a[positive] = a[negative];

a[negative] = temp;

}

// Break from the while loop when any

// index exceeds the size of the array

else

break;

}

}

// Driver Code

publicstaticvoidMain(String []args) {

int[]arr = {1, -3, 5, 6, -3, 6, 7, -4, 9, 10};

intn = arr.Length;

rearrange(arr, n);

for(inti = 0; i < n; i++)

Console.Write(arr[i] + " ");

}

}

// This code is contributed by Nitin Mittal.

chevron_right

filter_none

PHP

filter_none

editclose

play_arrow

linkbrightness_4code

<?php

// PHP program to rearrange positive

// and negative numbers

functionrearrange(&$a, $size)

{

$positive= 0;

$negative= 1;

while(true)

{

/* Move forward the positive

pointer till negative number

number not encountered */

while($positive< $size&&

$a[$positive] >= 0)

$positive+= 2;

/* Move forward the negative

pointer till positive number

number not encountered */

while($negative< $size&&

$a[$negative] <= 0)

$negative+= 2;

// Swap array elements to fix

// their position.

if($positive< $size&&

$negative< $size)

{

$temp= $a[$positive];

$a[$positive] = $a[$negative];

$a[$negative] = $temp;

}

/* Break from the while loop

when any index exceeds the

size of the array */

else

break;

}

}

// Driver code

$arr= array( 1, -3, 5, 6, -3,

6, 7, -4, 9, 10 );

$n= sizeof($arr);

rearrange($arr, $n);

for($i= 0; $i< $n; $i++)

echo$arr[$i] ." ";

// This code is contributed by ChitraNayal

?>

chevron_right

filter_none

Output:

1 -3 5 -3 6 6 7 -4 9 10

Lets explain the working of the code on the first example
arr[] = {1, -3, 5, 6, -3, 6, 7, -4, 9, 10}
We declare two variables positive and negative positive points to zeroth position and negative points to first position
positive = 0 negative = 1
In the first iteration positive will move 4 places to fifth position as a[4] is less than zero and positive = 4.
Negative will move 2 places and will point to fourth position as a[3]>0
we will swap positive and negative position values as they are less than size of array.
After first iteration the array becomes arr[] = {1, -3, 5, -3, 6, 6, 7, -4, 9, 10}

Now positive points at fourth position and negative points at third position
In second iteration the positive value will move 6 places and its value will
more than the size of the array.
The negative pointer will move two steps forward and it will point to 5th position
As the positive pointer value becomes greater than the array size we will not perform any swap operation and break out of the while loop.
The final output will be
arr[] = {1, -3, 5, -3, 6, 6, 7, -4, 9, 10}

Another Approach :-
The idea is to find a positive/negative element which is in incorrect place(i.e. positive at odd and negative at even place) and the then find the element of opposite sign which is also in incorrect position in the remaining array and then swap these two elements.
Here is the implementation of the above idea.

C++

filter_none

editclose

play_arrow

linkbrightness_4code

// C++ program to rearrange positive

// and negative numbers

#include<iostream>

usingnamespacestd;

// Swap function

voidswap(int* a, inti , intj)

{

inttemp = a[i];

a[i] = a[j];

a[j] = temp;

return;

}

// Print array function

voidprintArray(int* a, intn)

{

for(inti = 0; i < n; i++)

cout << a[i] << " ";

cout << endl;

return;

}

// Driver code

intmain()

{

intarr[] = { 1, -3, 5, 6, -3, 6, 7, -4, 9, 10 };

intn = sizeof(arr)/sizeof(arr[0]);

//before modification

printArray(arr, n);

for(inti = 0; i < n; i++)

{

if(arr[i] >= 0 && i % 2 == 1)

{

// out of order positive element

for(intj = i + 1; j < n; j++)

{

if(arr[j] < 0 && j % 2 == 0)

{

// find out of order negative

// element in remaining array

swap(arr, i, j);

break;

}

}

}

elseif(arr[i] < 0 && i % 2 == 0)

{

// out of order negative element

for(intj = i + 1; j < n; j++)

{

if(arr[j] >= 0 && j % 2 == 1)

{

// find out of order positive

// element in remaining array

swap(arr, i, j);

break;

}

}

}

}

//after modification

printArray(arr, n);

return0;

}

// This code is contributed by AnitAggarwal

chevron_right

filter_none

Java

filter_none

editclose

play_arrow

linkbrightness_4code

// Java program to rearrange positive

// and negative numbers

importjava.io.*;

importjava.util.*;

classGFG

{

// Swap function

staticvoidswap(int[] a, inti, intj)

{

inttemp = a[i];

a[i] = a[j];

a[j] = temp;

}

// Print array function

staticvoidprintArray(int[] a, intn)

{

for(inti = 0; i < n; i++)

System.out.print(a[i] + " ");

System.out.println();

}

// Driver code

publicstaticvoidmain(String args[])

{

int[] arr = { 1, -3, 5, 6, -3, 6, 7, -4, 9, 10};

intn = arr.length;

//before modification

printArray(arr, n);

for(inti = 0; i < n; i++)

{

if(arr[i] >= 0&& i % 2== 1)

{

// out of order positive element

for(intj = i + 1; j < n; j++)

{

if(arr[j] < 0&& j % 2== 0)

{

// find out of order negative

// element in remaining array

swap(arr, i, j);

break;

}

}

}

elseif(arr[i] < 0&& i % 2== 0)

{

// out of order negative element

for(intj = i + 1; j < n; j++)

{

if(arr[j] >= 0&& j % 2== 1)

{

// find out of order positive

// element in remaining array

swap(arr, i, j);

break;

}

}

}

}

//after modification

printArray(arr, n);

}

}

// This code is contributed by rachana soma

chevron_right

filter_none

Python3

filter_none

editclose

play_arrow

linkbrightness_4code

# Python3 program to rearrange positive

# and negative numbers

# Print array function

defprintArray(a, n):

fori ina:

print(i, end =" ")

print()

# Driver code

arr =[1, -3, 5, 6, -3, 6, 7, -4, 9, 10]

n =len(arr)

# before modification

printArray(arr, n)

fori inrange(n):

if(arr[i] >=0andi %2==1):

# out of order positive element

forj inrange(i +1, n):

if(arr[j] < 0andj %2==0):

# find out of order negative

# element in remaining array

arr[i], arr[j] =arr[j], arr[i]

break

elif(arr[i] < 0andi %2==0):

# out of order negative element

forj inrange(i +1, n):

if(arr[j] >=0andj %2==1):

# find out of order positive

# element in remaining array

arr[i], arr[j] =arr[j], arr[i]

break

# after modification

printArray(arr, n);

# This code is contributed

# by mohit kumar

chevron_right

filter_none

C#

// C# program to rearrange positive
// and negative numbers
using System;

This article is contributed by Ashish Madaan. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.