Rearrange array in alternating positive & negative items with O(1) extra space | Set 1

23 Jun, 2022
Given an array of positive and negative numbers, arrange them in an alternate fashion such that every positive number is followed by negative and vice-versa maintaining the order of appearance. Number of positive and negative numbers need not be equal. If there are more positive numbers they appear at the end of the array. If there are more negative numbers, they too appear in the end of the array.
Examples : 
Input:  arr[] = {1, 2, 3, -4, -1, 4}
Output: arr[] = {-4, 1, -1, 2, 3, 4}

Input:  arr[] = {-5, -2, 5, 2, 4, 7, 1, 8, 0, -8}
output: arr[] = {-5, 5, -2, 2, -8, 4, 7, 1, 8, 0}
This question has been asked at many places (See this and this)
Naive Approach : 
The above problem can be easily solved if O(n) extra space is allowed. It becomes interesting due to the limitations that O(1) extra space and order of appearances. The idea is to process array from left to right. While processing, find the first out of place element in the remaining unprocessed array. An element is out of place if it is negative and at odd index (0 based index), or it is positive and at even index (0 based index) . Once we find an out of place element, we find the first element after it with opposite sign. We right rotate the subarray between these two elements (including these two).
Following is the implementation of above idea.  
C++
Java
Python
C#
PHP
Javascript
/*  C++ program to rearrange   positive and negative integers   in alternate fashion while keeping   the order of positive and negative numbers. */#include <assert.h>#include <iostream>using namespace std; // Utility function to right rotate all elements between// [outofplace, cur]void rightrotate(int arr[], int n, int outofplace, int cur){    char tmp = arr[cur];    for (int i = cur; i > outofplace; i--)        arr[i] = arr[i - 1];    arr[outofplace] = tmp;} void rearrange(int arr[], int n){    int outofplace = -1;     for (int index = 0; index < n; index++)    {        if (outofplace >= 0)        {            // find the item which must be moved into the            // out-of-place entry if out-of-place entry is            // positive and current entry is negative OR if            // out-of-place entry is negative and current            // entry is negative then right rotate            //            // [...-3, -4, -5, 6...] -->   [...6, -3, -4,            // -5...]            //      ^                          ^            //      |                          |            //     outofplace      -->      outofplace            //            if (((arr[index] >= 0) && (arr[outofplace] < 0))                || ((arr[index] < 0)                    && (arr[outofplace] >= 0)))            {                rightrotate(arr, n, outofplace, index);                 // the new out-of-place entry is now 2 steps                // ahead                if (index - outofplace >= 2)                    outofplace = outofplace + 2;                else                    outofplace = -1;            }        }         // if no entry has been flagged out-of-place        if (outofplace == -1) {            // check if current entry is out-of-place            if (((arr[index] >= 0) && (!(index & 0x01)))                || ((arr[index] < 0) && (index & 0x01))) {                outofplace = index;            }        }    }} // A utility function to print an array 'arr[]' of size 'n'void printArray(int arr[], int n){    for (int i = 0; i < n; i++)        cout << arr[i] << " ";    cout << endl;} // Driver codeint main(){         int arr[] = { -5, -2, 5, 2,                 4, 7, 1, 8, 0, -8 };    int n = sizeof(arr) / sizeof(arr[0]);     cout << "Given array is \n";    printArray(arr, n);     rearrange(arr, n);     cout << "Rearranged array is \n";    printArray(arr, n);     return 0;}
class RearrangeArray{    // Utility function to right rotate all elements    // between [outofplace, cur]    void rightrotate(int arr[], int n, int outofplace,                     int cur)    {        int tmp = arr[cur];        for (int i = cur; i > outofplace; i--)            arr[i] = arr[i - 1];        arr[outofplace] = tmp;    }     void rearrange(int arr[], int n)    {        int outofplace = -1;         for (int index = 0; index < n; index++)        {            if (outofplace >= 0)            {                // find the item which must be moved into                // the out-of-place entry if out-of-place                // entry is positive and current entry is                // negative OR if out-of-place entry is                // negative and current entry is negative                // then right rotate                //                // [...-3, -4, -5, 6...] -->   [...6, -3,                // -4, -5...]                //      ^                          ^                //      |                          |                //     outofplace      -->      outofplace                //                if (((arr[index] >= 0)                     && (arr[outofplace] < 0))                    || ((arr[index] < 0)                        && (arr[outofplace] >= 0))) {                    rightrotate(arr, n, outofplace, index);                     // the new out-of-place entry is now 2                    // steps ahead                    if (index - outofplace >= 2)                        outofplace = outofplace + 2;                    else                        outofplace = -1;                }            }             // if no entry has been flagged out-of-place            if (outofplace == -1)            {                // check if current entry is out-of-place                if (((arr[index] >= 0)                     && ((index & 0x01) == 0))                    || ((arr[index] < 0)                        && (index & 0x01) == 1))                    outofplace = index;            }        }    }     // A utility function to print    // an array 'arr[]' of size 'n'    void printArray(int arr[], int n)    {        for (int i = 0; i < n; i++)            System.out.print(arr[i] + " ");        System.out.println("");    }     // Driver Code    public static void main(String[] args)    {        RearrangeArray rearrange = new RearrangeArray();        /* int arr[n] = {-5, 3, 4, 5, -6,                         -2, 8, 9, -1, -4};        int arr[] = {-5, -3, -4, -5, -6,                     2 , 8, 9, 1 , 4};        int arr[] = {5, 3, 4, 2, 1,                     -2 , -8, -9, -1 , -4};        int arr[] = {-5, 3, -4, -7,                     -1, -2 , -8, -9, 1 , -4};*/        int arr[] = { -5, -2, 5, 2, 4,                     7, 1, 8, 0, -8 };        int n = arr.length;         System.out.println("Given array is ");        rearrange.printArray(arr, n);         rearrange.rearrange(arr, n);         System.out.println("RearrangeD array is ");        rearrange.printArray(arr, n);    }} // This code has been contributed by Mayank Jaiswal
# Python3 program to rearrange# positive and negative integers# in alternate fashion and# maintaining the order of positive# and negative numbers # rotates the array to right by once# from index 'outOfPlace to cur'  def rightRotate(arr, n, outOfPlace, cur):    temp = arr[cur]    for i in range(cur, outOfPlace, -1):        arr[i] = arr[i - 1]    arr[outOfPlace] = temp    return arr  def rearrange(arr, n):    outOfPlace = -1    for index in range(n):        if(outOfPlace >= 0):             # if element at outOfPlace place in            # negative and if element at index            # is positive we can rotate the            # array to right or if element            # at outOfPlace place in positive and            # if element at index is negative we            # can rotate the array to right            if((arr[index] >= 0 and arr[outOfPlace] < 0) or               (arr[index] < 0 and arr[outOfPlace] >= 0)):                arr = rightRotate(arr, n, outOfPlace, index)                if(index-outOfPlace > 2):                    outOfPlace += 2                else:                    outOfPlace = - 1         if(outOfPlace == -1):             # conditions for A[index] to            # be in out of place            if((arr[index] >= 0 and index % 2 == 0) or               (arr[index] < 0 and index % 2 == 1)):                outOfPlace = index    return arr  # Driver Codearr = [-5, -2, 5, 2, 4,       7, 1, 8, 0, -8] print("Given Array is:")print(arr) print("\nRearranged array is:")print(rearrange(arr, len(arr))) # This code is contributed# by Charan Sai
// Rearrange array in alternating positive// & negative items with O(1) extra spaceusing System; class GFG {    // Utility function to right rotate    // all elements between [outofplace, cur]    static void rightrotate(int[] arr, int n,                            int outofplace, int cur)    {        int tmp = arr[cur];        for (int i = cur; i > outofplace; i--)            arr[i] = arr[i - 1];        arr[outofplace] = tmp;    }     static void rearrange(int[] arr, int n)    {        int outofplace = -1;         for (int index = 0; index < n; index++) {            if (outofplace >= 0) {                // find the item which must be moved                // into the out-of-place entry if out-of-                // place entry is positive and current                // entry is negative OR if out-of-place                // entry is negative and current entry                // is negative then right rotate                // [...-3, -4, -5, 6...] --> [...6, -3, -4,                // -5...]                //     ^                         ^                //     |                         |                //     outofplace     -->     outofplace                //                if (((arr[index] >= 0)                     && (arr[outofplace] < 0))                    || ((arr[index] < 0)                        && (arr[outofplace] >= 0))) {                    rightrotate(arr, n, outofplace, index);                     // the new out-of-place entry                    // is now 2 steps ahead                    if (index - outofplace > 2)                        outofplace = outofplace + 2;                    else                        outofplace = -1;                }            }             // if no entry has been flagged out-of-place            if (outofplace == -1) {                // check if current entry is out-of-place                if (((arr[index] >= 0)                     && ((index & 0x01) == 0))                    || ((arr[index] < 0)                        && (index & 0x01) == 1))                    outofplace = index;            }        }    }     // A utility function to print an    // array 'arr[]' of size 'n'    static void printArray(int[] arr, int n)    {        for (int i = 0; i < n; i++)            Console.Write(arr[i] + " ");        Console.WriteLine("");    }     // Driver code    public static void Main()    {        int[] arr = { -5, -2, 5, 2, 4, 7, 1, 8, 0, -8 };        int n = arr.Length;         Console.WriteLine("Given array is ");        printArray(arr, n);         rearrange(arr, n);         Console.WriteLine("RearrangeD array is ");        printArray(arr, n);    }} // This code is contributed by Sam007
<?php// PHP program to rearrange positive and// negative integers in alternate fashion// while keeping the order of positive// and negative numbers. // Utility function to right rotate all// elements between [outofplace, cur]function rightrotate(&$arr, $n,                      $outofplace, $cur){    $tmp = $arr[$cur];    for ($i = $cur; $i > $outofplace; $i--)        $arr[$i] = $arr[$i - 1];    $arr[$outofplace] = $tmp;} function rearrange(&$arr, $n){    $outofplace = -1;     for ($index = 0; $index < $n; $index ++)    {        if ($outofplace >= 0)        {            // find the item which must be moved            // into the out-of-place entry if            // out-of-place entry is positive and            // current entry is negative OR if            // out-of-place entry is negative            // and current entry is negative then            // right rotate            // [...-3, -4, -5, 6...] --> [...6, -3, -4, -5...]            //     ^                         ^            //     |                         |            //     outofplace     -->     outofplace            //            if ((($arr[$index] >= 0) && ($arr[$outofplace] < 0)) ||                (($arr[$index] < 0) && ($arr[$outofplace] >= 0)))            {                rightrotate($arr, $n, $outofplace, $index);                 // the new out-of-place entry is                // now 2 steps ahead                if ($index - $outofplace > 2)                    $outofplace = $outofplace + 2;                else                    $outofplace = -1;            }        }         // if no entry has been flagged out-of-place        if ($outofplace == -1)        {            // check if current entry is out-of-place            if ((($arr[$index] >= 0) && (!($index & 0x01)))                || (($arr[$index] < 0) && ($index & 0x01)))            {                $outofplace = $index;            }        }    }} // A utility function to print an// array 'arr[]' of size 'n'function printArray(&$arr, $n){    for ($i = 0; $i < $n; $i++)    echo $arr[$i]." ";    echo "\n";} // Driver Code // arr = array(-5, 3, 4, 5, -6, -2, 8, 9, -1, -4);// arr = array(-5, -3, -4, -5, -6, 2 , 8, 9, 1 , 4);// arr = array(5, 3, 4, 2, 1, -2 , -8, -9, -1 , -4);// arr = array(-5, 3, -4, -7, -1, -2 , -8, -9, 1 , -4);$arr = array(-5, -2, 5, 2, 4, 7, 1, 8, 0, -8);$n = sizeof($arr); echo "Given array is \n";printArray($arr, $n); rearrange($arr, $n); echo "Rearranged array is \n";printArray($arr, $n); // This code is contributed by ChitraNayal?>
<script>    // Utility function to right rotate all elements    // between [outofplace, cur]    function rightrotate(arr , n , outofplace , cur) {        var tmp = arr[cur];        for (i = cur; i > outofplace; i--)            arr[i] = arr[i - 1];        arr[outofplace] = tmp;    }     function rearrange(arr , n) {        var outofplace = -1;         for (var index = 0; index < n; index++)        {            if (outofplace >= 0)            {                             // find the item which must be moved into                // the out-of-place entry if out-of-place                // entry is positive and current entry is                // negative OR if out-of-place entry is                // negative and current entry is negative                // then right rotate                //                // [...-3, -4, -5, 6...] --> [...6, -3,                // -4, -5...]                // ^ ^                // | |                // outofplace --> outofplace                //                if (((arr[index] >= 0) && (arr[outofplace] < 0)) || ((arr[index] < 0) && (arr[outofplace] >= 0))) {                    rightrotate(arr, n, outofplace, index);                     // the new out-of-place entry is now 2                    // steps ahead                    if (index - outofplace >= 2)                        outofplace = outofplace + 2;                    else                        outofplace = -1;                }            }             // if no entry has been flagged out-of-place            if (outofplace == -1) {                // check if current entry is out-of-place                if (((arr[index] >= 0) && ((index & 0x01) == 0)) || ((arr[index] < 0) && (index & 0x01) == 1))                    outofplace = index;            }        }    }     // A utility function to print    // an array 'arr' of size 'n'    function printArray(arr , n) {        for (i = 0; i < n; i++)            document.write(arr[i] + " ");        document.write("");    }     // Driver Code         /*         * var arr[n] = [-5, 3, 4, 5, -6, -2, 8, 9, -1, -4]; var arr = [-5, -3, -4,         * -5, -6, 2 , 8, 9, 1 , 4]; var arr = [5, 3, 4, 2, 1, -2 , -8, -9, -1 , -4];         * var arr = [-5, 3, -4, -7, -1, -2 , -8, -9, 1 , -4];         */        var arr = [ -5, -2, 5, 2, 4, 7, 1, 8, 0, -8 ];        var n = arr.length;         document.write("Given array is ");        printArray(arr, n);         rearrange(arr, n);         document.write("<br/>RearrangeD array is ");        printArray(arr, n);         // This code is contributed by gauravrajput1</script>
Given array is 
-5 -2 5 2 4 7 1 8 0 -8 
Rearranged array is 
-5 5 -2 2 -8 4 7 1 8 0 
Time Complexity: O(N^2), as we are using a loop to traverse N times and calling function rightrotate each time which will cost O (N).Space Complexity: O(1), as we are not using any extra space.
Rearrange array in alternating positive & negative items with O(1) extra space | Set 2
Sam007
Charan Sai Gummadava
ukasp
AmanGautam1
vvkbisht
jyoti369
sweetyty
tharun07
sagartomar9927
GauravRajput1
splevel62
dark_hunter
rohitkumarsinghcna
hardikkoriintern
array-rearrange
Arrays
Arrays
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Arrays in Java
Write a program to reverse an array or string
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Largest Sum Contiguous Subarray
Arrays in C/C++
Multidimensional Arrays in Java
Stack Data Structure (Introduction and Program)
Linear Search
Subset Sum Problem | DP-25