 Open in App
Not now

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

• Difficulty Level : Easy
• Last Updated : 17 Mar, 2023

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.

Example:

```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: Using sort() function

## Python3

 `# driver program to test` `arr ``=` `[``0``, ``1``, ``0``, ``1``, ``1``, ``1``]` `arr.sort()` `print``(``"Array after segregation is"``, end``=``' '``)` `print``(``*``arr)`   `# This code is contributed by vikkycirus`

Output

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

Time Complexity: O(n*logn)
Auxiliary Space: O(1)

Method 2: (Count 0s or 1s)

• Count the number of 0s. Let count be C.
• 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)
Auxiliary Space: O(1)
Thanks to Naveen for suggesting this method.

Method 3: (Use two indexes to traverse)
Method 2 traverses the array two times. Method 3 does the same in a single pass.

Maintain two indexes. Initialize first index left as 0 and second index right as n-1.
Do the 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
[0, 0, 1, 1, 1, 1]```

Time Complexity: O(n)
Auxiliary Space: O(1)

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.

Please refer complete article on Segregate 0s and 1s in an array for more details!

My Personal Notes arrow_drop_up
Related Articles