Minimum adjacent swaps required to Sort Binary array

Given a binary array, the task is to find the minimum number of swaps needed to sort this binary array. We are allowed to swap only adjacent elements.

Examples: 

Input : arr[] = [0, 0, 1, 0, 1, 0, 1, 1]
Output : 3
Explanation:
1st swap : [0, 0, 1, 0, 0, 1, 1, 1]
2nd swap : [0, 0, 0, 1, 0, 1, 1, 1]
3rd swap : [0, 0, 0, 0, 1, 1, 1, 1]

Input : arr[]= [0, 0, 0, 1, 1]
Output : 0
Explanation: Array is already sorted.

Approach:

Since a sorted binary array would have all 0s followed by all 1s, we can process the array from right to left and calculate how many positions each 1 needs to travel through to reach its correct position. The count of positions for a 1 would be equal to number of zeros on right side of it.

Step by step approach:

1. Start traversing the array from the end:
2. If 0 is found, increment the zero count.
3. When a 1 is found, it must move past all zeros to its right. So, add the count of zeros to the total swaps for each 1 encountered.

Illustration:

Taking example of arr[] = [0, 0, 1, 0, 1, 0, 1, 1]:

1. Position 7: Element is 1, zero count = 0, swaps = 0
2. Position 6: Element is 1, zero count = 0, swaps = 0
3. Position 5: Element is 0, zero count = 1, swaps = 0
4. Position 4: Element is 1, zero count = 1, swaps = 1
5. Position 3: Element is 0, zero count = 2, swaps = 1
6. Position 2: Element is 1, zero count = 2, swaps = 3
7. Position 1: Element is 0, zero count = 3, swaps = 3
8. Position 0: Element is 0, zero count = 4, swaps = 3 + 0 = 3

// C++ program to find Minimum adjacent 
// swaps required to Sort Binary array
#include <bits/stdc++.h>
using namespace std;

// Function to find Minimum adjacent 
// swaps required to Sort Binary array
int minSwaps(vector<int> &arr) {
    int n = arr.size();
    int res = 0;
    
    int zeroCount = 0;
    
    for (int i = n - 1; i >= 0; i--) {
        
        // If current element is 0, 
        // increment count of zeros
        if (arr[i] == 0) {
            zeroCount++;
        }
        
        // If current element is 1, it needs to be 
        // swapped with the number of zeros found 
        // so far.
        else {
            res += zeroCount;
        }
    }
    
    return res;
}

int main() {
    vector<int> arr = {0, 0, 1, 0, 1, 0, 1, 1};
    cout << minSwaps(arr);
    return 0;
}

// Java program to find Minimum adjacent 
// swaps required to Sort Binary array
import java.util.*;

class GfG {

    // Function to find Minimum adjacent 
    // swaps required to Sort Binary array
    static int minSwaps(int[] arr) {
        int n = arr.length;
        int res = 0;
        
        int zeroCount = 0;
        
        for (int i = n - 1; i >= 0; i--) {
            
            // If current element is 0, 
            // increment count of zeros
            if (arr[i] == 0) {
                zeroCount++;
            }
            
            // If current element is 1, it needs to be 
            // swapped with the number of zeros found 
            // so far.
            else {
                res += zeroCount;
            }
        }
        
        return res;
    }

    public static void main(String[] args) {
        int[] arr = {0, 0, 1, 0, 1, 0, 1, 1};
        System.out.println(minSwaps(arr));
    }
}

# Python program to find Minimum adjacent 
# swaps required to Sort Binary array

# Function to find Minimum adjacent 
# swaps required to Sort Binary array
def minSwaps(arr):
    n = len(arr)
    res = 0
    
    zeroCount = 0
    
    for i in range(n - 1, -1, -1):
        
        # If current element is 0, 
        # increment count of zeros
        if arr[i] == 0:
            zeroCount += 1
        
        # If current element is 1, it needs to be 
        # swapped with the number of zeros found 
        # so far.
        else:
            res += zeroCount
    
    return res

if __name__ == "__main__":
    arr = [0, 0, 1, 0, 1, 0, 1, 1]
    print(minSwaps(arr))

// C# program to find Minimum adjacent 
// swaps required to Sort Binary array
using System;

class GfG {

    // Function to find Minimum adjacent 
    // swaps required to Sort Binary array
    static int minSwaps(int[] arr) {
        int n = arr.Length;
        int res = 0;
        
        int zeroCount = 0;
        
        for (int i = n - 1; i >= 0; i--) {
            
            // If current element is 0, 
            // increment count of zeros
            if (arr[i] == 0) {
                zeroCount++;
            }
            
            // If current element is 1, it needs to be 
            // swapped with the number of zeros found 
            // so far.
            else {
                res += zeroCount;
            }
        }
        
        return res;
    }

    static void Main(string[] args) {
        int[] arr = {0, 0, 1, 0, 1, 0, 1, 1};
        Console.WriteLine(minSwaps(arr));
    }
}

// JavaScript program to find Minimum adjacent 
// swaps required to Sort Binary array

// Function to find Minimum adjacent 
// swaps required to Sort Binary array
function minSwaps(arr) {
    let n = arr.length;
    let res = 0;
    
    let zeroCount = 0;
    
    for (let i = n - 1; i >= 0; i--) {
        
        // If current element is 0, 
        // increment count of zeros
        if (arr[i] == 0) {
            zeroCount++;
        }
        
        // If current element is 1, it needs to be 
        // swapped with the number of zeros found 
        // so far.
        else {
            res += zeroCount;
        }
    }
    
    return res;
}

let arr = [0, 0, 1, 0, 1, 0, 1, 1];
console.log(minSwaps(arr));

3

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

Now try the below question yourself

What would be the count when we can swap any 0 with any 1?