LeetCode169.多数元素、229.求众数II、JZ28出现次数超过一半的数字

63 阅读 0 评论 42 点赞

我是靠谱客的博主傲娇大山，最近开发中收集的这篇文章主要介绍LeetCode169.多数元素、229.求众数II、JZ28出现次数超过一半的数字，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

JZ28.出现次数超过一半的数字

题目描述

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

LeetCode169.多数元素

题目描述

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

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

示例 2:

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

解题思路

一、排序法
这两个其实是一个题，拿到这个题我的第一反应是先排序，然后直接取下标为⌊ n/2 ⌋（下标从0开始）的关键字。

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

时间复杂度：O(nlogn)。将数组排序的时间复杂度为 O(nlogn)。
空间复杂度：O(logn)。如果使用语言自带的排序算法，需要使用 O(logn) 的栈空间。如果自己编写堆排序，则只需要使用 O(1) 的额外空间。

二、哈希表
这是看了官方题解才知道的一种解法，对我个人而言还是不太会想到的，思想就是通过HashMap来存储每个元素以及出现的次数，没有HashMap中的键值对，键表示一个元素，值表示元素的出现次数。我们用一个循环遍历数组 nums 并将数组中的每个元素加入哈希映射中。在这之后，我们遍历哈希映射中的所有键值对，返回值最大的键。

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();
    }
}

这里面涉及到了几个Map方法：

boolean containsKey(Object key)：如果此映射包含指定键的映射关系，则返回 true。更确切地讲，当且仅当此映射包含针对满足 (key == null ? k ==null : key.equals(k)) 的键 k 的映射关系时，返回 true。（最多只能有一个这样的映射关系）。
boolean containsValue(Object value)：如果此映射将一个或多个键映射到指定值，则返回 true。更确切地讲，当且仅当此映射至少包含一个对满足 (value == null ? v==null : value.equals(v)) 的值 v 的映射关系时，返回 true。对于大多数 Map 接口的实现而言，此操作需要的时间可能与映射大小呈线性关系。
Entry：由于Map中存放的元素均为键值对，故每一个键值对必然存在一个映射关系。Map中采用Entry内部类来表示一个映射项，映射项包含Key和Value。Map.Entry里面包含getKey()和getValue()方法。Set<Entry<T,V>> entrySet()：该方法返回值就是这个map中各个键值对映射关系的集合。Set里面的类型是Map.Entry，一般可以通过map.entrySet()得到。

当然，我们也可以对上述解法做出优化，在将数组中的元素加入哈希映射的过程中做出判断，如果有符合条件的值则直接返回。

import java.util.HashMap;
import java.util.Map;
public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
         Map<Integer,Integer> hashMap = new HashMap<Integer,Integer>();
        for(int i=0; i<array.length ; i++){
            if(hashMap.containsKey(array[i])){
                hashMap.put(array[i],hashMap.get(array[i])+1);
            }else{
                hashMap.put(array[i],1);
            }
            if(hashMap.get(array[i]) > array.length/2){
                return array[i];
            }
        }
        return 0;
    }
}

三、摩尔投票法
哇，这个算法思想真得精妙！当我们对数组进行遍历的时候，如果遇到目标数就+1，如果是其他数就-1，最终遍历完之后和显然大于1，从结果来看，众数比其他数多。
详细步骤如下：

我们维护一个候选众数 candidate 和它出现的次数 count。初始时 candidate 可以为任意值，count 为 0；
我们遍历数组 nums 中的所有元素，对于每个元素 x，在判断 x 之前，如果 count 的值为 0，我们先将 x 的值赋予 candidate，随后我们判断 x：
如果 x 与 candidate 相等，那么计数器 count 的值增加 1；
如果 x 与 candidate 不等，那么计数器 count 的值减少 1。
在遍历完成后，candidate 即为整个数组的众数。

证明:

如果候选人不是maj 则 maj,会和其他非候选人一起反对会反对候选人,所以候选人一定会下台(maj==0时发生换届选举)
如果候选人是maj , 则maj 会支持自己，其他候选人会反对，同样因为maj 票数超过一半，所以maj 一定会成功当选

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;
    }
}

LeetCode229.求众数 II

题目描述

给定一个大小为 n 的数组，找出其中所有出现超过 ⌊ n/3 ⌋ 次的元素。
说明: 要求算法的时间复杂度为 O(n)，空间复杂度为 O(1)。
示例1

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

示例2

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

解题思路

这个题如果能用哈希法的话是非常简单的，时间复杂度也符合要求，但是不符合常量级的空间复杂度这一要求。
摩尔投票法
思路和上边那个题是一样的，不过主候选人由一个变成了两个。具体解题步骤写在算法代码注释里了。

class Solution {
    public List<Integer> majorityElement(int[] nums) {
        // 创建返回值
        List<Integer> res = new ArrayList<>();
        if (nums == null || nums.length == 0) return res;
        // 初始化两个候选人candidate，和他们的计票
        int cand1 = nums[0], count1 = 0;
        int cand2 = nums[0], count2 = 0;

        // 摩尔投票法，分为两个阶段：配对阶段和计数阶段
        // 配对阶段
        for (int num : nums) {
            // 投票
            if (cand1 == num) {
                count1++;
                continue;
            }
            if (cand2 == num) {
                count2++;
                continue;
            }

            // 第1个候选人配对
            if (count1 == 0) {
                cand1 = num;
                count1++;
                continue;
            }
            // 第2个候选人配对
            if (count2 == 0) {
                cand2 = num;
                count2++;
                continue;
            }

            count1--;
            count2--;
        }

        // 计数阶段
        // 找到了两个候选人之后，需要确定票数是否满足大于 N/3
        count1 = 0;
        count2 = 0;
        for (int num : nums) {
            if (cand1 == num) count1++;
            else if (cand2 == num) count2++;
        }

        if (count1 > nums.length / 3) res.add(cand1);
        if (count2 > nums.length / 3) res.add(cand2);

        return res;
    }
}