找出整型数组中占比超过一半的数｜ 豆包MarsCode AI 刷题

Java数组多数元素查找：算法设计与分析

一、问题背景

在数组处理中，找出占比超过数组一半的元素是一个经典的算法问题。本文将深入分析Java中解决此问题的多种算法，探讨其实现原理、时间复杂度和空间复杂度。

二、问题定义

多数元素（Majority Element）定义：在给定数组中，出现次数超过 ⌊n / 2⌋ 的元素，其中n为数组长度。

三、算法实现

1. 哈希表计数法

public class MajorityElementFinder {
    public int findMajorityElement(int[] nums) {
        // 使用HashMap统计元素出现次数
        Map<Integer, Integer> countMap = new HashMap<>();
        int threshold = nums.length / 2;

        for (int num : nums) {
            countMap.put(num, countMap.getOrDefault(num, 0) + 1);
            if (countMap.get(num) > threshold) {
                return num;
            }
        }

        return -1; // 未找到多数元素
    }
}

算法特点

• 时间复杂度：O(n)
• 空间复杂度：O(n)
• 优点：实现简单，逻辑清晰
• 缺点：额外空间开销较大

2. 摩尔投票算法（最优解）

public class MooreVotingAlgorithm {
    public int findMajorityElement(int[] nums) {
        int candidate = nums[0];
        int count = 1;

        for (int i = 1; i < nums.length; i++) {
            if (count == 0) {
                candidate = nums[i];
                count = 1;
            } else if (nums[i] == candidate) {
                count++;
            } else {
                count--;
            }
        }

        // 验证候选元素是否真的是多数元素
        return validateMajorityElement(nums, candidate);
    }

    private int validateMajorityElement(int[] nums, int candidate) {
        int count = 0;
        for (int num : nums) {
            if (num == candidate) {
                count++;
            }
        }
        return count > nums.length / 2 ? candidate : -1;
    }
}

算法原理

• 核心思想：相互抵消
• 时间复杂度：O(n)
• 空间复杂度：O(1)
• 优点：
  1. 空间复杂度最低
  2. 只需遍历两次数组
  3. 不需要额外数据结构

3. 分治算法实现

public class DivideConquerSolution {
    public int findMajorityElement(int[] nums) {
        return majorityElementRecursive(nums, 0, nums.length - 1);
    }

    private int majorityElementRecursive(int[] nums, int left, int right) {
        // 单个元素情况
        if (left == right) {
            return nums[left];
        }

        // 分治
        int mid = left + (right - left) / 2;
        int leftMajority = majorityElementRecursive(nums, left, mid);
        int rightMajority = majorityElementRecursive(nums, mid + 1, right);

        // 合并结果
        if (leftMajority == rightMajority) {
            return leftMajority;
        }

        int leftCount = countElementFrequency(nums, leftMajority, left, right);
        int rightCount = countElementFrequency(nums, rightMajority, left, right);

        return leftCount > rightCount ? leftMajority : rightMajority;
    }

    private int countElementFrequency(int[] nums, int element, int left, int right) {
        int count = 0;
        for (int i = left; i <= right; i++) {
            if (nums[i] == element) {
                count++;
            }
        }
        return count;
    }
}

算法特点

• 时间复杂度：O(n log n)
• 空间复杂度：O(log n)
• 优点：递归实现，思路清晰
• 缺点：性能略低于摩尔投票算法

四、算法性能对比

算法	时间复杂度	空间复杂度	实现难度
哈希表计数法	O(n)	O(n)	低
摩尔投票算法	O(n)	O(1)	中
分治算法	O(n log n)	O(log n)	高

五、应用场景与注意事项

1. 对于小规模数组，哈希表方法更直观
2. 大规模数据推荐使用摩尔投票算法
3. 需要额外验证多数元素的存在性
4. 注意处理无多数元素的边界情况

六. 实践建议

• 理解算法本质，而非死记硬背
• 根据具体场景选择最佳算法
• 注重代码的可读性和健壮性
• 必要时进行性能基准测试

结语

找出数组中的多数元素是一个经典算法问题，它体现了算法设计中的"分治"、"投票"等思想。通过对比不同算法，我们可以深入理解算法复杂度、空间利用和解题思路。