11/10 <priorityQueue> 215 347

215. Kth Largest Element in an Array

快速排序法，选择一个数，比这个数大的交换到左边，比这个数小的交换到右边。

class Solution {
    public int findKthLargest(int[] nums, int k) {
        shuffle(nums);
        k = nums.length - k;
        int lo = 0, hi = nums.length - 1;
        while(lo < hi){
            final int j = partition(nums, lo, hi);
            if(j < k){
                lo = j + 1;
            }else if( j > k){
                hi = j - 1;
            }else{
                break;   
            }
        }
        return nums[k];
    }
    
    public int partition(int[] a, int lo, int hi){
        int i = 0;
        int j = hi + 1;
        while(true){
            while(i < hi && less(a[++i], a[lo]));
            while(j > lo && less(a[lo], a[--j]));
            if(i >= j){
                break;
            }
            swap(a, i, j);
        }
        swap(a, lo, j);
        return j;
    }
    
    public void swap(int[] a, int i, int j){
        int tmp = a[i];
        a[i] = a[j];
        a[j] =tmp;
    }
    
    private void shuffle(int a[]) {

        final Random random = new Random();
        for(int ind = 1; ind < a.length; ind++) {
            final int r = random.nextInt(ind + 1);
            swap(a, ind, r);
        }
    }
    
    public boolean less(int v, int m){
        return v < m;
    }
}

347. Top K Frequent Elements

用桶排序原则，bucket[]的下标表示出现的次数。用HashMap放入数字和出现的次数并放入对应的bucket中，最后从后向前取出。

HashMap.getOrDefault(n,0), 返回Key对应的Value，没有则返回0

HashMap.keySet(): 获取所有 Key

class Solution {
    public List<Integer> topKFrequent(int[] nums, int k) {
        List<Integer>[] bucket = new List[nums.length + 1];
        Map<Integer, Integer> frequencyMap = new HashMap<Integer, Integer>();
        
        for(int n : nums){
            frequencyMap.put(n, frequencyMap.getOrDefault(n, 0) + 1);
        }
        
        for(int key : frequencyMap.keySet()){
            int frequency = frequencyMap.get(key);
            if(bucket[frequency] == null){
                bucket[frequency] = new ArrayList<>();
            }
            bucket[frequency].add(key);
        }
        
        List<Integer> res = new ArrayList<>();
        for(int pos = bucket.length - 1; pos >= 0 && res.size() < k; pos--){
            if(bucket[pos] != null){
                res.addAll(bucket[pos]);
            }
        }
        return res;
    }
}