使数组变成交替数组的最少操作数

/*
 * Using Java Stream API, the problem is solved similarly to the Java solution.
 * We compute the frequency of numbers at even and odd indices using streams.
 * Then we determine the most frequent elements and calculate the minimum operations.
 */
import java.util.*;
import java.util.stream.*;

public class SolutionStream {
    public int minimumOperations(int[] nums) {
        int n = nums.length;

        Map<Integer, Long> evenFreq = IntStream.range(0, n).filter(i -> i % 2 == 0)
                .mapToObj(i -> nums[i])
                .collect(Collectors.groupingBy(e -> e, Collectors.counting()));

        Map<Integer, Long> oddFreq = IntStream.range(0, n).filter(i -> i % 2 != 0)
                .mapToObj(i -> nums[i])
                .collect(Collectors.groupingBy(e -> e, Collectors.counting()));

        int[] evenTop = getTopTwo(evenFreq);
        int[] oddTop = getTopTwo(oddFreq);

        if (evenTop[0] != oddTop[0]) {
            return (n / 2 - evenTop[1]) + (n - n / 2 - oddTop[1]);
        } else {
            return Math.min((n / 2 - evenTop[1]) + (n - n / 2 - oddTop[2]),
                            (n / 2 - evenTop[2]) + (n - n / 2 - oddTop[1]));
        }
    }

    private int[] getTopTwo(Map<Integer, Long> freq) {
        int first = 0, second = 0;
        long firstCount = 0, secondCount = 0;
        for (Map.Entry<Integer, Long> entry : freq.entrySet()) {
            int num = entry.getKey();
            long count = entry.getValue();
            if (count > firstCount) {
                second = first;
                secondCount = firstCount;
                first = num;
                firstCount = count;
            } else if (count > secondCount) {
                second = num;
                secondCount = count;
            }
        }
        return new int[]{first, (int) firstCount, second, (int) secondCount};
    }
}