refactor(sorting): reuse merge sort strategy

app/src/main/java/ru/project/sorting/EvenOnlyMergeSortStrategy.java

@@ -1,5 +1,6 @@
 package ru.project.sorting;
 
+import ru.project.collection.MyLinkedList;
 import ru.project.collection.MyList;
 
 import java.util.Comparator;
@@ -7,9 +8,11 @@ import java.util.function.ToIntFunction;
 
 public class EvenOnlyMergeSortStrategy<T> implements SortStrategy<T> {
     private final ToIntFunction<T> valueExtractor;
+    private final SortStrategy<T> mergeSortStrategy;
 
     public EvenOnlyMergeSortStrategy(ToIntFunction<T> valueExtractor) {
         this.valueExtractor = valueExtractor;
+        this.mergeSortStrategy = new MergeSortStrategy<>();
     }
 
     @Override
@@ -32,8 +35,7 @@ public class EvenOnlyMergeSortStrategy<T> implements SortStrategy<T> {
             return;
         }
 
-        @SuppressWarnings("unchecked")
+        MyList<T> evenElements = new MyLinkedList<>();
-        T[] evenElements = (T[]) new Object[evenCount];
 
         int[] evenIndexes = new int[evenCount];
 
@@ -43,85 +45,15 @@ public class EvenOnlyMergeSortStrategy<T> implements SortStrategy<T> {
             T element = list.get(i);
 
             if (valueExtractor.applyAsInt(element) % 2 == 0) {
-                evenElements[evenIndex] = element;
+                evenElements.add(element);
                 evenIndexes[evenIndex] = i;
                 evenIndex++;
             }
         }
-        mergeSort(evenElements, 0, evenElements.length - 1, comparator);
+        mergeSortStrategy.sort(evenElements, comparator);
 
         for (int i = 0; i < evenIndexes.length; i++) {
-            list.set(evenIndexes[i], evenElements[i]);
+            list.set(evenIndexes[i], evenElements.get(i));
-        }
-    }
-
-    private void mergeSort(
-            T[] elements,
-            int left,
-            int right,
-            Comparator<T> comparator
-    ) {
-        if (left >= right) {
-            return;
-        }
-
-        int mid = (left + right) / 2;
-
-        mergeSort(elements, left, mid, comparator);
-        mergeSort(elements, mid + 1, right, comparator);
-
-        merge(elements, left, mid, right, comparator);
-    }
-    private void merge(
-            T[] elements,
-            int left,
-            int mid,
-            int right,
-            Comparator<T> comparator
-    ) {
-        int leftSize = mid - left + 1;
-        int rightSize = right - mid;
-
-        @SuppressWarnings("unchecked")
-        T[] leftArray = (T[]) new Object[leftSize];
-
-        @SuppressWarnings("unchecked")
-        T[] rightArray = (T[]) new Object[rightSize];
-
-        for (int i = 0; i < leftSize; i++) {
-            leftArray[i] = elements[left + i];
-        }
-
-        for (int j = 0; j < rightSize; j++) {
-            rightArray[j] = elements[mid + 1 + j];
-        }
-
-        int i = 0;
-        int j = 0;
-        int k = left;
-
-        while (i < leftSize && j < rightSize) {
-            if (comparator.compare(leftArray[i], rightArray[j]) <= 0) {
-                elements[k] = leftArray[i];
-                i++;
-            } else {
-                elements[k] = rightArray[j];
-                j++;
-            }
-
-            k++;
-        }
-
-        while (i < leftSize) {
-            elements[k] = leftArray[i];
-            i++;
-            k++;
-        }
-
-        while (j < rightSize) {
-            elements[k] = rightArray[j];
-            j++;
-            k++;
         }
     }
 }