【LeetCode】19. Majority Element·多数元素

浅浅的花香味﹌ 2024-04-08 09:23 64阅读 0赞

> 活动地址：[CSDN21天学习挑战赛][CSDN21]

### 题目描述 ###

#### 英文版描述 ####

Given an array nums of size n, return the majority element. The majority element is the element that appears more than ⌊n / 2⌋ times. You may assume that the majority element always exists in the array.

#### 英文版地址 ####

https://leetcode.com/problems/majority-element/

#### 中文版描述 ####

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

示例 1：

输入：nums = \[3,2,3\]

输出：3

示例 2：

输入：nums = \[2,2,1,1,1,2,2\]

输出：2

提示：

*  n == nums.length
 *  1 <= n <= 5 \* 10^4
 *  \-10^9 <= nums\[i\] <= 10^9

#### 中文版地址 ####

https://leetcode.cn/problems/majority-element/

### 解题思路 ###

比较直接的想法是遍历数组，然后存进一个Map<数字，出现次数>，然后判断哪个出现次数大于数组长度的一半。 思考下如何优化？

*  添加判断，如果当前计数的数字已经大于或者等于数组长度的一半，就结束遍历

### 解题方法 ###

#### 俺这版 ####

![9719cfbee9524a8e35df2ee73c5cd6f3.png][]

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

**复杂度分析**

*  时间复杂度：O(n)，n是数组的长度，遍历数组并添加进Map，总体时长不会超过n
 *  空间复杂度：O(n)，n是数组的长度，遍历数组并添加进Map，Map所占空间不会超过n

### 官方版 ###

#### 方法一：哈希表 ####

class Solution {
        private Map<Integer, Integer> countNums(int[] nums) {
            Map<Integer, Integer> counts = new HashMap<Integer, Integer>();
            for (int num : nums) {
                if (!counts.containsKey(num)) {
                    counts.put(num, 1);
                } else {
                    counts.put(num, counts.get(num) + 1);
                }
            }
            return counts;
        }
    
        public int majorityElement(int[] nums) {
            Map<Integer, Integer> counts = countNums(nums);
    
            Map.Entry<Integer, Integer> majorityEntry = null;
            for (Map.Entry<Integer, Integer> entry : counts.entrySet()) {
                if (majorityEntry == null || entry.getValue() > majorityEntry.getValue()) {
                    majorityEntry = entry;
                }
            }
    
            return majorityEntry.getKey();
        }
    }

#### 方法二：排序 ####

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

#### 方法三：随机化 ####

由于一个给定的下标对应的数字很有可能是众数，我们随机挑选一个下标，检查它是否是众数，如果是就返回，否则继续随机挑选。

class Solution {
        private int randRange(Random rand, int min, int max) {
            return rand.nextInt(max - min) + min;
        }
    
        private int countOccurences(int[] nums, int num) {
            int count = 0;
            for (int i = 0; i < nums.length; i++) {
                if (nums[i] == num) {
                    count++;
                }
            }
            return count;
        }
    
        public int majorityElement(int[] nums) {
            Random rand = new Random();
    
            int majorityCount = nums.length / 2;
    
            while (true) {
                int candidate = nums[randRange(rand, 0, nums.length)];
                if (countOccurences(nums, candidate) > majorityCount) {
                    return candidate;
                }
            }
        }
    }

#### 方法四：分治 ####

使用经典的分治算法递归求解，直到所有的子问题都是长度为 1 的数组。长度为 1 的子数组中唯一的数显然是众数，直接返回即可。如果回溯后某区间的长度大于 1，我们必须将左右子区间的值合并。如果它们的众数相同，那么显然这一段区间的众数是它们相同的值。否则，我们需要比较两个众数在整个区间内出现的次数来决定该区间的众数。

class Solution {
        private int countInRange(int[] nums, int num, int lo, int hi) {
            int count = 0;
            for (int i = lo; i <= hi; i++) {
                if (nums[i] == num) {
                    count++;
                }
            }
            return count;
        }
    
        private int majorityElementRec(int[] nums, int lo, int hi) {
            // base case; the only element in an array of size 1 is the majority
            // element.
            if (lo == hi) {
                return nums[lo];
            }
    
            // recurse on left and right halves of this slice.
            int mid = (hi - lo) / 2 + lo;
            int left = majorityElementRec(nums, lo, mid);
            int right = majorityElementRec(nums, mid + 1, hi);
    
            // if the two halves agree on the majority element, return it.
            if (left == right) {
                return left;
            }
    
            // otherwise, count each element and return the "winner".
            int leftCount = countInRange(nums, left, lo, hi);
            int rightCount = countInRange(nums, right, lo, hi);
    
            return leftCount > rightCount ? left : right;
        }
    
        public int majorityElement(int[] nums) {
            return majorityElementRec(nums, 0, nums.length - 1);
        }
    }

#### 方法五：Boyer-Moore 投票算法 ####

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

### 总结 ###

这是我碰到官方提供方法最多的一次，，，没有之一=\[,,\_,,\]:3 排序的那个方法中真的太机智叻>>>冒个泡.｡oO感慨下 随机化那个方法= = ，呃，建议运气不太行（比如年会只能抽到幸运奖/安慰奖的同学）别试

[CSDN21]: https://marketing.csdn.net/p/bdabfb52c5d56532133df2adc1a728fd
[9719cfbee9524a8e35df2ee73c5cd6f3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/a877f4be3ac8458982f80be0bc02ab1a.png