题目

给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

• 来源：力扣（LeetCode）
• 链接：leetcode.cn/problems/ma…
• 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解法一

思路

• 排序

代码一

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

复杂度

• 时间复杂度：O(nlogn)
• 空间复杂度：O(logn)

解法二

思路

• HashMap

代码

    public int majorityElement(int[] nums) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int num : nums) {
            Integer count = map.get(num);
            if (count == null) {
                count = 1;
            } else {
                count++;
            }
            map.put(num, count);
            if (count > nums.length / 2) {
                return num;
            }
        }
        return -1;
    }

复杂度

• 时间复杂度：O(n)
• 空间复杂度：O(n)

解法三

思路

• 分治法

代码

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

    private int getMajority(int[] nums, int left, int right) {
        if (left == right) {
            return nums[left];
        }
        int mid = left + (right - left) / 2;
        int leftMajority = getMajority(nums, left, mid);
        int rightMajority = getMajority(nums, mid + 1, right);
        if (leftMajority == rightMajority) {
            return leftMajority;
        }
        int leftCount = 0, rightCount = 0;
        for (int i = left; i <= right; i++) {
            if (nums[i] == leftMajority) {
                leftCount++;
            }
            if (nums[i] == rightMajority) {
                rightCount++;
            }
        }
        return leftCount > rightCount ? leftMajority : rightMajority;
    }

复杂度

• 时间复杂度：O(nlogn)
• 空间复杂度：O(logn)

解法四

思路

• 投票法

代码

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

复杂度

• 时间复杂度：O(n)
• 空间复杂度：O(1)