feat(sorting): add even-only merge sort strategy

2026-08-27 01:14:23 +03:00
parent a7a253d726
commit 4794f03f3c
1 changed files with 128 additions and 0 deletions
@@ -0,0 +1,128 @@
 package ru.project.sorting;
 import ru.project.collection.MyList;
 import java.util.Comparator;
 import java.util.function.ToIntFunction;
 public class EvenOnlyMergeSortStrategy<T> implements SortStrategy<T> {
    private final ToIntFunction<T> valueExtractor;
    public EvenOnlyMergeSortStrategy(ToIntFunction<T> valueExtractor) {
        this.valueExtractor = valueExtractor;
    }
    @Override
    public void sort(MyList<T> list, Comparator<T> comparator) {
        if (list == null || list.size() <= 1) {
            return;
        }
        int evenCount = 0;
        for (int i = 0; i < list.size(); i++) {
            T element = list.get(i);
            if (valueExtractor.applyAsInt(element) % 2 == 0) {
                evenCount++;
            }
        }
        if (evenCount <= 1) {
            return;
        }
        @SuppressWarnings("unchecked")
        T[] evenElements = (T[]) new Object[evenCount];
        int[] evenIndexes = new int[evenCount];
        int evenIndex = 0;
        for (int i = 0; i < list.size(); i++) {
            T element = list.get(i);
            if (valueExtractor.applyAsInt(element) % 2 == 0) {
                evenElements[evenIndex] = element;
                evenIndexes[evenIndex] = i;
                evenIndex++;
            }
        }
        mergeSort(evenElements, 0, evenElements.length - 1, comparator);
        for (int i = 0; i < evenIndexes.length; i++) {
            list.set(evenIndexes[i], evenElements[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++;
        }
    }
 }