Removed excess parenthesis

Author: dinishajais

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) -> (SortUtils.less(a, b)) : (a, b) -> (SortUtils.greater(a, b));
+            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/CircleSort.java

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

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

@@ -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 && (SortUtils.greater(array[j], key))) {
+            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 && (SortUtils.greater(array[low + left], array[low + largest]))) {
+        if (left < n && SortUtils.greater(array[low + left], array[low + largest])) {
             largest = left;
         }
-        if (right < n && (SortUtils.greater(array[low + right], array[low + largest]))) {
+        if (right < n && SortUtils.greater(array[low + right], array[low + largest])) {
             largest = right;
         }
         if (largest != i) {

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 (SortUtils.less(array[start], array[minIndexInRest])) ? start : minIndexInRest;
+        return SortUtils.less(array[start], array[minIndexInRest]) ? start : minIndexInRest;
     }
 }