LRU-2 实施

Question

我正在尝试用 Java 中的 PriorityQueue 实现 LRU-2 缓存。在我看来，我可以在O(LogN) 时间内完成poll() 和add()，但是要在缓存中搜索，我会花费O(N) 时间。关于如何在O(LogN) 时间内使用poll()、add() 和search() 实现LRU-2 缓存的任何建议？还是根本不可能这样做？

Answer 1

经过一番挣扎，我得到了一个带有 MaxHeap 和 HashMap 的 LRU-2，操作最多需要 O(log N) 时间。这是 Java 中 LRU-2 的代码。代码也在我的GitHub。

Node.java，这是HashMap和MaxHeap中的值

package me.york;

class Node<K, V extends Comparable<V>> implements Comparable<Node<K, V>> {
private K key;
private V value;
private int index;
private long lastTime;
private long lastSecondTime;
public static long INIT = -1;

Node(K key, V value) {
    this.key = key;
    this.value = value;
    lastTime = INIT;
    lastSecondTime = INIT;
}

@Override
public int compareTo(Node<K, V> o) {
    return (int)(lastSecondTime-o.getLastSecondTime());
}

K getKey() {
    return key;
}

V getValue() {
    return value;
}

int getIndex() {
    return index;
}

void setIndex(int index) {
    this.index = index;
}

long getLastTime() {
    return lastTime;
}

void setLastTime(long lastTime) {
    this.lastTime = lastTime;
}

long getLastSecondTime() {
    return lastSecondTime;
}

void setLastSecondTime(long lastSecondTime) {
    this.lastSecondTime = lastSecondTime;
}
}

MaxHeap.java，LRU-2算法的主要逻辑在这个类中。

package me.york;

class MaxHeap<K, V extends Comparable<V>> {
private Node<K, V>[] heap;
private int currentSize;
private long count;

MaxHeap(int size) {
    count = 0;
    currentSize = 1;
    heap = new Node[size + 1];
}

boolean isFull() {
    return currentSize >= heap.length;
}

Node<K, V> add(Node<K, V> value) {
    Node<K, V> previous = value;
    if (currentSize >= heap.length) {
        previous = removeMax();
    }
    if (value.getLastSecondTime() != Node.INIT) {
        value.setLastSecondTime(value.getLastTime());
    } else {
        value.setLastSecondTime(count);
    }
    value.setLastTime(count++);
    value.setIndex(currentSize);
    heap[currentSize++] = value;
    siftUp(currentSize - 1);
    return previous;
}

Node<K, V> getMax() {
    return heap[0];
}

Node<K, V> removeMax() {
    return remove(0);
}

Node<K, V> reVisited(int index) {
    Node<K, V> node = heap[index];
    remove(node.getIndex());
    add(node);
    return node;
}

Node<K, V> remove(int index) {
    Node<K, V> previous = heap[index];
    heap[index] = heap[--currentSize];
    siftDown(index);
    return previous;
}

private void siftDown(int index) {
    int left = 2 * index;
    int right = 2 * index + 1;
    int largest;
    if (left < currentSize && heap[left].compareTo(heap[index]) > 0)
        largest = left;
    else
        largest = index;
    if (right < currentSize && heap[right].compareTo(heap[largest]) > 0)
        largest = right;
    if (largest != index) {
        Node<K, V> temp = heap[index];
        heap[index] = heap[largest];
        heap[largest] = temp;
        heap[index].setIndex(largest);
        heap[largest].setIndex(index);
        siftDown(largest);
    }
}

private void siftUp(int index) {
    while (index > 1 && heap[index].compareTo(heap[index / 2]) > 0) {
        Node<K, V> temp = heap[index];
        heap[index] = heap[index / 2];
        heap[index / 2] = temp;
        heap[index].setIndex(index / 2);
        heap[index / 2].setIndex(index);
        index = index / 2;
    }
}
}

LRU2Cache.java，这是LRU-2缓存算法的入口。它只是提供了两个函数，get() 和 put()。

package me.york;

import java.util.HashMap;
import java.util.Map;

public class LRU2Cache<K, V extends Comparable<V>> {
private MaxHeap<K, V> maxHeap;
private Map<K, Node<K, V>> map;

public LRU2Cache(int cacheSize) {
    maxHeap = new MaxHeap<K, V>(cacheSize);
    map = new HashMap<K, Node<K, V>>((int) ((float) cacheSize / 0.75F + 1.0F));
}

public void put(K key, V value) {
    if (key != null && value != null) {
        Node<K, V> previous;
        if ((previous = map.get(key)) != null) {
            maxHeap.remove(previous.getIndex());
        }
        if (maxHeap.isFull())
            map.remove(maxHeap.getMax().getKey());
        previous = new Node<K, V>(key, value);
        map.put(key, previous);
        maxHeap.add(previous);
    }
}

public V get(K key) {
    V value = null;
    if (key != null) {
        Node<K, V> node = map.get(key);
        if (node != null) {
            value = node.getValue();
            maxHeap.reVisited(node.getIndex());
        }
    }
    return value;
}
}