# Sort a binary array using one traversal

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

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

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.

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

1. Create a variable index index = 0
2. Traverse the array from start to end
3. If the element is 0 then swap the current element with the element at index position and increment the index by 1.
4. If the element is 1 keep the element as it is.

Implementation:

## CPP

 `// CPP program to sort a binary array``#include ``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]);``    ``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 program to test above function */``    ``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;` `        ``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 program``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)` `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 program to test above``    ``function */``    ``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;` `        ``sortBinaryArray(a, n);` `        ``for` `(``int` `i = 0; i < n; i++)``            ``Console.Write(a[i] + ``" "``);``    ``}``}` `// This code is contributed by vt_m.`

## PHP

 ``

## Javascript

 `   `

Output :

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

Complexity Analysis:

• Time Complexity: O(n).
Only one traversal of the array is needed, So time Complexity is O(n).

• Space Complexity: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 contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.