• lintcode 中等题:majority number 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;
        }
    }
    Java Code

    总耗时: 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
    Python Code

    总耗时: 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);
            }
        }
    }
    Python Code

    总耗时: 1725 ms

    表示没有理解透彻 

  • 相关阅读:
    watchers
    Observer
    计算属性
    Jsonp
    跨域
    axios
    duilib入门简明教程 -- 部分bug (11) (转)
    duilib入门简明教程 -- 界面设计器 DuiDesigner (10) (转)
    duilib入门简明教程 -- 界面布局(9) (转)
    duilib入门简明教程 -- 完整的自绘标题栏(8) (转)
  • 原文地址:https://www.cnblogs.com/bbbblog/p/4915338.html
Copyright © 2020-2023  润新知