Binary Sort

1. Binary Sort Algorithm
2. Binary Sort Example
3. Binary Sort Algorithm Implementation
4. Binary Sort Algorithm Complexity

Binary sort is a comparison type sorting algorithm. It is a modification of the insertion sort algorithm. In this algorithm, we also maintain one sorted and one unsorted subarray. The only difference is that we find the correct position of an element using binary search instead of linear search. It helps to fasten the sorting algorithm by reducing the number of comparisons required.

Binary Sort Algorithm

Let us assume that we have an unsorted array A[] containing n elements. The first element, A[0], is already sorted and in the sorted subarray.

Binary Sort Example

Suppose we have the array: (5,3,4,2,1,6). We will sort it using the insertion sort algorithm.

• First Iteration

Key : A[1] = 3

Binary Search: returns the position of 3 as index 0. Right shift rest of elements in the sorted array.

• Second Iteration

Key : A[2] = 4

Binary Search: returns the position of 4 as index 1. Right shift rest of elements in the sorted array.

• Third Iteration

Key : A[3] = 2

Binary Search: returns the position of 2 as index 0. Right shift rest of elements in the sorted array.

• Fourth Iteration

Key : A[4] = 1

Binary Search: return the position of 1 as index 0. Right shift rest of elements in the sorted array.

• Fifth Iteration

Key : A[5] = 6

Binary Search: return the position of 6 as index 5. There are no elements on the right side.

We get the sorted array after the fourth iteration - (1 2 3 4 5 6)

Binary Sort Algorithm Implementation

#include <bits/stdc++.h>
using namespace std;

int binarySearch(int a[], int x, int low, int high) {
  if (high <= low) return (x > a[low]) ? (low + 1) : low;

  int mid = (low + high) / 2;

  if (x == a[mid]) return mid + 1;

  if (x > a[mid]) return binarySearch(a, x, mid + 1, high);
  return binarySearch(a, x, low, mid - 1);
}

void binarySort(int a[], int n) {
  for (int i = 1; i < n; ++i) {
    int j = i - 1;
    int key = a[i];
    int pos = binarySearch(a, key, 0, j);
    while (j >= pos) {
      a[j + 1] = a[j];
      j--;
    }
    a[j + 1] = key;
  }
}

int main() {
  int n = 6;
  int arr[6] = {5, 3, 4, 2, 1, 6};
  cout << "Input arr: ";
  for (int i = 0; i < n; i++) {
    cout << arr[i] << " ";
  }
  cout << "\n";
  binarySort(arr, n);  // Sort elements in ascending order
  cout << "Output arr: ";
  for (int i = 0; i < n; i++) {
    cout << arr[i] << " ";
  }
  cout << "\n";
}

Binary Sort Algorithm Complexity

Time Complexity

• Average Case

Binary search has logarithmic complexity logn compared to linear complexity n of linear search used in insertion sort. We use binary sort for n elements giving us the time complexity nlogn. Hence, the time complexity is of the order of [Big Theta]: O(nlogn).

• Worst Case

The worst-case occurs when the array is reversely sorted, and the maximum number of shifts are required. The worst-case time complexity is [Big O]: O(nlogn).

• Best Case

The best-case occurs when the array is already sorted, and no shifting of elements is required. The best-case time complexity is [Big Omega]: O(n).

Space Complexity

Space Complexity for the binary sort algorithm is O(n) because no extra memory other than a temporary variable is required.