lintcode 中等题：majority number III主元素III

题目

主元素 III

给定一个整型数组，找到主元素，它在数组中的出现次数严格大于数组元素个数的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

表示没有理解透彻