Refactoring BinaryInsertionSort according to common SortAlgorithm approach (#5239)

* Refactoring BinaryInsertionSort according to common SortAlgorithm approach

* Formatting has been fixed

* Refactoring tests for BinaryInsertionSort according to SortingAlgorithmTest

* Removing redundant tests and improving variable readability

---------

Co-authored-by: alx <[email protected]>
Co-authored-by: Piotr Idzik <[email protected]>

Author: 3 people

src/main/java/com/thealgorithms/sorts/BinaryInsertionSort.java

@@ -1,17 +1,28 @@
 package com.thealgorithms.sorts;
 
-public class BinaryInsertionSort {
+/**
+ * BinaryInsertionSort class implements the SortAlgorithm interface using the binary insertion sort technique.
+ * Binary Insertion Sort improves upon the simple insertion sort by using binary search to find the appropriate
+ * location to insert the new element, reducing the number of comparisons in the insertion step.
+ */
+public class BinaryInsertionSort implements SortAlgorithm {
 
-    // Binary Insertion Sort method
-    public int[] binaryInsertSort(int[] array) {
+    /**
+     * Sorts the given array using the Binary Insertion Sort algorithm.
+     *
+     * @param <T> the type of elements in the array, which must implement the Comparable interface
+     * @param array the array to be sorted
+     * @return the sorted array
+     */
+    public <T extends Comparable<T>> T[] sort(T[] array) {
         for (int i = 1; i < array.length; i++) {
-            int temp = array[i];
+            final T temp = array[i];
             int low = 0;
             int high = i - 1;
 
             while (low <= high) {
                 final int mid = (low + high) >>> 1;
-                if (temp < array[mid]) {
+                if (temp.compareTo(array[mid]) < 0) {
                     high = mid - 1;
                 } else {
                     low = mid + 1;

src/test/java/com/thealgorithms/sorts/BinaryInsertionSortTest.java

@@ -1,27 +1,10 @@
 package com.thealgorithms.sorts;
 
-import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+class BinaryInsertionSortTest extends SortingAlgorithmTest {
+    private final BinaryInsertionSort binaryInsertionSort = new BinaryInsertionSort();
 
-import org.junit.jupiter.api.Test;
-
-class BinaryInsertionSortTest {
-
-    BinaryInsertionSort bis = new BinaryInsertionSort();
-
-    @Test
-    // valid test case
-    public void binaryInsertionSortTestNonDuplicate() {
-        int[] array = {1, 0, 2, 5, 3, 4, 9, 8, 10, 6, 7};
-        int[] expResult = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-        int[] actResult = bis.binaryInsertSort(array);
-        assertArrayEquals(expResult, actResult);
-    }
-
-    @Test
-    public void binaryInsertionSortTestDuplicate() {
-        int[] array = {1, 1, 1, 5, 9, 8, 7, 2, 6};
-        int[] expResult = {1, 1, 1, 2, 5, 6, 7, 8, 9};
-        int[] actResult = bis.binaryInsertSort(array);
-        assertArrayEquals(expResult, actResult);
+    @Override
+    SortAlgorithm getSortAlgorithm() {
+        return binaryInsertionSort;
     }
 }