# Sort a binary array using one traversal and no extra space

• Difficulty Level : Easy
• Last Updated : 15 Sep, 2022

Given a binary array, sort it using one traversal and no extra space

Examples:

Input: 1 0 0 1 0 1 0 1 1 1 1 1 1 0 0 1 1 0 1 0 0
Output: 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1
Explanation: The output is a sorted array of 0 and 1

Input: 1 0 1 0 1 0 1 0
Output: 0 0 0 0 1 1 1 1
Explanation: The output is a sorted array of 0 and 1

## Sort a binary array using one traversal using partition function of quicksort:

This concept is related to partition of quick sort . In the quick sort partition function, after one scan, the left of the array is the smallest and the right of the array is the largest of the selected pivot element

Follow the given steps to solve the problem:

• Create a variable index say j = -1
• Traverse the array from start to end
• If the element is 0 then swap the current element with the element at the index( jth ) position and increment the index j by 1.
• If the element is 1 keep the element as it is.

Below is the implementation of the above approach:

## CPP

```// CPP program to sort a binary array
#include <iostream>
using namespace std;

void sortBinaryArray(int a[], int n)
{
int j = -1;
for (int i = 0; i < n; i++) {

// if number is smaller than 1
// then swap it with j-th number
if (a[i] < 1) {
j++;
swap(a[i], a[j]);
}
}
}

// Driver code
int main()
{
int a[] = { 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1,
1, 1, 0, 0, 1, 1, 0, 1, 0, 0 };
int n = sizeof(a) / sizeof(a[0]);

// Function call
sortBinaryArray(a, n);
for (int i = 0; i < n; i++)
cout << a[i] << " ";

return 0;
}```

## Java

```// JAVA Code for Sort a binary
// array using one traversal
import java.util.*;

class GFG {

static void sortBinaryArray(int a[], int n)
{
int j = -1;
for (int i = 0; i < n; i++) {

// if number is smaller than 1
// then swap it with j-th number
if (a[i] < 1) {
j++;
int temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
}

// Driver code
public static void main(String[] args)
{

int a[] = { 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1,
1, 1, 0, 0, 1, 1, 0, 1, 0, 0 };

int n = a.length;

// Function call
sortBinaryArray(a, n);

for (int i = 0; i < n; i++)
System.out.print(a[i] + " ");
}
}```

## Python3

```# A Python program to sort a
# binary array

def sortBinaryArray(a, n):
j = -1
for i in range(n):

# if number is smaller
# than 1 then swap it
# with j-th number
if a[i] < 1:
j = j + 1

# swap
a[i], a[j] = a[j], a[i]

# Driver code
if __name__ == "__main__":
a = [1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1,
1, 1, 0, 0, 1, 1, 0, 1, 0, 0]
n = len(a)

# Function call
sortBinaryArray(a, n)

for i in range(n):
print(a[i], end=" ")

# This code is contributed by Shrikant13.
```

## C#

```// C# Code for Sort a binary
// array using one traversal
using System;

class GFG {

static void sortBinaryArray(int[] a, int n)
{
int j = -1;
for (int i = 0; i < n; i++) {

// if number is smaller than
// 1 then swap it with j-th
// number
if (a[i] < 1) {
j++;
int temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
}

// Driver code
public static void Main()
{

int[] a = { 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1,
1, 1, 0, 0, 1, 1, 0, 1, 0, 0 };

int n = a.Length;

// Function call
sortBinaryArray(a, n);

for (int i = 0; i < n; i++)
Console.Write(a[i] + " ");
}
}

// This code is contributed by vt_m.```

## PHP

```<?php
// PHP Code for Sort a binary
// array using one traversal
function sortBinaryArray(\$a, \$n)
{
\$j = -1;
for (\$i = 0; \$i < \$n; \$i++)
{

// if number is smaller than
// 1 then swap it with j-th
// number
if (\$a[\$i] < 1)
{
\$j++;
\$temp = \$a[\$j];
\$a[\$j] = \$a[\$i];
\$a[\$i] = \$temp;
}
}
for (\$i = 0; \$i < \$n; \$i++)
echo \$a[\$i] . " ";

}

// Driver Code
\$a = array(1, 0, 0, 1, 0, 1, 0,
1, 1, 1, 1, 1, 1, 0,
0, 1, 1, 0, 1, 0, 0);

\$n = count(\$a);

// Function call
sortBinaryArray(\$a, \$n);

// This code is contributed by Sam007
?>```

## Javascript

```<script>
// Javascript Code for Sort a binary
// array using one traversal

function sortBinaryArray(a, n)
{
let j = -1;
for (let i = 0; i < n; i++) {

// if number is smaller than 1
// then swap it with j-th number
if (a[i] < 1) {
j++;
let temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
}

// driver function
let a = [ 1, 0, 0, 1, 0, 1, 0, 1, 1, 1,
1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0 ];

let n = a.length;

sortBinaryArray(a, n);

for (let i = 0; i < n; i++)
document.write(a[i] + " ");

// This code is contributed by code_hunt.
</script>```
Output

`0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 `

Time Complexity: O(N), Only one traversal of the array is needed, So the time Complexity is O(N)
Auxiliary Space: O(1). The space required is constant

This article is contributed by Devanshu Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.