TopK_LRU_归并

1. TopK

import java.util.Comparator;
import java.util.ArrayList;
import java.util.PriorityQueue;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> res = new ArrayList();
        if(k<=0 || k > input.length) return res;
        //维持一个容量为k的大顶堆
        PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(k, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });
        for(int i=0;i<input.length;i++){
            if(maxHeap.size() < k){
                maxHeap.offer(input[i]);
            }else if(input[i] < maxHeap.peek()){
                maxHeap.poll();
                maxHeap.offer(input[i]);
            }
        }
        for(Integer num : maxHeap){
            res.add(num);
        }
        return res;
    }
}

 2. LRU

class LRUCache {
    int capacity;
    LinkedList<Integer> list = new LinkedList();//存储key的缓存关系，最前面是最近最久未使用的
    HashMap<Integer, Integer> map = new HashMap();//存储键值对
    public LRUCache(int capacity) {
        this.capacity = capacity;
    }
    public int get(int key) {
        if(map.containsKey(key)){
            list.remove((Integer)key);
            list.addLast(key);
            return map.get(key);
        }
        return -1;
    }
    
    public void put(int key, int value) {
        if(map.containsKey(key)){
            list.remove((Integer)key);
        }else if(list.size() == capacity){
            map.remove(list.removeFirst());
        }
        map.put(key,value);
        list.addLast(key);
    }
}

3. 归并排序

基本思想：将待排序序列R[0...n-1]看成n个长度为1的有序序列，将相邻的有序表成对归并，得到n/2个长度为2的有序表；将这些有序表再次归并，得到n/4个长度为4的有序序列；如此反复，最后得到一个长度为n的有序序列。

3.1 总流程

3.2 合并两个小数组

 

 3.3 代码