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

dinishajais · DenizAltunkapan · web-flow · commit a8b579e293d5 · 2025-07-26T08:37:54.000Z
* Refactoring compareTo() to SortUtils methods

* Adding formatting

* Removed excess parenthesis

---------

Co-authored-by: Deniz Altunkapan &lt;93663085+DenizAltunkapan@users.noreply.github.com&gt;
diff --git a/src/main/java/com/thealgorithms/sorts/AdaptiveMergeSort.java b/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++];
diff --git a/src/main/java/com/thealgorithms/sorts/BinaryInsertionSort.java b/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;
diff --git a/src/main/java/com/thealgorithms/sorts/BitonicSort.java b/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);
diff --git a/src/main/java/com/thealgorithms/sorts/BucketSort.java b/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;
             }
         }
diff --git a/src/main/java/com/thealgorithms/sorts/CircleSort.java b/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;
         }
diff --git a/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java b/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 {
diff --git a/src/main/java/com/thealgorithms/sorts/ExchangeSort.java b/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);
                 }
             }
diff --git a/src/main/java/com/thealgorithms/sorts/IntrospectiveSort.java b/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) {
diff --git a/src/main/java/com/thealgorithms/sorts/OddEvenSort.java b/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;
             }
diff --git a/src/main/java/com/thealgorithms/sorts/SelectionSort.java b/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;
             }
         }
diff --git a/src/main/java/com/thealgorithms/sorts/SelectionSortRecursive.java b/src/main/java/com/thealgorithms/sorts/SelectionSortRecursive.java
@@ -56,6 +56,6 @@ private static <T extends Comparable<T>> int findMinIndex(T[] array, final int s
         final int minIndexInRest = findMinIndex(array, start + 1);
 
         // Return the index of the smaller element between array[start] and the minimum element in the rest of the array
-        return array[start].compareTo(array[minIndexInRest]) < 0 ? start : minIndexInRest;
+        return SortUtils.less(array[start], array[minIndexInRest]) ? start : minIndexInRest;
     }
 }
diff --git a/src/main/java/com/thealgorithms/sorts/StalinSort.java b/src/main/java/com/thealgorithms/sorts/StalinSort.java
@@ -8,7 +8,7 @@ public <T extends Comparable<T>> T[] sort(T[] array) {
         }
         int currentIndex = 0;
         for (int i = 1; i < array.length; i++) {
-            if (array[i].compareTo(array[currentIndex]) >= 0) {
+            if (SortUtils.greaterOrEqual(array[i], array[currentIndex])) {
                 currentIndex++;
                 array[currentIndex] = array[i];
             }

Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ private <T extends Comparable<T>> int hash(final T element, final T min, final T`
`111`	`111`	`private <T extends Comparable<T>> T findMin(T[] array) {`
`112`	`112`	`T min = array[0];`
`113`	`113`	`for (T element : array) {`
`114`		`- if (element.compareTo(min) < 0) {`
	`114`	`+ if (SortUtils.less(element, min)) {`
`115`	`115`	`min = element;`
`116`	`116`	`}`
`117`	`117`	`}`
`@@ -121,7 +121,7 @@ private <T extends Comparable<T>> T findMin(T[] array) {`
`121`	`121`	`private <T extends Comparable<T>> T findMax(T[] array) {`
`122`	`122`	`T max = array[0];`
`123`	`123`	`for (T element : array) {`
`124`		`- if (element.compareTo(max) > 0) {`
	`124`	`+ if (SortUtils.greater(element, max)) {`
`125`	`125`	`max = element;`
`126`	`126`	`}`
`127`	`127`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,15 +36,15 @@ private <T extends Comparable<T>> boolean doSort(final T[] array, final int left`
`36`	`36`	`int high = right;`
`37`	`37`
`38`	`38`	`while (low < high) {`
`39`		`- if (array[low].compareTo(array[high]) > 0) {`
	`39`	`+ if (SortUtils.greater(array[low], array[high])) {`
`40`	`40`	`SortUtils.swap(array, low, high);`
`41`	`41`	`swapped = true;`
`42`	`42`	`}`
`43`	`43`	`low++;`
`44`	`44`	`high--;`
`45`	`45`	`}`
`46`	`46`
`47`		`- if (low == high && array[low].compareTo(array[high + 1]) > 0) {`
	`47`	`+ if (low == high && SortUtils.greater(array[low], array[high + 1])) {`
`48`	`48`	`SortUtils.swap(array, low, high + 1);`
`49`	`49`	`swapped = true;`
`50`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ class ExchangeSort implements SortAlgorithm {`
`31`	`31`	`public <T extends Comparable<T>> T[] sort(T[] array) {`
`32`	`32`	`for (int i = 0; i < array.length - 1; i++) {`
`33`	`33`	`for (int j = i + 1; j < array.length; j++) {`
`34`		`- if (array[i].compareTo(array[j]) > 0) {`
	`34`	`+ if (SortUtils.greater(array[i], array[j])) {`
`35`	`35`	`SortUtils.swap(array, i, j);`
`36`	`36`	`}`
`37`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ public <T extends Comparable<T>> T[] sort(T[] array) {`
`21`	`21`	`private static <T extends Comparable<T>> int findIndexOfMin(T[] array, final int startIndex) {`
`22`	`22`	`int minIndex = startIndex;`
`23`	`23`	`for (int i = startIndex + 1; i < array.length; i++) {`
`24`		`- if (array[i].compareTo(array[minIndex]) < 0) {`
	`24`	`+ if (SortUtils.less(array[i], array[minIndex])) {`
`25`	`25`	`minIndex = i;`
`26`	`26`	`}`
`27`	`27`	`}`