Sort an array containing two types of elements

We 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.

Examples:

Input :  arr[] = [0, 1, 0, 1, 0, 0, 1, 1, 1, 0] 
Output : arr[] = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1] 

Input :  arr[] = [1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1] 
Output : arr[] = [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1] 


We have already discussed a solution Segregate 0s and 1s in an array

In this post, a new solution is discussed.

Step 1 : Here we can take two pointers type0 (for element 0) starting from beginning (index = 0) and type1 (for element 1) starting from end index.

Step 2: We intend to put 1 to the right side of the array. Once we have done this then 0 will definitely towards left side of array to achieve this we do following.
We compare elements at index type0
1) if this is 1 then this should be moved to right side so we need to swap this with index type1 once swapped we are sure that element at index type1 is ‘1’ so we need to decrement index type1
2) else it will be 0 then we need to simple increment index type0

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to sort an array with two types
// of values in one traversal.
#include <bits/stdc++.h>
using namespace std;
  
/* Method for segregation 0 and 1 given 
   input array */
void segregate0and1(int arr[], int n)
{
    int type0 = 0;
    int type1 = n - 1;
  
    while (type0 < type1) {
        if (arr[type0] == 1) {
            swap(arr[type0], arr[type1]);
            type1--;
        }
        else {
            type0++;
        }
    }
}
  
// Driver program
int main()
{
    int arr[] = { 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1 };
    int n = sizeof(arr)/sizeof(arr[0]);
    segregate0and1(arr, n);
    for (int a : arr)
        cout << a << " ";
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to sort an array with two types
// of values in one traversal.public class GFG {
    /* Method for segregation 0 and 1 
         given input array */
    static void segregate0and1(int arr[], int n) {
        int type0 = 0;
        int type1 = n - 1;
  
        while (type0 < type1) {
            if (arr[type0] == 1) {
  
                // swap type0 and type1
                arr[type0] = arr[type0] + arr[type1];
                arr[type1] = arr[type0]-arr[type1];
                arr[type0] = arr[type0]-arr[type1];
                type1--;
            } else {
                type0++;
            }
        }
    }
  
    // Driver program
    public static void main(String[] args) {
          int arr[] = { 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1 };
  
          segregate0and1(arr, arr.length);
          for (int a : arr)
              System.out.print(a+" ");
      }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to sort an array with 
# two types of values in one traversal.
  
# Method for segregation 0 and 
# 1 given input array 
def segregate0and1(arr, n):
  
    type0 = 0; type1 = n - 1
  
    while (type0 < type1): 
        if (arr[type0] == 1): 
            arr[type0], arr[type1] = arr[type1], arr[type0]
            type1 -= 1
          
        else
            type0 += 1
          
# Driver Code
arr = [1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1
n = len(arr)
segregate0and1(arr, n)
for i in range(0, n):
    print(arr[i], end = " ")
  
# This code is contributed by Smitha Dinesh Semwal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to sort an array with two types
// of values in one traversal.
using System;
  
class GFG {
      
    static void segregate0and1(int []arr, int n)
    {
        int type0 = 0;
        int type1 = n - 1;
  
        while (type0 < type1)
        {
              
            if (arr[type0] == 1)
            {
  
                // swap type0 and type1
                arr[type0] = arr[type0] + arr[type1];
                arr[type1] = arr[type0]-arr[type1];
                arr[type0] = arr[type0]-arr[type1];
                type1--;
            
            else {
                type0++;
            }
        }
    }
  
    // Driver program
    public static void Main()
    {
          
        int []arr = { 1, 1, 1, 0, 1, 0, 0,
                             1, 1, 1, 1 };
  
        segregate0and1(arr, arr.Length);
          
        for (int i = 0; i < arr.Length; i++)
            Console.Write(arr[i] + " ");
    }
}
  
// This code is contributed by vt_m.

chevron_right


Output:

0 0 0 1 1 1 1 1 1 1 1


My Personal Notes arrow_drop_up

computer science guys love algo problem solving

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : san4net



Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.