# Техническое задание: сортировка по чётным значениям

## Задача

Дополнить существующую сортировку слиянием специальной стратегией `EvenOnlyMergeSortStrategy`.

Стратегия должна сортировать только объекты, у которых выбранное числовое поле имеет чётное значение. Объекты с нечётным значением должны сохранять свои исходные позиции.

## Контракты

1. Стратегия должна реализовывать существующий интерфейс:

```java
SortStrategy<T>
```

1. Метод сортировки должен работать с:

```java
MyList<T>
```

1. Для сортировки чётных элементов использовать алгоритм **Merge Sort**.

2. Готовые методы сортировки Java использовать запрещено.

3. Стратегия не должна зависеть непосредственно от класса `Student`.

4. Числовое поле передавать в стратегию извне через:

```java
ToIntFunction<T>
```

1. Сохранить переданный `ToIntFunction<T>` во внутреннем поле стратегии.

2. Для определения чётности элемента использовать:

```java
valueExtractor.applyAsInt(element)
```

1. `ToIntFunction<T>` используется только для получения числового значения выбранного поля. Стратегия не должна знать, какое именно поле объекта используется.

2. Для `Student` в качестве числового поля используется:

```java
Student::getRecordBookNumber
```

 1. `getRecordBookNumber()` должен возвращать `int`.

## Правила алгоритма

Стратегия должна:

1. Пройти по исходной `MyList<T>`.
2. Определить элементы с чётным значением, используя `ToIntFunction<T>`.
3. Запомнить позиции этих элементов.
4. Отдельно отсортировать только чётные элементы с помощью **Merge Sort** и переданного `Comparator<T>`.
5. Вернуть отсортированные чётные элементы на позиции, которые занимали чётные элементы до сортировки.
6. Не изменять позиции элементов с нечётным значением.
7. Не изменять размер коллекции.

### Пример

Исходные значения выбранного числового поля:

```text
[7, 8, 3, 2, 5, 4]
```

Чётные элементы:

```text
8, 2, 4
```

После Merge Sort:

```text
2, 4, 8
```

Результат:

```text
[7, 2, 3, 4, 5, 8]
```

Нечётные элементы `7`, `3`, `5` остались на исходных позициях.

## Пример использования

```java
SortStrategy<Student> strategy =
        new EvenOnlyMergeSortStrategy<>(
                Student::getRecordBookNumber
        );

strategy.sort(
        students,
        new StudentRecordBookComparator()
);
```

Стратегия получает функцию выбора числового поля извне и не содержит логики, специфичной для `Student`.

## Примеры тестов

### Обычный случай

Создать студентов с `recordBookNumber`:

```text
7, 8, 3, 2, 5, 4
```

После сортировки ожидается:

```text
7, 2, 3, 4, 5, 8
```

Проверить:

- нечётные элементы сохранили свои позиции;
- чётные элементы отсортированы по возрастанию;
- количество элементов не изменилось.

### Все значения нечётные

```text
1, 3, 5, 7
```

Ожидаемый результат:

```text
1, 3, 5, 7
```

### Все значения чётные

```text
8, 2, 6, 4
```

Ожидаемый результат:

```text
2, 4, 6, 8
```

### Один элемент

```text
4
```

Ожидаемый результат:

```text
4
```

### Пустая коллекция

Пустая коллекция должна остаться пустой и не приводить к ошибке.

### Проверка `ToIntFunction`

Передать:

```java
Student::getRecordBookNumber
```

и проверить, что именно `recordBookNumber` используется для определения чётности.

## Ограничения

Запрещено:

- использовать `Arrays.sort()`, `Collections.sort()`, `List.sort()` и другие готовые алгоритмы сортировки;
- перемещать элементы с нечётным значением;
- использовать отдельный алгоритм сортировки вместо Merge Sort;
- напрямую обращаться к полям `Student` внутри `EvenOnlyMergeSortStrategy`;
- выбирать поле через `if` или `switch`;
- использовать стандартные коллекции Java в качестве основной коллекции.

## Результат

Реализовать:

```text
EvenOnlyMergeSortStrategy.java
```

Класс должен использовать:

```text
SortStrategy.java
MyList.java
ToIntFunction<T>
Comparator<T>
```

и не должен иметь зависимости от конкретного класса `Student`.