【leetcode-摩尔投票法】求众数

最新推荐文章于 2021-10-23 13:17:01 发布

Hung武

最新推荐文章于 2021-10-23 13:17:01 发布

阅读量235

点赞数

分类专栏： leetcode

本文链接：https://blog.youkuaiyun.com/qq_31478771/article/details/115577211

版权

leetcode 专栏收录该内容

87 篇文章

订阅专栏

本文介绍了几种有效的算法来寻找数组中的众数，包括哈希表、排序、分治及Boyer-Moore投票算法等方法，并针对不同情况提供了具体实现案例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

求众数1

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1：
输入：[3,2,3]
输出：3

示例 2：
输入：[2,2,1,1,1,2,2]
输出：2

哈希表

class Solution {
    public int majorityElement(int[] nums) {
        int len = nums.length;
        Map<Integer, Integer> map = new HashMap<>();
        int count;
        for (int n : nums) {
            count = map.getOrDefault(n, 0);
            if (count >= len / 2)
                return n;
            map.put(n, count + 1);
        }
        return nums[0];
    }
}

排序

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

分治

class Solution {
    private int countInRange(int[] nums, int target, int start, int end) {
        int count = 0;
        for (int i = start; i <= end; i++) {
            if (nums[i] == target) 
                count++;
        }
        return count;
    }

    private int majorityElementRec(int[] nums, int low, int high) {
        if (low == high)
            return nums[low];

        int mid = (high - low) / 2 + low;
        int left = majorityElementRec(nums, low, mid);
        int right = majorityElementRec(nums, mid + 1, high);

        if (left == right)
            return left;

        int leftCount = countInRange(nums, left, low, high);
        int rightCount = countInRange(nums, right, low, high);

        return leftCount > rightCount ? left : right;
    }

    public int majorityElement(int[] nums) {
        return majorityElementRec(nums, 0, nums.length - 1);
    }
}

Boyer-Moore 投票算法

如果我们把众数记为 +1，把其他数记为 -1，将它们全部加起来，显然和大于 0，从结果本身我们可以看出众数比其他数多。
在这里插入图片描述

class Solution {
    public int majorityElement(int[] nums) {
        int count = 0;
        int len = nums.length;
        int candidate = nums[0];
        for (int num : nums) {
            if (count == 0)
                candidate = num;
            count += (num == candidate) ? 1 : -1;
        }
        return candidate;
    }
}

求众数2

给定一个大小为 n 的整数数组，找出其中所有出现超过 ⌊ n/3 ⌋ 次的元素。
进阶：尝试设计时间复杂度为 O(n)、空间复杂度为 O(1)的算法解决此问题。

示例 1：
输入：[3,2,3]
输出：[3]

示例 2：
输入：nums = [1]
输出：[1]

示例 3：
输入：[1,1,1,3,3,2,2,2]
输出：[1,2]

哈希表

class Solution {
    public List<Integer> majorityElement(int[] nums) {
        int threshold = nums.length / 3;
        Map<Integer, Integer> map = new HashMap<>();
        for (int num : nums)
            map.put(num, map.getOrDefault(num, 0) + 1);
        List<Integer> result = new ArrayList<>();
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            if (entry.getValue() > threshold)
                result.add(entry.getKey());
        }
        return result;
    }
}

Boyer-Moore 投票算法

class Solution {
    public List<Integer> majorityElement(int[] nums) {
        int cand1 = nums[0], cand2 = nums[0];
        int count1 = 0, count2 = 0;
        for (int num : nums) {
            if (cand1 == num) {
                count1++;
            } else if (cand2 == num) {
                count2++;
            } else if (count1 == 0) {
                cand1 = num;
                count1 = 1;
            } else if (count2 == 0) {
                cand2 = num;
                count2 = 1;
            } else {
                count1--;
                count2--;
            }
        }
        
        List<Integer> result = new ArrayList<>();
        count1 = 0; count2 = 0;
        for (int num : nums) {
            if (num == cand1)
                count1++;
            else if (num == cand2)
                count2++;
        }

        if (count1 > nums.length / 3)
            result.add(cand1);
        if (count2 > nums.length / 3)
            result.add(cand2);

        return result;
    }
}