#6336/enhancement/Refactor: Standardize comparison logic using SortUtils (#6442)

* Refactoring compareTo() to SortUtils methods

* Adding formatting

* Removed excess parenthesis

---------

Co-authored-by: Deniz Altunkapan <93663085+DenizAltunkapan@users.noreply.github.com>

Author: dinishajais

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

@@ -30,7 +30,7 @@ private <T extends Comparable<T>> void merge(T[] array, T[] aux, int low, int mi
                 array[k] = aux[j++];
             } else if (j > high) {
                 array[k] = aux[i++];
-            } else if (aux[j].compareTo(aux[i]) < 0) {
+            } else if (SortUtils.less(aux[j], aux[i])) {
                 array[k] = aux[j++];
             } else {
                 array[k] = aux[i++];

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

@@ -22,7 +22,7 @@ public <T extends Comparable<T>> T[] sort(T[] array) {
 
             while (low <= high) {
                 final int mid = (low + high) >>> 1;
-                if (temp.compareTo(array[mid]) < 0) {
+                if (SortUtils.less(temp, array[mid])) {
                     high = mid - 1;
                 } else {
                     low = mid + 1;

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

@@ -64,7 +64,7 @@ private <T extends Comparable<T>> void bitonicMerge(T[] array, int low, int cnt,
         if (cnt > 1) {
             final int k = cnt / 2;
 
-            final BiPredicate<T, T> areSorted = (direction == Direction.ASCENDING) ? (a, b) -> a.compareTo(b) < 0 : (a, b) -> a.compareTo(b) > 0;
+            final BiPredicate<T, T> areSorted = (direction == Direction.ASCENDING) ? (a, b) -> SortUtils.less(a, b) : (a, b) -> SortUtils.greater(a, b);
             for (int i = low; i < low + k; i++) {
                 if (!areSorted.test(array[i], array[i + k])) {
                     SortUtils.swap(array, i, i + k);

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

@@ -111,7 +111,7 @@ private <T extends Comparable<T>> int hash(final T element, final T min, final T
     private <T extends Comparable<T>> T findMin(T[] array) {
         T min = array[0];
         for (T element : array) {
-            if (element.compareTo(min) < 0) {
+            if (SortUtils.less(element, min)) {
                 min = element;
             }
         }
@@ -121,7 +121,7 @@ private <T extends Comparable<T>> T findMin(T[] array) {
     private <T extends Comparable<T>> T findMax(T[] array) {
         T max = array[0];
         for (T element : array) {
-            if (element.compareTo(max) > 0) {
+            if (SortUtils.greater(element, max)) {
                 max = element;
             }
         }

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

@@ -36,15 +36,15 @@ private <T extends Comparable<T>> boolean doSort(final T[] array, final int left
         int high = right;
 
         while (low < high) {
-            if (array[low].compareTo(array[high]) > 0) {
+            if (SortUtils.greater(array[low], array[high])) {
                 SortUtils.swap(array, low, high);
                 swapped = true;
             }
             low++;
             high--;
         }
 
-        if (low == high && array[low].compareTo(array[high + 1]) > 0) {
+        if (low == high && SortUtils.greater(array[low], array[high + 1])) {
             SortUtils.swap(array, low, high + 1);
             swapped = true;
         }

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

@@ -26,11 +26,11 @@ private <T extends Comparable<T>> T[] dutchNationalFlagSort(final T[] array, fin
         int k = array.length - 1;
 
         while (j <= k) {
-            if (0 > array[j].compareTo(intendedMiddle)) {
+            if (SortUtils.less(array[j], intendedMiddle)) {
                 SortUtils.swap(array, i, j);
                 j++;
                 i++;
-            } else if (0 < array[j].compareTo(intendedMiddle)) {
+            } else if (SortUtils.greater(array[j], intendedMiddle)) {
                 SortUtils.swap(array, j, k);
                 k--;
             } else {

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

@@ -31,7 +31,7 @@ class ExchangeSort implements SortAlgorithm {
     public <T extends Comparable<T>> T[] sort(T[] array) {
         for (int i = 0; i < array.length - 1; i++) {
             for (int j = i + 1; j < array.length; j++) {
-                if (array[i].compareTo(array[j]) > 0) {
+                if (SortUtils.greater(array[i], array[j])) {
                     SortUtils.swap(array, i, j);
                 }
             }

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

@@ -63,7 +63,7 @@ private static <T extends Comparable<T>> int partition(T[] array, final int low,
         final T pivot = array[high];
         int i = low - 1;
         for (int j = low; j < high; j++) {
-            if (array[j].compareTo(pivot) <= 0) {
+            if (SortUtils.greaterOrEqual(pivot, array[j])) {
                 i++;
                 SortUtils.swap(array, i, j);
             }
@@ -84,7 +84,7 @@ private static <T extends Comparable<T>> void insertionSort(T[] array, final int
         for (int i = low + 1; i <= high; i++) {
             final T key = array[i];
             int j = i - 1;
-            while (j >= low && array[j].compareTo(key) > 0) {
+            while (j >= low && SortUtils.greater(array[j], key)) {
                 array[j + 1] = array[j];
                 j--;
             }
@@ -125,10 +125,10 @@ private static <T extends Comparable<T>> void heapify(T[] array, final int i, fi
         final int right = 2 * i + 2;
         int largest = i;
 
-        if (left < n && array[low + left].compareTo(array[low + largest]) > 0) {
+        if (left < n && SortUtils.greater(array[low + left], array[low + largest])) {
             largest = left;
         }
-        if (right < n && array[low + right].compareTo(array[low + largest]) > 0) {
+        if (right < n && SortUtils.greater(array[low + right], array[low + largest])) {
             largest = right;
         }
         if (largest != i) {

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

@@ -30,7 +30,7 @@ public <T extends Comparable<T>> T[] sort(T[] array) {
     private <T extends Comparable<T>> boolean performOddSort(T[] array) {
         boolean sorted = true;
         for (int i = 1; i < array.length - 1; i += 2) {
-            if (array[i].compareTo(array[i + 1]) > 0) {
+            if (SortUtils.greater(array[i], array[i + 1])) {
                 SortUtils.swap(array, i, i + 1);
                 sorted = false;
             }
@@ -41,7 +41,7 @@ private <T extends Comparable<T>> boolean performOddSort(T[] array) {
     private <T extends Comparable<T>> boolean performEvenSort(T[] array) {
         boolean sorted = true;
         for (int i = 0; i < array.length - 1; i += 2) {
-            if (array[i].compareTo(array[i + 1]) > 0) {
+            if (SortUtils.greater(array[i], array[i + 1])) {
                 SortUtils.swap(array, i, i + 1);
                 sorted = false;
             }

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

@@ -21,7 +21,7 @@ public <T extends Comparable<T>> T[] sort(T[] array) {
     private static <T extends Comparable<T>> int findIndexOfMin(T[] array, final int startIndex) {
         int minIndex = startIndex;
         for (int i = startIndex + 1; i < array.length; i++) {
-            if (array[i].compareTo(array[minIndex]) < 0) {
+            if (SortUtils.less(array[i], array[minIndex])) {
                 minIndex = i;
             }
         }