Skip to content
Related Articles

Related Articles

Sort a binary array using one traversal
  • Difficulty Level : Easy
  • Last Updated : 31 Mar, 2020

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

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 <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]);
    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




<?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);
sortBinaryArray($a, $n);
  
// This code is contributed by Sam007
?>


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 contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

    Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

    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.

    My Personal Notes arrow_drop_up
  • Recommended Articles
    Page :