给你一个下标从 0 开始的数组 nums ，该数组由 n 个正整数组成。

    如果满足下述条件，则数组 nums 是一个 交替数组 ：

    nums[i - 2] == nums[i] ，其中 2 <= i <= n - 1 。
    nums[i - 1] != nums[i] ，其中 1 <= i <= n - 1 。
    在一步 操作 中，你可以选择下标 i 并将 nums[i] 更改 为 任一 正整数。

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

    示例 1：

    输入：nums = [3,1,3,2,4,3]
    输出：3
    解释：
    使数组变成交替数组的方法之一是将该数组转换为 [3,1,3,1,3,1] 。
    在这种情况下，操作数为 3 。
    可以证明，操作数少于 3 的情况下，无法使数组变成交替数组。
    示例 2：

    输入：nums = [1,2,2,2,2]
    输出：2
    解释：
    使数组变成交替数组的方法之一是将该数组转换为 [1,2,1,2,1].
    在这种情况下，操作数为 2 。
    注意，数组不能转换成 [2,2,2,2,2] 。因为在这种情况下，nums[0] == nums[1]，不满足交替数组的条件。

    提示：

    1 <= nums.length <= 105
    1 <= nums[i] <= 105

    1. class Solution {
    2.     //找到奇偶下标对应的最高频率和次高频率,剩下的用他们替换
    3.     public int minimumOperations(int[] nums) {
    4.         int n = nums.length;
    5.         if (n == 1) return 0;
    6.         Map<Integer,Integer> map1 = new HashMap(), map2 = new HashMap();
    7.         for (int i = 0; i < n; ++i) 
    8.             if (i % 2 == 0) map1.put(nums[i],map1.getOrDefault(nums[i],0) + 1);
    9.             else map2.put(nums[i],map2.getOrDefault(nums[i],0) + 1);
    10.         int aa = 0, bb = 0, a1 = 0, a2 = 0, b1 = 0, b2 = 0;
    11.         //分别找奇偶下标的最多和次多数
    12.         for (Map.Entry<Integer,Integer> entry : map1.entrySet()) {
    13.             if (entry.getValue() > a1) {
    14.                 aa = entry.getKey();
    15.                 a2 = a1;
    16.                 a1 = entry.getValue();
    17.             } else if (entry.getValue() > a2) 
    18.                 a2 = entry.getValue(); 
    19.         }
    20.         for (Map.Entry<Integer,Integer> entry : map2.entrySet()) {
    21.             if (entry.getValue() > b1) {
    22.                 bb = entry.getKey();
    23.                 b2 = b1;
    24.                 b1 = entry.getValue();
    25.             } else if (entry.getValue() > b2) 
    26.                 b2 = entry.getValue();
    27.         }
    28.         //如果不等就直接返回
    29.         if (aa != bb) return n - a1 - b1;
    30.         //相等就取保留的最大值
    31.         else return n - Math.max(a1 + b2, b1 + a2);
    32.     }
    33. }