Related Articles

# Segregate 0s and 1s in an array

• Difficulty Level : Easy
• Last Updated : 13 Apr, 2021

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. 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. Let count be C.
2) Once we have count, we can put C 0s at the beginning and 1s at the remaining n – C positions in array.
Time Complexity : O(n)

## C++

 `// C++ code to Segregate 0s and 1s in an array``#include ``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);``    ` `    ``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

 ``

## Javascript

 ``

Output :

`Array after segregation is 0 0 1 1 1 1 `

The 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 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 ``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);` `    ``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` `/*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);` `    ``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

 ``

## Javascript

 ``

Output:

`Array after segregation is 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 left side of array.

## C++

 `// C++ program to sort a``// binary array in one pass``#include ``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)``        ``{``            ``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);` `    ``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``) {``                ``// 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``):``            ``(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)``        ``{``            ``// 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

 ``

## Javascript

 ``

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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up