题目
给定一个整型数组,找到主元素,它在数组中的出现次数严格大于数组元素个数的1/k。
给出数组 [3,1,2,3,2,3,3,4,4,4] ,和 k = 3,返回 3
数组中只有唯一的主元素
要求时间复杂度为O(n),空间复杂度为O(k)
解题
上一题刚介绍过所用的方法,但是这个确实很复杂的
先利用HashMap实现
public class Solution { /** * @param nums: A list of integers * @param k: As described * @return: The majority number */ public int majorityNumber(ArrayList<Integer> nums, int k) { // write your code if(nums == null) return 0; HashMap<Integer,Integer> map = new HashMap<Integer,Integer>(); int majority = 0; for(int i = 0;i<nums.size(); i++){ int num = nums.get(i); if(map.containsKey(num)){ map.put(num,map.get(num) + 1); }else{ map.put(num,1); } if(map.get(num)*k > nums.size()){ majority = num; break; } } return majority; } }
总耗时: 1655 ms
class Solution: """ @param nums: A list of integers @param k: As described @return: The majority number """ def majorityNumber(self, nums, k): # write your code here if nums == None: return 0 d = {} majority = 0 for num in nums: if num in d: d[num] += 1 else: d[num] = 1 if d[num]*k > len(nums): majority = num break return majority
总耗时: 307 ms
更新HashMap的方法
import java.util.*; public class Solution { /** * @param nums: A list of integers * @param k: As described * @return: The majority number */ public int majorityNumber(ArrayList<Integer> nums, int k) { // write your code HashMap<Integer,int[]> counters = new HashMap<Integer,int[]>(); // 数组定义key 效率比较高 for(Integer num : nums){ int[] value = counters.get(num); if(value == null){ counters.put(num,new int[]{1}); }else{ value[0]++; // 直接 + 1 } } k = nums.size()/k; for(Map.Entry<Integer,int[]> entry:counters.entrySet()){ int[] value = entry.getValue(); if(value[0] > k){ return entry.getKey(); } } return Integer.MAX_VALUE; } }
进阶2:思路是,如果出现k个不一样的数,就抵消掉。这里需要用巧妙的数据结构来记录Candidates,并使得如下操作均为O(1):
1. 加入一个Candidate/给某个Candidate出现次数+1
2. Candidates中是否存在某个数
3. Candidates中所有数的出现次数 - 1
4. 移除出现次数为0的Candidates
对于1,2两个操作,我们自然可以想到使用Hash表来完成。对于第4两个操作,我们希望能够有出现次数最少的Candidate的信息,但是如果使用Heap则并非O(1)的时间复杂度。注意到每一次加入一个Candidate时,count均为1,每一次给改变一个Candidate出现次数时,也只涉及到加1运算。因此,如果我们能维护Candidates的有序性,就可以容易的解决这个问题。方法是,使用LinkedList。与普通的LinkedList不同的是,我们将所有出现次数相同的Candidate放在一个Bucket里,Bucket内部的Candidate用Doubly Linked List链接起来,Bucket之间也用Doubly Linked List链接起来。这样针对+1运算,我们只需要通过Hash表找到对应的Candidate,把Candidate从当前的Bucket移动到下一个Bucket(出现次数+1的Bucket)。另外,对于所有数-1的操作,我们记录全局的一个Base,每次-1操作,则Base+1。如果Base和Buckets中的第一个Bucket中的Candidates的出现次数相同,则整个删除第一个Bucket。最后,我们会得到最大k-1个Candidates,重新遍历一遍整个数组,用O(k)的Hash记录这k-1个Candidates的出现次数,就可以验证谁是真正的主元素。
public class Solution { /** * @param nums: A list of integers * @param k: As described * @return: The majority number */ public int majorityNumber(ArrayList<Integer> nums, int k) { // write your code HashMap<Integer,Integer> counters = new HashMap<Integer,Integer>(); for(Integer num : nums){ if(!counters.containsKey(num)){ counters.put(num,1); }else{ counters.put(num,counters.get(num) + 1); } if( counters.size() >= k){ removeKey(counters);// 清空 } } if( counters.size() ==0) { return Integer.MIN_VALUE; } for(Integer i: counters.keySet()){ counters.put(i,0); } for(Integer i :nums){ if(counters.containsKey(i)){ counters.put(i,counters.get(i) + 1); } } int maxCounter = 0; int maxKey = 0; for (Integer i : counters.keySet()) { if (counters.get(i) > maxCounter) { maxCounter = counters.get(i); maxKey = i; } } return maxKey; } private void removeKey(HashMap<Integer, Integer> counters) { Set<Integer> keySet = counters.keySet(); List<Integer> removeList = new ArrayList<>(); for (Integer key : keySet) { counters.put(key, counters.get(key) - 1); if (counters.get(key) == 0) { removeList.add(key); } } for (Integer key : removeList) { counters.remove(key); } } }
总耗时: 1725 ms
表示没有理解透彻