Mueva todos los ceros para comenzar y unos para terminar en una array de números enteros aleatorios

Dada una array arr[] de enteros aleatorios, la tarea es empujar todos los ceros de la array al principio y todos los unos al final de la array. Tenga en cuenta que el orden de todos los demás elementos debe ser el mismo.
Ejemplo: 
 

Entrada: arr[] = {1, 2, 0, 4, 3, 0, 5, 0} 
Salida: 0 0 0 2 4 3 5 1 
Entrada: arr[] = {1, 2, 0, 0, 0, 3, 6}; 
Salida: 0 0 0 2 3 6 1 
 

Enfoque: recorra la array de izquierda a derecha y mueva todos los elementos que no son iguales a 1 al principio y luego coloque 1 en el resto de los índices al final de la array. Ahora, encuentre el índice del último elemento que no es igual a 1 , diga lastInd y luego, comenzando desde este índice hasta el comienzo de la array, empuje todos los elementos que no son iguales a 0 al final hasta lastInd y luego coloque 0 en el comienzo.
A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <iostream>
using namespace std;
 
// Utility function to print
// the contents of an array
void printArr(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}
 
// Function that pushes all the zeros
// to the start and ones to the end of an array
void pushBinaryToBorder(int arr[], int n)
{
 
    // To store the count of elements
    // which are not equal to 1
    int count1 = 0;
 
    // Traverse the array and calculate
    // count of elements which are not 1
    for (int i = 0; i < n; i++)
        if (arr[i] != 1)
            arr[count1++] = arr[i];
 
    // Now all non-ones elements have been shifted to
    // front and 'count1' is set as index of first 1.
    // Make all elements 1 from count to end.
    while (count1 < n)
        arr[count1++] = 1;
 
    // Initialize lastNonBinary position to zero
    int lastNonOne = 0;
 
    // Traverse the array and pull non-zero
    // elements to the required indices
    for (int i = n - 1; i >= 0; i--) {
 
        // Ignore the 1's
        if (arr[i] == 1)
            continue;
        if (!lastNonOne) {
 
            // Mark the position Of
            // last NonBinary integer
            lastNonOne = i;
        }
 
        // Place non-zero element to
        // their required indices
        if (arr[i] != 0)
            arr[lastNonOne--] = arr[i];
    }
 
    // Put zeros to start of array
    while (lastNonOne >= 0)
        arr[lastNonOne--] = 0;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 0, 0, 0, 3, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
    pushBinaryToBorder(arr, n);
    printArr(arr, n);
 
    return 0;
}

// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
// Utility function to print
// the contents of an array
static void printArr(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        System.out.print(arr[i]+" ");
}
 
// Function that pushes all the zeros
// to the start and ones to the end of an array
static void pushBinaryToBorder(int arr[], int n)
{
 
    // To store the count of elements
    // which are not equal to 1
    int count1 = 0;
 
    // Traverse the array and calculate
    // count of elements which are not 1
    for (int i = 0; i < n; i++)
        if (arr[i] != 1)
            arr[count1++] = arr[i];
 
    // Now all non-ones elements have been shifted to
    // front and 'count1' is set as index of first 1.
    // Make all elements 1 from count to end.
    while (count1 < n)
        arr[count1++] = 1;
 
    // Initialize lastNonBinary position to zero
    int lastNonOne = 0;
 
    // Traverse the array and pull non-zero
    // elements to the required indices
    for (int i = n - 1; i >= 0; i--)
    {
 
        // Ignore the 1's
        if (arr[i] == 1)
            continue;
        if (lastNonOne == 0)
        {
 
            // Mark the position Of
            // last NonBinary integer
            lastNonOne = i;
        }
 
        // Place non-zero element to
        // their required indices
        if (arr[i] != 0)
            arr[lastNonOne--] = arr[i];
    }
 
    // Put zeros to start of array
    while (lastNonOne >= 0)
        arr[lastNonOne--] = 0;
}
 
// Driver code
public static void main(String args[])
{
    int arr[] = { 1, 2, 0, 0, 0, 3, 6 };
    int n = arr.length;
    pushBinaryToBorder(arr, n);
    printArr(arr, n);
 
}
}
 
// This code is contributed by SURENDRA_GANGWAR.

# Python3 implementation of the approach
 
# Utility function to print
# the contents of an array
def printArr(arr, n) :
 
    for i in range(n) :
        print(arr[i],end=" ")
 
 
# Function that pushes all the zeros
# to the start and ones to the end of an array
def pushBinaryToBorder(arr, n) :
 
    # To store the count of elements
    # which are not equal to 1
    count1 = 0
     
    # Traverse the array and calculate
    # count of elements which are not 1
    for i in range(n) :
        if (arr[i] != 1) :
            arr[count1] = arr[i]
            count1 += 1
 
    # Now all non-ones elements have been shifted to
    # front and 'count1' is set as index of first 1.
    # Make all elements 1 from count to end.
    while (count1 < n) :
        arr[count1] = 1
        count1 += 1
 
    # Initialize lastNonBinary position to zero
    lastNonOne = 0
 
    # Traverse the array and pull non-zero
    # elements to the required indices
    for i in range(n - 1, -1, -1) :
 
        # Ignore the 1's
        if (arr[i] == 1) :
            continue
             
        if (not lastNonOne) :
 
            # Mark the position Of
            # last NonBinary integer
            lastNonOne = i
 
        # Place non-zero element to
        # their required indices
        if (arr[i] != 0) :
            arr[lastNonOne] = arr[i]
            lastNonOne -= 1
 
    # Put zeros to start of array
    while (lastNonOne >= 0) :
        arr[lastNonOne] = 0
        lastNonOne -= 1
 
# Driver code
if __name__ == "__main__" :
     
    arr = [ 1, 2, 0, 0, 0, 3, 6 ];
    n = len(arr);
    pushBinaryToBorder(arr, n)
    printArr(arr, n)
 
# This code is contributed by Ryuga

// C# implementation of the approach
using System;
 
class GFG
{
 
// Utility function to print
// the contents of an array
static void printArr(int []arr, int n)
{
    for (int i = 0; i < n; i++)
        Console.Write(arr[i] + " ");
}
 
// Function that pushes all the zeros
// to the start and ones to the end of an array
static void pushBinaryToBorder(int [] arr, int n)
{
 
    // To store the count of elements
    // which are not equal to 1
    int count1 = 0;
 
    // Traverse the array and calculate
    // count of elements which are not 1
    for (int i = 0; i < n; i++)
        if (arr[i] != 1)
            arr[count1++] = arr[i];
 
    // Now all non-ones elements have been shifted to
    // front and 'count1' is set as index of first 1.
    // Make all elements 1 from count to end.
    while (count1 < n)
        arr[count1++] = 1;
 
    // Initialize lastNonBinary position to zero
    int lastNonOne = 0;
 
    // Traverse the array and pull non-zero
    // elements to the required indices
    for (int i = n - 1; i >= 0; i--)
    {
 
        // Ignore the 1's
        if (arr[i] == 1)
            continue;
        if (lastNonOne == 0)
        {
 
            // Mark the position Of
            // last NonBinary integer
            lastNonOne = i;
        }
 
        // Place non-zero element to
        // their required indices
        if (arr[i] != 0)
            arr[lastNonOne--] = arr[i];
    }
 
    // Put zeros to start of array
    while (lastNonOne >= 0)
        arr[lastNonOne--] = 0;
}
 
// Driver code
public static void Main()
{
    int []arr = { 1, 2, 0, 0, 0, 3, 6 };
    int n = arr.Length;
    pushBinaryToBorder(arr, n);
    printArr(arr, n);
}
}
 
// This code is contributed by Mohit kumar 29.

<script>
 
// Javascript implementation of the approach
 
// Utility function to print
// the contents of an array
function printArr(arr, n)
{
    for (var i = 0; i < n; i++)
        document.write( arr[i] + " ");
}
 
// Function that pushes all the zeros
// to the start and ones to the end of an array
function pushBinaryToBorder(arr, n)
{
 
    // To store the count of elements
    // which are not equal to 1
    var count1 = 0;
 
    // Traverse the array and calculate
    // count of elements which are not 1
    for (var i = 0; i < n; i++)
        if (arr[i] != 1)
            arr[count1++] = arr[i];
 
    // Now all non-ones elements have been shifted to
    // front and 'count1' is set as index of first 1.
    // Make all elements 1 from count to end.
    while (count1 < n)
        arr[count1++] = 1;
 
    // Initialize lastNonBinary position to zero
    var lastNonOne = 0;
 
    // Traverse the array and pull non-zero
    // elements to the required indices
    for (var i = n - 1; i >= 0; i--) {
 
        // Ignore the 1's
        if (arr[i] == 1)
            continue;
        if (!lastNonOne) {
 
            // Mark the position Of
            // last NonBinary integer
            lastNonOne = i;
        }
 
        // Place non-zero element to
        // their required indices
        if (arr[i] != 0)
            arr[lastNonOne--] = arr[i];
    }
 
    // Put zeros to start of array
    while (lastNonOne >= 0)
        arr[lastNonOne--] = 0;
}
 
// Driver code
var arr = [ 1, 2, 0, 0, 0, 3, 6 ];
var n = arr.length;
pushBinaryToBorder(arr, n);
printArr(arr, n);
 
 
</script>

0 0 0 2 3 6 1

Complejidad de tiempo: O(N), donde N representa el tamaño de la array dada.

Espacio auxiliar: O(1), no se requiere espacio adicional, por lo que es una constante.