Mueva todos los elementos negativos al final en orden con espacio adicional permitido

Dada una array desordenada arr[] de enteros negativos y positivos. La tarea es colocar todos los elementos negativos al final de la array sin cambiar el orden del elemento positivo y el elemento negativo. 

Ejemplos: 

Input : arr[] = {1, -1, 3, 2, -7, -5, 11, 6 }
Output : 1  3  2  11  6  -1  -7  -5 

Input : arr[] = {-5, 7, -3, -4, 9, 10, -1, 11}
Output : 7  9  10  11  -5  -3  -4  -1  

Hemos discutido diferentes enfoques para este problema en la publicación a continuación.
Reorganizar números positivos y negativos con espacio extra constante

El problema se vuelve más fácil si se nos permite usar espacio extra. La idea es crear una array vacía (temp[]). Primero almacenamos todos los elementos positivos de la array dada y luego almacenamos todos los elementos negativos de la array en Temp[]. Finalmente copiamos temp[] a la array original.

Implementación:

// C++ program to Move All -ve Element At End
// Without changing order Of Array Element
#include<bits/stdc++.h>
using namespace std;
 
// Moves all -ve element to end of array in
// same order.
void segregateElements(int arr[], int n)
{
    // Create an empty array to store result
    int temp[n];
 
    // Traversal array and store +ve element in
    // temp array
    int j = 0; // index of temp
    for (int i = 0; i < n ; i++)
        if (arr[i] >= 0 )
            temp[j++] = arr[i];
 
    // If array contains all positive or all negative.
    if (j == n || j == 0)
        return;
 
    // Store -ve element in temp array
    for (int i = 0 ; i < n ; i++)
        if (arr[i] < 0)
            temp[j++] = arr[i];
 
    // Copy contents of temp[] to arr[]
    memcpy(arr, temp, sizeof(temp));
}
 
// Driver program
int main()
{
    int arr[] = {1 ,-1 ,-3 , -2, 7, 5, 11, 6 };
    int n = sizeof(arr)/sizeof(arr[0]);
 
    segregateElements(arr, n);
 
    for (int i = 0; i < n; i++)
    cout << arr[i] << " ";
 
    return 0;
}

// Java program to Move All -ve Element At End
// Without changing order Of Array Element
import java.util.Arrays;
 
class GFG {
     
    // Moves all -ve element to end of array in
    // same order.
    static void segregateElements(int arr[], int n)
    {
         
        // Create an empty array to store result
        int temp[] = new int[n];
 
        // Traversal array and store +ve element in
        // temp array
        int j = 0; // index of temp
         
        for (int i = 0; i < n; i++)
            if (arr[i] >= 0)
                temp[j++] = arr[i];
 
        // If array contains all positive or all
        // negative.
        if (j == n || j == 0)
            return;
 
        // Store -ve element in temp array
        for (int i = 0; i < n; i++)
            if (arr[i] < 0)
                temp[j++] = arr[i];
 
        // Copy contents of temp[] to arr[]
        for (int i = 0; i < n; i++)
            arr[i] = temp[i];
    }
     
    // Driver code
    public static void main(String arg[])
    {
        int arr[] = { 1, -1, -3, -2, 7, 5, 11, 6 };
        int n = arr.length;
 
        segregateElements(arr, n);
 
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }
}
 
// This code is contributed by Anant Agarwal.

# Python program to Move All -ve Element At End
# Without changing order Of Array Element
 
# Moves all -ve element to end of array in
# same order.
def move(arr,n):
    j = 0
    ans=[None]*n
    i=0;j=n-1
    for k in range(n):
        if arr[k]>=0:
          ans[i]=arr[k]
          i+=1
        else:
          ans[j]=arr[k]
          j-=1
    ans[i:]=ans[n-1:i-1:-1]
    return ans
 
# Driver program
arr = [1 ,-1 ,-3 , -2, 7, 5, 11, 6 ]
n = len(arr)
print(move(arr, n))
 
 
# Contributed by Venkatesh hegde

// C# program to Move All -ve Element At End
// Without changing order Of Array Element
using System;
 
class GFG {
 
    // Moves all -ve element to
    // end of array in same order.
    static void segregateElements(int[] arr, int n)
    {
        // Create an empty array to store result
        int[] temp = new int[n];
 
        // Traversal array and store +ve element in
        // temp array
        int j = 0; // index of temp
 
        for (int i = 0; i < n; i++)
            if (arr[i] >= 0)
                temp[j++] = arr[i];
 
        // If array contains all positive or all
        // negative.
        if (j == n || j == 0)
            return;
 
        // Store -ve element in temp array
        for (int i = 0; i < n; i++)
            if (arr[i] < 0)
                temp[j++] = arr[i];
 
        // Copy contents of temp[] to arr[]
        for (int i = 0; i < n; i++)
            arr[i] = temp[i];
    }
 
    // Driver code
    public static void Main()
    {
        int[] arr = { 1, -1, -3, -2, 7, 5, 11, 6 };
        int n = arr.Length;
        segregateElements(arr, n);
 
        for (int i = 0; i < n; i++)
            Console.Write(arr[i] + " ");
    }
}
 
// This Code is contributed by vt_m.

<?php
// PHP program to Move All -ve Element At End
// Without changing order Of Array Element
 
// Moves all -ve element to end of
// array in same order.
function segregateElements(&$arr, $n)
{
    // Create an empty array to store result
    $temp = array(0, $n, NULL);
 
    // Traversal array and store +ve
    // element in temp array
    $j = 0; // index of temp
    for ($i = 0; $i < $n ; $i++)
        if ($arr[$i] >= 0 )
            $temp[$j++] = $arr[$i];
 
    // If array contains all positive
    // or all negative.
    if ($j == $n || $j == 0)
        return;
 
    // Store -ve element in temp array
    for ($i = 0 ; $i < $n ; $i++)
        if ($arr[$i] < 0)
            $temp[$j++] = $arr[$i];
 
    // Copy contents of temp[] to arr[]
    for($i = 0; $i < $n; $i++)
        $arr[$i] = $temp[$i];
}
 
// Driver Code
$arr = array(1 ,-1 ,-3 , -2, 7, 5, 11, 6 );
$n = sizeof($arr);
 
segregateElements($arr, $n);
 
for ($i = 0; $i < $n; $i++)
echo $arr[$i] ." ";
 
// This code is contributed
// by ChitraNayal
?>

<script>
 
// Javascript program to Move All -ve Element At End
// Without changing order Of Array Element
 
// Moves all -ve element to end of array in
// same order.
function segregateElements(arr, n)
{
    // Create an empty array to store result
    let temp= new Array(n);
 
    // Traversal array and store +ve element in
    // temp array
    let j = 0; // index of temp
    for (let i = 0; i < n ; i++)
        if (arr[i] >= 0 )
            temp[j++] = arr[i];
 
    // If array contains all positive or all negative.
    if (j == n || j == 0)
        return;
 
    // Store -ve element in temp array
    for (let i = 0 ; i < n ; i++)
        if (arr[i] < 0)
            temp[j++] = arr[i];
 
   for (let i = 0; i < n ; i++) arr[i] = temp[i];
}
 
// Driver program
 
let arr= [1 ,-1 ,-3 , -2, 7, 5, 11, 6];
let n = arr.length;
 
segregateElements(arr, n);
 
for (let i = 0; i < n; i++)
document.write(arr[i] + " ");
 
</script>

1 7 5 11 6 -1 -3 -2 

Tiempo Complejidad : O(n) 
Espacio auxiliar : O(n) 

Artículos relacionados:  
Reordenar números positivos y negativos con espacio extra constante  
Reordenar números positivos y negativos en tiempo O(n) y espacio extra O(1)

Este artículo es una contribución de Nishant_Singh (Pintu) . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.