排序题目：多数元素

题目

标题和出处

标题：多数元素

出处：169. 多数元素

难度

2 级

题目描述

要求

给定大小为 $\text{n}$ 的数组 $\text{nums}$，返回其中的多数元素。

多数元素是指在数组中出现次数大于 $\lfloor \frac{\text{n}}{\text{2}}\rfloor$ 的元素。可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例

示例 1：

输入：$\text{nums = [3,2,3]}$
输出：$\text{3}$

示例 2：

输入：$\text{nums = [2,2,1,1,1,2,2]}$
输出：$\text{2}$

数据范围

• $\text{n}=\text{nums.length}$
• $\text{1}\le \text{n}\le \text{5}\times {\text{10}}^{\text{4}}$
• ${\text{-10}}^{\text{9}}\le \text{nums[i]}\le {\text{10}}^{\text{9}}$

进阶

你可以使用线性时间复杂度和 $\text{O(1)}$ 空间复杂度解决此问题吗？

解法一

思路和算法

最直观的解法是统计数组中每个元素的出现次数，然后寻找出现次数大于 $\lfloor \frac{n}{2}\rfloor$ 的元素。

遍历数组，使用哈希表记录每个元素的出现次数，遍历结束之后即可得到数组中每个元素的出现次数。然后遍历哈希表，对于哈希表中的每个元素得到出现次数，返回出现次数大于 $\lfloor \frac{n}{2}\rfloor$ 的元素。

代码

class Solution {
    public int majorityElement(int[] nums) {
        Map<Integer, Integer> counts = new HashMap<Integer, Integer>();
        for (int num : nums) {
            counts.put(num, counts.getOrDefault(num, 0) + 1);
        }
        int majority = 0;
        int n = nums.length;
        Set<Integer> set = counts.keySet();
        for (int num : set) {
            if (counts.get(num) > n / 2) {
                majority = num;
                break;
            }
        }
        return majority;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。遍历数组统计每个元素的出现次数需要 $O(n)$ 的时间，遍历哈希表得到多数元素也需要 $O(n)$ 的时间。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。需要创建哈希表记录每个元素的出现次数，哈希表中的元素个数不超过 $n$。

解法二

思路和算法

另一个解法是将数组排序后得到多数元素。排序后的数组满足相等的元素一定出现在数组中的相邻位置，由于多数元素在数组中的出现次数大于 $\lfloor \frac{n}{2}\rfloor$，因此排序后的数组中存在至少 $\lfloor \frac{n}{2}\rfloor +1$ 个连续的元素都是多数元素，下标 $\lfloor \frac{n}{2}\rfloor$ 的元素一定是多数元素。理由如下：

• 如果多数元素是数组中的最小元素，则排序后的数组从下标 $0$ 到下标 $\lfloor \frac{n}{2}\rfloor$ 的元素都是多数元素；

• 如果多数元素是数组中的最大元素，则排序后的数组从下标 $\lfloor \frac{n}{2}\rfloor$ 到下标 $n-1$ 的元素都是多数元素；

• 如果多数元素不是数组中的最小元素和最大元素，则排序后的数组的下标 $0$ 和下标 $n-1$ 的元素都不是多数元素，多数元素的开始下标一定小于 $\lfloor \frac{n}{2}\rfloor$，结束下标一定大于 $\lfloor \frac{n}{2}\rfloor$，下标 $\lfloor \frac{n}{2}\rfloor$ 的元素一定是多数元素。

因此将数组排序之后返回下标 $\lfloor \frac{n}{2}\rfloor$ 的元素即可。

代码

class Solution {
    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        int n = nums.length;
        return nums[n / 2];
    }
}

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。排序需要 $O(n\log n)$ 的时间。

• 空间复杂度：$O(\log n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。排序需要 $O(\log n)$ 的递归调用栈空间。

解法三

思路和算法

寻找多数元素的另一种解法是摩尔投票算法，其时间复杂度是 $O(n)$，空间复杂度是 $O(1)$。

摩尔投票算法由 Robert S. Boyer 和 J Strother Moore 提出，该算法的基本思想是：在每一轮投票过程中，从数组中删除两个不同的元素，直到投票过程无法继续，此时数组为空或者数组中剩下的元素都相等。

摩尔投票算法的具体做法如下。

1. 维护多数元素 $\text{majority}$ 和多数元素的出现次数 $\text{count}$，初始时 $\text{majority}$ 为数组的首个元素，$\text{count}=1$。

2. 遍历数组中除了首个元素以外的所有元素，当遍历到元素 $\text{num}$ 时，执行如下操作。

   1. 如果 $\text{count}=0$，则将 $\text{majority}$ 的值更新为 $\text{num}$，否则不更新 $\text{majority}$ 的值。

   2. 如果 $\text{num}=\text{majority}$，则将 $\text{count}$ 加 $1$，否则将 $\text{count}$ 减 $1$。

由于这道题中多数元素总是存在，因此遍历结束之后，$\text{majority}$ 即为多数元素。

如果不保证多数元素一定存在，则当多数元素不存在时，遍历结束之后的 $\text{majority}$ 可能为数组中的任意一个元素。此时需要再次遍历数组，统计 $\text{majority}$ 在数组中的出现次数，当 $\text{majority}$ 的出现次数大于 $\lfloor \frac{n}{2}\rfloor$ 时 $\text{majority}$ 是多数元素，当 $\text{majority}$ 的出现次数小于等于 $\lfloor \frac{n}{2}\rfloor$ 时没有多数元素。

考虑示例 1，$\text{nums}=[3,2,3]$，使用摩尔投票算法寻找多数元素的过程如下。

1. 初始化 $\text{majority}=\text{nums}[0]=3$，$\text{count}=1$。

2. 遍历到 $\text{nums}[1]=2$。

   1. 由于 $\text{count}=1$，因此不更新 $\text{majority}$ 的值。

   2. 由于当前元素不等于 $\text{majority}$，因此将 $\text{count}$ 减 $1$，$\text{count}$ 变成 $0$。

3. 遍历到 $\text{nums}[2]=3$。

   1. 由于 $\text{count}=0$，因此将 $\text{majority}$ 的值更新为当前元素 $3$。

   2. 由于当前元素等于 $\text{majority}$，因此将 $\text{count}$ 加 $1$，$\text{count}$ 变成 $1$。

4. 遍历结束，$\text{majority}=3$，多数元素是 $3$。

代码

class Solution {
    public int majorityElement(int[] nums) {
        int majority = nums[0];
        int count = 1;
        int n = nums.length;
        for (int i = 1; i < n; i++) {
            int num = nums[i];
            if (count == 0) {
                majority = num;
            }
            if (num == majority) {
                count++;
            } else {
                count--;
            }
        }
        return majority;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。需要遍历数组 $\text{nums}$ 一次。

• 空间复杂度：$O(1)$。