LeetCode-Java：169.多数元素

题目

给定一个大小为 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 * 104
• -109 <= nums[i] <= 109

**进阶：**尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。

解

①先排序，后查找，超过40.76%

import java.util.Arrays;
class Solution {
    public static int majorityElement(int[] nums) {
        int number=nums[0];
        Arrays.sort(nums);
        for(int i=0;i<nums.length;){
            int times=0;
            while(i<nums.length&&number==nums[i++]){
                times++;
            }
            if(times>=(nums.length+1)/2){
                return number;
            }
            else{
                number=nums[i];
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] nums1 = {1, 2, 2, 2, 2};
        majorityElement(nums1);
    }
}

②排序法的改进，超过66.66%

import java.util.Arrays;
class Solution {
    public static int majorityElement(int[] nums) {
        Arrays.sort(nums);
        //if(nums.length%2!=0)
        //如果一共奇数个，因为题目提到多数元素总是存在，出现次数大于n/2
        //故最中间的那个肯定是多数元素
        //如果偶数个，最中间的两个都应该是多数元素
        //所以return排序后最中间的就可以
        return nums[nums.length/2];
    }
    
    public static void main(String[] args) {
        int[] nums1 = {1, 2, 2, 2, 2};
        majorityElement(nums1);
    }
}

③参考LeetCode思路后：摩尔投票，超过99.87%

class Solution {
    public static int majorityElement(int[] nums) {
        // 假设是众数+1，非众数-1，最后遍历整个数组得到的数一定大于0
        // 若前a个元素相加为0，则n-a剩余的元素当中，出现最多的仍是众数
        int number = 0, votes = 0;
        for (int i = 0; i < nums.length; i++) {
            if (votes == 0) {
                number = nums[i];
            }
            votes += nums[i] == number ? 1 : -1;
        }
        System.out.println(number);
        return number;
    }

    public static void main(String[] args) {
        int[] nums1 = {1, 2, 2, 2, 2};
        majorityElement(nums1);
    }
}

④LeetCode思路：哈希表,超过23.99%

补充知识：

哈希表，一种数据结构，能够快速完成插入和查找操作。简单来说就是对给定的K，将其存储到F(K)上，通过一个函数可以迅速得到K对应的存储内容。除了哈希函数之外，哈希表的另外一个重要的内容就是解决哈希冲突，确保不同的变量不会得到同一个结果，常用的解决冲突的方法是链表法（将冲突元素存放在链表当中），开放定址法（以发生哈希冲突的哈希地址为自变量，通过某种哈希函数得到一个新的空闲内存单地址的方法）

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

class Solution {
    private static 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 {
                //如果已经存在的话，value在原有基础上+1
                counts.put(num, counts.get(num) + 1);
            }
        }
        return counts;
    }

    public static int majorityElement(int[] nums) {
        Map<Integer, Integer> counts = countNums(nums);
        Map.Entry<Integer, Integer> max = null;
        for (Map.Entry<Integer, Integer> entry : counts.entrySet()) {
            if (max == null || entry.getValue() > max.getValue()) {
                max = entry;
            }
        }
        return max.getKey();
    }

    public static void main(String[] args) {
        int[] nums1 = {1, 2, 2, 2, 2};
        majorityElement(nums1);
    }
}

总结

这道简单题的解法很多，在尝试用排序方法解完之后，我又看了摩尔排序和哈希表的方法。

以为哈希表的解法会更快速，实际结果是这几个方法里面运行时间最长的，这一点没想到，汗。

不过也算是，学习了一下哈希表相关知识。