Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Segregate 0s and 1s in an array

  • Difficulty Level : Easy
  • Last Updated : 14 Apr, 2022

You are given an array of 0s and 1s in random order. Segregate 0s on left side and 1s on right side of the array [Basically you have to sort the array]. Traverse array only once. 

Input array   =  [0, 1, 0, 1, 0, 0, 1, 1, 1, 0] 
Output array =  [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

Method 1 (Count 0s or 1s) 
Thanks to Naveen for suggesting this method. 
1) Count the number of 0s. So let’s understand with an example we have an array arr = [0, 1, 0, 1, 0, 0, 1] the size of the array is 7 now we will traverse the entire array and find out the number of zeros in the array, In this case the number of zeros is 4 so now we can easily get the number of Ones in the array by Array Length – Number Of Zeros.

2) Once we have counted, we can fill the array first we will put the zeros and then ones (we can get number of ones by using above formula).
Time Complexity : O(n) 

C++




// C++ code to Segregate 0s and 1s in an array
#include <bits/stdc++.h>
using namespace std;
 
// Function to segregate 0s and 1s
void segregate0and1(int arr[], int n)
{
    int count = 0; // Counts the no of zeros in arr
 
    for (int i = 0; i < n; i++) {
        if (arr[i] == 0)
            count++;
    }
 
    // Loop fills the arr with 0 until count
    for (int i = 0; i < count; i++)
        arr[i] = 0;
 
    // Loop fills remaining arr space with 1
    for (int i = count; i < n; i++)
        arr[i] = 1;
}
 
// Function to print segregated array
void print(int arr[], int n)
{
    cout << "Array after segregation is ";
 
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}
 
// Driver function
int main()
{
    int arr[] = { 0, 1, 0, 1, 1, 1 };
    int n = sizeof(arr) / sizeof(arr[0]);
     
    segregate0and1(arr, n);
    print(arr, n);
     
    return 0;
}
 
// This code is contributed by Sahil_Bansall
Java



// Java code to Segregate 0s and 1s in an array
class GFG {
     
    // function to segregate 0s and 1s
    static void segregate0and1(int arr[], int n)
    {
        int count = 0; // counts the no of zeros in arr
     
        for (int i = 0; i < n; i++) {
            if (arr[i] == 0)
                count++;
        }
 
        // loop fills the arr with 0 until count
        for (int i = 0; i < count; i++)
            arr[i] = 0;
 
        // loop fills remaining arr space with 1
        for (int i = count; i < n; i++)
            arr[i] = 1;
    }
     
    // function to print segregated array
    static void print(int arr[], int n)
    {
        System.out.print("Array after segregation is ");
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");   
    }
     
    // driver function
    public static void main(String[] args)
    {
        int arr[] = new int[]{ 0, 1, 0, 1, 1, 1 };
        int n = arr.length;
 
        segregate0and1(arr, n);
        print(arr, n);
         
    }
}
 
// This code is contributed by Kamal Rawal
Python3



# Python 3 code to Segregate
# 0s and 1s in an array
 
# Function to segregate 0s and 1s
def segregate0and1(arr, n) :
     
    # Counts the no of zeros in arr
    count = 0
 
    for i in range(0, n) :
        if (arr[i] == 0) :
            count = count + 1
 
    # Loop fills the arr with 0 until count
    for i in range(0, count) :
        arr[i] = 0
 
    # Loop fills remaining arr space with 1
    for i in range(count, n) :
        arr[i] = 1
         
 
# Function to print segregated array
def print_arr(arr , n) :
    print( "Array after segregation is ",end = "")
 
    for i in range(0, n) :
        print(arr[i] , end = " ")
         
 
# Driver function
arr = [ 0, 1, 0, 1, 1, 1 ]
n = len(arr)
     
segregate0and1(arr, n)
print_arr(arr, n)
 
 
         
# This code is contributed by Nikita Tiwari.
C#



// C# code to Segregate 0s and 1s in an array
using System;
 
class GFG {
     
    // function to segregate 0s and 1s
    static void segregate0and1(int []arr, int n)
    {  
        // counts the no of zeros in arr
        int count = 0;
     
        for (int i = 0; i < n; i++) {
            if (arr[i] == 0)
                count++;
        }
 
        // loop fills the arr with 0 until count
        for (int i = 0; i < count; i++)
            arr[i] = 0;
 
        // loop fills remaining arr space with 1
        for (int i = count; i < n; i++)
            arr[i] = 1;
    }
     
    // function to print segregated array
    static void print(int []arr, int n)
    {
        Console.WriteLine("Array after segregation is ");
        for (int i = 0; i < n; i++)
            Console.Write(arr[i] + " ");
    }
     
    // driver function
    public static void Main()
    {
        int []arr = new int[]{ 0, 1, 0, 1, 1, 1 };
        int n = arr.Length;
 
        segregate0and1(arr, n);
        print(arr, n);
         
    }
}
 
//This code is contributed by vt_m.
PHP



<?php
// PHP code to Segregate 
// 0s and 1s in an array
 
// Function to segregate
// 0s and 1s
function segregate0and1(&$arr, $n)
{
    $count = 0; // Counts the no
                // of zeros in arr
 
    for ($i = 0; $i < $n; $i++)
    {
        if ($arr[$i] == 0)
            $count++;
    }
 
    // Loop fills the arr
    // with 0 until count
    for ($i = 0; $i < $count; $i++)
        $arr[$i] = 0;
 
    // Loop fills remaining
    // arr space with 1
    for ($i = $count; $i < $n; $i++)
        $arr[$i] = 1;
}
 
// Function to print
// segregated array
function toprint(&$arr , $n)
{
    echo ("Array after segregation is ");
 
    for ($i = 0; $i < $n; $i++)
        echo ( $arr[$i] . " ");
}
 
// Driver Code
$arr = array(0, 1, 0, 1, 1, 1 );
$n = sizeof($arr);
 
segregate0and1($arr, $n);
toprint($arr, $n);
     
// This code is contributed
// by Shivi_Aggarwal
?>
Javascript



<script>
// JavaScript code to Segregate 0s and 1s in an array
 
// Function to segregate 0s and 1s
function segregate0and1(arr, n)
{
    let count = 0; // Counts the no of zeros in arr
 
    for (let i = 0; i < n; i++) {
        if (arr[i] == 0)
            count++;
    }
 
    // Loop fills the arr with 0 until count
    for (let i = 0; i < count; i++)
        arr[i] = 0;
 
    // Loop fills remaining arr space with 1
    for (let i = count; i < n; i++)
        arr[i] = 1;
}
 
// Function to print segregated array
function print(arr, n)
{
    document.write("Array after segregation is ");
 
    for (let i = 0; i < n; i++)
        document.write(arr[i] + " ");
}
 
// Driver function
 
    let arr = [ 0, 1, 0, 1, 1, 1 ];
    let n = arr.length;
     
    segregate0and1(arr, n);
    print(arr, n);
     
 
// This code is contributed by Surbhi Tyagi
 
</script>
Output
Array after segregation is 0 0 1 1 1 1 
Method 1 traverses the array two times. Method 2 does the same in a single pass.
Method 2 (Use two indexes to traverse) 
Maintain two indexes. Initialize the first index left as 0 and second index right as n-1.
Do following while left < right 
a) Keep incrementing index left while there are 0s at it 
b) Keep decrementing index right while there are 1s at it 
c) If left < right then exchange arr[left] and arr[right]
Implementation: 
C++



// C++ program to sort a binary array in one pass
#include <bits/stdc++.h>
using namespace std;
 
/*Function to put all 0s on left and all 1s on right*/
void segregate0and1(int arr[], int size)
{
    /* Initialize left and right indexes */
    int left = 0, right = size-1;
 
    while (left < right)
    {
        /* Increment left index while we see 0 at left */
        while (arr[left] == 0 && left < right)
            left++;
 
        /* Decrement right index while we see 1 at right */
        while (arr[right] == 1 && left < right)
            right--;
 
        /* If left is smaller than right then there is a 1 at left
        and a 0 at right. Exchange arr[left] and arr[right]*/
        if (left < right)
        {
            arr[left] = 0;
            arr[right] = 1;
            left++;
            right--;
        }
    }
}
 
/* Driver code */
int main()
{
    int arr[] = {0, 1, 0, 1, 1, 1};
    int i, arr_size = sizeof(arr)/sizeof(arr[0]);
 
    segregate0and1(arr, arr_size);
 
    cout << "Array after segregation ";
    for (i = 0; i < 6; i++)
        cout << arr[i] << " ";
    return 0;
}
 
// This is code is contributed by rathbhupendra
C



// C program to sort a binary array in one pass
#include<stdio.h>
 
/*Function to put all 0s on left and all 1s on right*/
void segregate0and1(int arr[], int size)
{
    /* Initialize left and right indexes */
    int left = 0, right = size-1;
 
    while (left < right)
    {
        /* Increment left index while we see 0 at left */
        while (arr[left] == 0 && left < right)
            left++;
 
        /* Decrement right index while we see 1 at right */
        while (arr[right] == 1 && left < right)
            right--;
 
        /* If left is smaller than right then there is a 1 at left
          and a 0 at right.  Exchange arr[left] and arr[right]*/
        if (left < right)
        {
            arr[left] = 0;
            arr[right] = 1;
            left++;
            right--;
        }
    }
}
 
/* driver program to test */
int main()
{
    int arr[] = {0, 1, 0, 1, 1, 1};
    int i, arr_size = sizeof(arr)/sizeof(arr[0]);
 
    segregate0and1(arr, arr_size);
 
    printf("Array after segregation ");
    for (i = 0; i < 6; i++)
        printf("%d ", arr[i]);
 
    getchar();
    return 0;
}
Java



class Segregate
{
    /*Function to put all 0s on left and all 1s on right*/
    void segregate0and1(int arr[], int size)
    {
        /* Initialize left and right indexes */
        int left = 0, right = size - 1;
 
        while (left < right)
        {
            /* Increment left index while we see 0 at left */
            while (arr[left] == 0 && left < right)
               left++;
 
            /* Decrement right index while we see 1 at right */
            while (arr[right] == 1 && left < right)
                right--;
 
            /* If left is smaller than right then there is a 1 at left
               and a 0 at right.  Exchange arr[left] and arr[right]*/
            if (left < right)
            {
                arr[left] = 0;
                arr[right] = 1;
                left++;
                right--;
            }
        }
    }
     
    /* Driver Program to test above functions */
    public static void main(String[] args)
    {
        Segregate seg = new Segregate();
        int arr[] = new int[]{0, 1, 0, 1, 1, 1};
        int i, arr_size = arr.length;
 
        seg.segregate0and1(arr, arr_size);
 
        System.out.print("Array after segregation is ");
        for (i = 0; i < 6; i++)
            System.out.print(arr[i] + " ");
    }
}
Python



# Python program to sort a binary array in one pass
 
# Function to put all 0s on left and all 1s on right
def segregate0and1(arr, size):
    # Initialize left and right indexes
    left, right = 0, size-1
     
    while left < right:
        # Increment left index while we see 0 at left
        while arr[left] == 0 and left < right:
            left += 1
 
        # Decrement right index while we see 1 at right
        while arr[right] == 1 and left < right:
            right -= 1
 
        # If left is smaller than right then there is a 1 at left
        # and a 0 at right. Exchange arr[left] and arr[right]
        if left < right:
            arr[left] = 0
            arr[right] = 1
            left += 1
            right -= 1
 
    return arr
 
# driver program to test
arr = [0, 1, 0, 1, 1, 1]
arr_size = len(arr)
print("Array after segregation")
print(segregate0and1(arr, arr_size))
 
# This code is contributed by Pratik Chhajer
C#



// C# program to sort a binary array in one pass
using System;
 
class Segregate
{
    /*Function to put all 0s on
      left and all 1s on right*/
    void segregate0and1(int []arr, int size)
    {
        /* Initialize left and right indexes */
        int left = 0, right = size - 1;
 
        while (left < right)
        {
            /* Increment left index while
               we see 0 at left */
            while (arr[left] == 0 && left < right)
            left++;
 
            /* Decrement right index while
               we see 1 at right */
            while (arr[right] == 1 && left < right)
                right--;
 
            /* If left is smaller than right then
               there is a 1 at left and a 0 at right.
               Exchange arr[left] and arr[right]*/
            if (left < right)
            {
                arr[left] = 0;
                arr[right] = 1;
                left++;
                right--;
            }
        }
    }
     
    /* Driver Program to test above functions */
    public static void Main()
    {
        Segregate seg = new Segregate();
        int []arr = new int[]{0, 1, 0, 1, 1, 1};
        int i, arr_size = arr.Length;
 
        seg.segregate0and1(arr, arr_size);
 
        Console.WriteLine("Array after segregation is ");
        for (i = 0; i < 6; i++)
            Console.Write(arr[i] + " ");
    }
}
 
//This code is contributed by vt_m.
PHP



<?php
// PHP program to sort a
// binary array in one pass
 
// Function to put all 0s on
// left and all 1s on right
function segregate0and1(&$arr, $size)
{
    // Initialize left and
    // right indexes
    $left = 0;
    $right = $size - 1;
 
    while ($left < $right)
    {
        // Increment left index
        // while we see 0 at left
        while ($arr[$left] == 0 &&
               $left < $right)
            $left++;
 
        // Decrement right index
        // while we see 1 at right
        while ($arr[$right] == 1 &&
               $left < $right)
            $right--;
 
        // If left is smaller than right
        // then there is a 1 at left
        // and a 0 at right. Exchange
        // arr[left] and arr[right]
        if ($left < $right)
        {
            $arr[$left] = 0;
            $arr[$right] = 1;
            $left++;
            $right--;
        }
    }
}
 
// Driver code
$arr = array(0, 1, 0, 1, 1, 1);
$arr_size = sizeof($arr);
 
segregate0and1($arr, $arr_size);
 
printf("Array after segregation is ");
for ($i = 0; $i < 6; $i++)
    echo ($arr[$i]. " ");
 
// This code is contributed
// by Shivi_Aggarwal
?>
Javascript



<script>
 
// Javascript program to sort a binary array in one pass
 
/*Function to put all 0s on left and all 1s on right*/
function segregate0and1(arr, size)
{
    /* Initialize left and right indexes */
    let left = 0, right = size-1;
 
    while (left < right)
    {
        /* Increment left index while we see 0 at left */
        while (arr[left] == 0 && left < right)
            left++;
 
        /* Decrement right index while we see 1 at right */
        while (arr[right] == 1 && left < right)
            right--;
 
        /* If left is smaller than right then there is a 1 at left
        and a 0 at right. Exchange arr[left] and arr[right]*/
        if (left < right)
        {
            arr[left] = 0;
            arr[right] = 1;
            left++;
            right--;
        }
    }
}
 
/* Driver code */
let arr = [0, 1, 0, 1, 1, 1];
let i, arr_size = arr.length;
 
segregate0and1(arr, arr_size);
 
document.write("Array after segregation ");
for (i = 0; i < 6; i++)
    document.write(arr[i] + " ");
 
</script>
Output
Array after segregation 0 0 1 1 1 1 
Time Complexity: O(n)
Another approach : 
1. Take two pointer type0(for element 0) starting from beginning (index = 0) and type1(for element 1) starting from end (index = array.length-1). 
Initialize type0 = 0 and type1 = array.length-1 
2. It is intended to Put 1 to the right side of the array. Once it is done, then 0 will definitely towards the left side of the array.
C++



// C++ program to sort a
// binary array in one pass
#include <bits/stdc++.h>
using namespace std;
 
/*Function to put all 0s on
left and all 1s on right*/
void segregate0and1(int arr[], int size)
{
    int type0 = 0;
    int type1 = size - 1;
 
    while (type0 < type1) {
        if (arr[type0] == 1) {
            if (arr[type1] != 1) {
                swap(arr[type0], arr[type1]);
            }
            type1--;
        }
        else
            type0++;
    }
}
 
// Driver Code
int main()
{
    int arr[] = { 0, 1, 0, 1, 1, 1 };
    int i, arr_size = sizeof(arr) / sizeof(arr[0]);
 
    segregate0and1(arr, arr_size);
 
    cout << "Array after segregation is ";
    for (i = 0; i < arr_size; i++)
        cout << arr[i] << " ";
 
    return 0;
}
Java



// Java code to segregate 0 and 1
import java.util.*;
 
class GFG {
    /**
    Method for segregation 0 and 1 given input array
    */
    static void segregate0and1(int arr[])
    {
        int type0 = 0;
        int type1 = arr.length - 1;
 
        while (type0 < type1) {
            if (arr[type0] == 1) {
                if (arr[type1] != 1) {
                    // swap
                    arr[type1] = arr[type1] + arr[type0];
                    arr[type0] = arr[type1] - arr[type0];
                    arr[type1] = arr[type1] - arr[type0];
                }
                type1--;
            }
            else {
                type0++;
            }
        }
    }
 
    // Driver program
    public static void main(String[] args)
    {
 
        int[] array = { 0, 1, 0, 1, 1, 1 };
 
        segregate0and1(array);
 
        for (int a : array) {
            System.out.print(a + " ");
        }
    }
}
Python3



# Python program to sort a
# binary array in one pass
 
# Function to put all 0s on
# left and all 1s on right
 
 
def segregate0and1(arr, size):
 
    type0 = 0
    type1 = size - 1
 
    while(type0 < type1):
        if(arr[type0] == 1):
            if(arr[type1] != 1):
              (arr[type0],
               arr[type1]) = (arr[type1],
                              arr[type0])
            type1 -= 1
        else:
            type0 += 1
     
# Driver Code
arr = [0, 1, 0, 1, 1, 1]
arr_size = len(arr)
segregate0and1(arr, arr_size)
print("Array after segregation is",
                         end = " ")
for i in range(0, arr_size):
        print(arr[i], end = " ")
 
# This code is contributed
# by Shivi_Aggarwal
C#



// C# code to segregate 0 and 1
using System;
 
class GFG {
 
    // Method for segregation 0
    // and 1 given input array
    static void segregate0and1(int[] arr)
    {
        int type0 = 0;
        int type1 = arr.Length - 1;
 
        while (type0 < type1) {
            if (arr[type0] == 1) {
                if (arr[type1] != 1) {
                    // swap
                    arr[type1] = arr[type1] + arr[type0];
                    arr[type0] = arr[type1] - arr[type0];
                    arr[type1] = arr[type1] - arr[type0];
                }
                type1--;
            }
 
            else {
                type0++;
            }
        }
    }
 
    // Driver Code
    public static void Main(string[] args)
    {
 
        int[] array = new int[] { 0, 1, 0, 1, 1, 1 };
        segregate0and1(array);
 
        Console.Write("Array after segregation is ");
        foreach(int a in array) { Console.Write(a + " "); }
    }
}
 
// This code is contributed by Shrikant13
PHP



<?php
// PHP program to sort a
// binary array in one pass
 
// Function to put all 0s on
// left and all 1s on right
function segregate0and1(&$arr , $size)
{
    $type0 = 0;
    $type1 = $size - 1;
     
    while($type0 < $type1)
    {
        if($arr[$type0] == 1)
        {
              if($arr[$type1] != 1)
            {
              $temp = $arr[$type0];
              $arr[$type0] = $arr[$type1];
              $arr[$type1] = $temp;
            }
            $type1--;
        }
        else
        $type0++;
    }
}
 
// Driver Code
$arr = array(0, 1, 0, 1, 1, 1);
$arr_size = sizeof($arr);
 
segregate0and1($arr, $arr_size);
 
echo ("Array after segregation is ");
for ($i = 0; $i < $arr_size; $i++)
    echo ($arr[$i] . " ");
 
// This code is contributed
// by Shivi_Aggarwal
?>
Javascript



<script>
 
// Javascript program to sort a
// binary array in one pass
 
// Function to put all 0s on
// left and all 1s on right
function segregate0and1(arr, size)
{
    let type0 = 0;
    let type1 = size - 1;
     
    while (type0 < type1)
    {
        if (arr[type0] == 1)
        {
             if (arr[type1] != 1)
            {  
              // Swap
              arr[type1] = arr[type1] + arr[type0];
              arr[type0] = arr[type1] - arr[type0];
              arr[type1] = arr[type1] - arr[type0];
             }
            type1--;
        }
        else
            type0++;
    }
}
 
// Driver Code
let arr = [ 0, 1, 0, 1, 1, 1 ];
let i, arr_size = arr.length;
 
segregate0and1(arr, arr_size);
 
document.write("Array after segregation is ");
for(i = 0; i < arr_size; i++)
    document.write(arr[i] + " ");
     
// This code is contributed by subhammahato348
 
</script>
Output
Array after segregation is 0 0 1 1 1 1 
Time complexity: O(n)
// Thanks san4net for suggesting this method.
 
Please write comments if you find any of the above algorithms/code incorrect, or a better way to solve the same problem.
 

My Personal Notes
arrow_drop_up
Previous
Sort an array of 0s, 1s and 2s (Simple Counting)
Next

Segregate Even and Odd numbers
Recommended Articles
Page :
Segregate Prime and Non-Prime Numbers in an array
30, Apr 21
Python3 Program for Segregate 0s and 1s in an array
28, Nov 21
Python Program for Segregate 0s and 1s in an array
28, Nov 21
Segregate Even and Odd numbers
07, Jun 10
Segregate even and odd nodes in a Linked List
22, Apr 11
Segregate even and odd numbers | Set 2
01, Feb 18
Segregate even and odd numbers | Set 3
13, May 18
Segregate Even and Odd numbers | Set 2
01, Nov 20
Modify array to another given array by replacing array elements with the sum of the array
12, Feb 21
Modify array to another given array by replacing array elements with the sum of the array | Set-2
29, Mar 22
Maximize sum of array by reducing array elements to contain no triplets (i, j, k) where a[i] < a[j] and a[i] < a[k] and j <i < k
09, Sep 20
Minimize swaps required to place largest and smallest array elements at first and last array indices
28, Jan 21
Generate an N-length array having length of non-decreasing subarrays maximized and minimum difference between first and last array elements
23, Jul 21
Find N-1 pairs (X, Y) from given array such that X and Y are different and X modulo Y is not preset in array
29, Dec 21
Find original array from encrypted array (An array of sums of other elements)
12, Apr 17
Check whether an array can be fit into another array rearranging the elements in the array
09, Jul 18
Find an element in array such that sum of left array is equal to sum of right array
07, Sep 17
Find Array formed by adding each element of given array with largest element in new array to its left
24, Mar 20
Array obtained by repeatedly reversing array after every insertion from given array
01, Oct 20
Maximize product of array by replacing array elements with its sum or product with element from another array
27, Oct 20
Reduce array to longest sorted array possible by removing either half of given array in each operation
17, Nov 20
Sum of Bitwise OR of each array element of an array with all elements of another array
21, Dec 20
Convert an array into Bitonic array by right shifting array elements
03, May 21
Sum of array elements possible by appending arr[i] / K to the end of the array K times for array elements divisible by K
19, Apr 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!