Binary Insertion Sorter Algorithm
The Binary Insertion Sort algorithm is an advanced variation of the traditional Insertion Sort algorithm, which aims to optimize the comparison and shifting operations during the sorting process. While the basic concept of Insertion Sort involves comparing and shifting elements one by one in a linear fashion, Binary Insertion Sort leverages the binary search technique to find the appropriate position for each element in the sorted part of the array. This significantly reduces the number of comparisons needed to insert an element at its correct position.
In the Binary Insertion Sort algorithm, the elements in the array are divided into two parts: the sorted part and the unsorted part. Initially, the sorted part consists of only the first element, and the rest are considered unsorted. The algorithm then iteratively picks an element from the unsorted part and performs a binary search on the sorted part to find the correct position for the element. Once the position is determined, the elements in the sorted part are shifted to make room for the new element, and the element is inserted at the correct position. This process continues until all the elements from the unsorted part are inserted into the sorted part, resulting in a completely sorted array. The key advantage of Binary Insertion Sort over the traditional Insertion Sort is the reduction in the number of comparisons required, making it more efficient for larger arrays or arrays with repetitive elements.
using System;
using System.Collections.Generic;
namespace Algorithms.Sorters.Comparison
{
/// <summary>
/// TODO.
/// </summary>
/// <typeparam name="T">TODO. 2.</typeparam>
public class BinaryInsertionSorter<T> : IComparisonSorter<T>
{
/// <summary>
/// Sorts array using specified comparer,
/// variant of insertion sort where binary search is used to find place for next element
/// internal, in-place, unstable,
/// time complexity: O(n^2),
/// space complexity: O(1),
/// where n - array length.
/// </summary>
/// <param name="array">Array to sort.</param>
/// <param name="comparer">Compares elements.</param>
public void Sort(T[] array, IComparer<T> comparer)
{
for (var i = 1; i < array.Length; i++)
{
var target = array[i];
var moveIndex = i - 1;
var targetInsertLocation = BinarySearch(array, 0, moveIndex, target, comparer);
Array.Copy(array, targetInsertLocation, array, targetInsertLocation + 1, i - targetInsertLocation);
array[targetInsertLocation] = target;
}
}
/// <summary>Implementation of Binary Search using an iterative approach.</summary>
/// <param name="array">An array of values sorted in ascending order between the index values left and right to search through.</param>
/// <param name="from">Left index to search from (inclusive).</param>
/// <param name="to">Right index to search to (inclusive).</param>
/// <param name="target">The value to find placefor in the provided array.</param>
/// <param name="comparer">TODO.</param>
/// <returns>The index where to insert target value.</returns>
private static int BinarySearch(T[] array, int from, int to, T target, IComparer<T> comparer)
{
var left = from;
var right = to;
while (right > left)
{
var middle = (left + right) / 2;
var comparisonResult = comparer.Compare(target, array[middle]);
if (comparisonResult == 0)
{
return middle + 1;
}
if (comparisonResult > 0)
{
left = middle + 1;
}
else
{
right = middle - 1;
}
}
return comparer.Compare(target, array[left]) < 0 ? left : left + 1;
}
}
}
