伟大的车尔尼

伟大的车尔尼

关注
发信
关注(28)粉丝(399)

排序题目：多数元素 II

题目

标题和出处

标题：多数元素 II

出处：229. 多数元素 II

难度

3 级

题目描述

要求

给定大小为 n \texttt{n} n 的数组 nums \texttt{nums} nums，找出其中所有出现超过 ⌊ n 3 ⌋ \Big\lfloor \dfrac{\texttt{n}}{\texttt{3}} \Big\rfloor ⌊3n​⌋ 次的元素。

示例

示例 1：

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

示例 2：

输入： nums   =   [1] \texttt{nums = [1]} nums = [1]
输出： [1] \texttt{[1]} [1]

示例 3：

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

数据范围

  • n = nums.length \texttt{n} = \texttt{nums.length} n=nums.length
  • 1 ≤ n ≤ 5 × 10 4 \texttt{1} \le \texttt{n} \le \texttt{5} \times \texttt{10}^\texttt{4} 1≤n≤5×104
  • -10 9 ≤ nums[i] ≤ 10 9 \texttt{-10}^\texttt{9} \le \texttt{nums[i]} \le \texttt{10}^\texttt{9} -109≤nums[i]≤109

进阶

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

前言

这道题是「多数元素」的进阶，要求找出数组中所有出现次数大于 ⌊ n 3 ⌋ \Big\lfloor \dfrac{n}{3} \Big\rfloor ⌊3n​⌋ 的元素。这道题也可以使用哈希表计数、排序和摩尔投票三种解法得到答案。

长度是 n n n 的数组中，最多有 2 2 2 个出现次数大于 ⌊ n 3 ⌋ \Big\lfloor \dfrac{n}{3} \Big\rfloor ⌊3n​⌋ 的元素。可以使用反证法证明。

假设有 3 3 3 个出现次数大于 ⌊ n 3 ⌋ \Big\lfloor \dfrac{n}{3} \Big\rfloor ⌊3n​⌋ 的元素，这 3 3 3 个元素的出现次数都不小于 ⌊ n 3 ⌋ + 1 \Big\lfloor \dfrac{n}{3} \Big\rfloor + 1 ⌊3n​⌋+1，因此这 3 3 3 个元素的总出现次数至少为 3 × ⌊ n 3 ⌋ + 3 3 \times \Big\lfloor \dfrac{n}{3} \Big\rfloor + 3 3×⌊3n​⌋+3。由于 ⌊ n 3 ⌋ > n 3 − 1 \Big\lfloor \dfrac{n}{3} \Big\rfloor > \dfrac{n}{3} - 1 ⌊3n​⌋>3n​−1，因此 3 × ⌊ n 3 ⌋ + 3 > 3 × ( n 3 − 1 ) + 3 = 3 × n 3 − 3 + 3 = n 3 \times \Big\lfloor \dfrac{n}{3} \Big\rfloor + 3 > 3 \times (\dfrac{n}{3} - 1) + 3 = 3 \times \dfrac{n}{3} - 3 + 3 = n 3×⌊3n​⌋+3>3×(3n​−1)+3=3×3n​−3+3=n，即这 3 3 3 个元素的总出现次数一定超过 n n n，和数组长度是 n n n 矛盾。因此数组中不可能有 3 3 3 个出现次数大于 ⌊ n 3 ⌋ \Big\lfloor \dfrac{n}{3} \Big\rfloor ⌊3n​⌋ 的元素，最多有 2 2 2 个出现次数大于 ⌊ n 3 ⌋ \Big\lfloor \dfrac{n}{3} \Big\rfloor ⌊3n​⌋ 的元素。

解法一

思路和算法

最直观的解法是统计数组中每个元素的出现次数，然后寻找出现次数大于 ⌊ n 3 ⌋ \Big\lfloor \dfrac{n}{3} \Big\rfloor ⌊3n​⌋ 的元素。

遍历数组，使用哈希表记录每个元素的出现次数，遍历结束之后即可得到数组中每个元素的出现次数。然后遍历哈希表，对于哈希表中的每个元素得到出现次数，将出现次数大于 ⌊ n 3 ⌋ \Big\lfloor \dfrac{n}{3} \Big\rfloor ⌊3n​⌋ 的元素添加到结果中。

代码

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

复杂度分析

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

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

解法二

思路和算法

首先将数组排序，排序后的数组满足相等的元素一定出现在数组中的相邻位置。如果一个元素在数组中的出现次数大于 ⌊ n 3 ⌋ \Big\lfloor \dfrac{n}{3} \Big\rfloor ⌊3n​⌋，则排序后的数组中存在至少 ⌊ n 3 ⌋ + 1 \Big\lfloor \dfrac{n}{3} \Big\rfloor + 1 ⌊3n​⌋+1 个连续的元素都等于该元素，即一定存在两个差为 ⌊ n 3 ⌋ \Big\lfloor \dfrac{n}{3} \Big\rfloor ⌊3n​⌋ 的下标处的元素都等于该元素。

将数组 nums \textit{nums} nums 排序之后遍历数组 nums \textit{nums} nums，对于下标 i i i，当 i ≥ ⌊ n 3 ⌋ i \ge \Big\lfloor \dfrac{n}{3} \Big\rfloor i≥⌊3n​⌋ 时，如果 nums [ i ] = nums [ i − ⌊ n 3 ⌋ ] \textit{nums}[i] = \textit{nums}[i - \Big\lfloor \dfrac{n}{3} \Big\rfloor] nums[i]=nums[i−⌊3n​⌋]，则 nums [ i ] \textit{nums}[i] nums[i] 是出现次数大于 ⌊ n 3 ⌋ \Big\lfloor \dfrac{n}{3} \Big\rfloor ⌊3n​⌋ 的元素。

为了避免重复计算，当 i < n − 1 i < n - 1 i<n−1 且 nums [ i ] = nums [ i + 1 ] \textit{nums}[i] = \textit{nums}[i + 1] nums[i]=nums[i+1] 时跳过下标 i i i，只有当下标 i i i 的右侧没有与 nums [ i ] \textit{nums}[i] nums[i] 相等的元素时才判断 nums [ i ] = nums [ i − ⌊ n 3 ⌋ ] \textit{nums}[i] = \textit{nums}[i - \Big\lfloor \dfrac{n}{3} \Big\rfloor] nums[i]=nums[i−⌊3n​⌋] 是否成立，如果成立则将 nums [ i ] \textit{nums}[i] nums[i] 添加到结果中。

代码

class Solution {
    public List<Integer> majorityElement(int[] nums) {
        Arrays.sort(nums);
        List<Integer> majorities = new ArrayList<Integer>();
        int n = nums.length;
        for (int i = n / 3; i < n; i++) {
            int num = nums[i];
            if (i < n - 1 && num == nums[i + 1]) {
                continue;
            }
            if (num == nums[i - n / 3]) {
                majorities.add(num);
            }
        }
        return majorities;
    }
}

复杂度分析

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

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

解法三

思路和算法

原始的摩尔投票算法用于找到出现次数大于一半的元素，其时间复杂度是 O ( n ) O(n) O(n)，空间复杂度是 O ( 1 ) O(1) O(1)。摩尔投票算法可以推广到寻找出现次数大于 ⌊ n k ⌋ \Big\lfloor \dfrac{n}{k} \Big\rfloor ⌊kn​⌋ 的元素，其中 k k k 是大于 1 1 1 的正整数。

由于出现次数大于 ⌊ n 3 ⌋ \Big\lfloor \dfrac{n}{3} \Big\rfloor ⌊3n​⌋ 的元素不可能超过 2 2 2 个，因此维护 2 2 2 个候选元素 majority 1 \textit{majority}_1 majority1​ 和 majority 2 \textit{majority}_2 majority2​，以及两个候选元素的出现次数 count 1 \textit{count}_1 count1​ 和 count 2 \textit{count}_2 count2​，初始时候选元素和出现次数都是 0 0 0。

遍历数组，当遍历到元素 num \textit{num} num 时，执行如下操作。

  1. 比较 num \textit{num} num 是否和候选元素相等，如果相等则将相应的出现次数加 1 1 1。

    1. 如果 num = majority 1 \textit{num} = \textit{majority}_1 num=majority1​，则将 count 1 \textit{count}_1 count1​ 加 1 1 1。

    2. 否则，如果 num = majority 2 \textit{num} = \textit{majority}_2 num=majority2​，则将 count 2 \textit{count}_2 count2​ 加 1 1 1。

  2. 如果 num \textit{num} num 和两个候选元素都不相等，则判断两个候选元素的出现次数是否为 0 0 0，如果为 0 0 0 则更新候选元素和出现次数。

    1. 如果 count 1 = 0 \textit{count}_1 = 0 count1​=0，则将 majority 1 \textit{majority}_1 majority1​ 更新为 num \textit{num} num，并将 count 1 \textit{count}_1 count1​ 加 1 1 1。

    2. 否则，如果 count 2 = 0 \textit{count}_2 = 0 count2​=0，则将 majority 2 \textit{majority}_2 majority2​ 更新为 num \textit{num} num，并将 count 2 \textit{count}_2 count2​ 加 1 1 1。

  3. 如果 num \textit{num} num 和两个候选元素都不相等且两个候选元素的出现次数都大于 0 0 0，则 num \textit{num} num 和两个候选元素抵消，将 count 1 \textit{count}_1 count1​ 和 count 2 \textit{count}_2 count2​ 都减 1 1 1。

遍历结束之后，得到两个候选元素。再次遍历数组，统计两个候选元素在数组中的出现次数，当出现次数大于 ⌊ n 3 ⌋ \Big\lfloor \dfrac{n}{3} \Big\rfloor ⌊3n​⌋ 时将候选元素添加到结果中。

代码

class Solution {
    public List<Integer> majorityElement(int[] nums) {
        int majority1 = 0, majority2 = 0;
        int count1 = 0, count2 = 0;
        for (int num : nums) {
            if (num == majority1) {
                count1++;
            } else if (num == majority2) {
                count2++;
            } else if (count1 == 0) {
                majority1 = num;
                count1++;
            } else if (count2 == 0) {
                majority2 = num;
                count2++;
            } else {
                count1--;
                count2--;
            }
        }
        count1 = 0;
        count2 = 0;
        for (int num : nums) {
            if (num == majority1) {
                count1++;
            } else if (num == majority2) {
                count2++;
            }
        }
        List<Integer> majorities = new ArrayList<Integer>();
        int n = nums.length;
        if (count1 > n / 3) {
            majorities.add(majority1);
        }
        if (count2 > n / 3) {
            majorities.add(majority2);
        }
        return majorities;
    }
}

复杂度分析

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

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

07-01 23:02
Powered by LMLPHP ©2024 伟大的车尔尼 0.002366