# Python Program for Segregate 0s and 1s in an array

• Difficulty Level : Easy
• Last Updated : 14 Dec, 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)

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:

## 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 `

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.

Output:

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

Time complexity: O(n)
Please refer complete article on Segregate 0s and 1s in an array for more details!

My Personal Notes arrow_drop_up
Recommended Articles
Page :