力扣 leetcode 169. 多数元素

力扣 leetcode 169. 多数元素

题目

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

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

示例 1:

输入: [3,2,3]
输出: 3
示例 2:

输入: [2,2,1,1,1,2,2]
输出: 2

来源：力扣（LeetCode）

1.我的解法

先上代码

class Solution {
    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        int max=nums.length/2;
        int times=1;
        int turn=0;
        for (int i=0;i<nums.length-1;i++){
            if(nums[i] == nums[i+1]){
                times++;
            }
            if (times>max){
                max=times;
                turn = nums[i];
            }
            if(nums[i] != nums[i+1]){
                times=1;
            }
        }
        if(nums.length==1){
            return nums[0];
        }
        return turn;
    }
}

思路：1.排序，变为有序数组2.遍历 相同+1，不同置1 记录下最多重复值 3.返回出现次数最多的值
时间复杂度：O(nlog(n)) 空间复杂度：O（log(n)）思路：1.
时间复杂度排序（递增） O(1) O(logn) O(n) O(nlog(n)) O(n^2)

2.哈希表

思路：1.将每个键值对放入哈希表中，key为num,value为出现次数，若哈希表中不存在，放入时value为1，若存在则为map.get(num)+1
(map的get(num)方法会自己返回相同num最大的value)
2.遍历，找到最大value对应的num
为什么用Map.Entry接口?
因为要以map类型的一个键值对遍历map键值对集合就必须用map.entry接口表示映射项来遍历map.entryset键值对集。

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

}

2.排序

题目中说多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
所以将数组按序排列后，若众数是最小的数，则它一定会经过下标为n/2处（众数个数>=n/2+1,下标>=n/2），若为最大的数也相同。
所以只需排序后返回下标为n/2的数即可

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

时间复杂度：O(nlog(n)) 空间复杂度：O（log(n)）