entrevista programador de oro - preguntas cara 16.25 caché LRU

tema:

Diseño y construcción de un "usado menos recientemente" caché que eliminar los elementos menos utilizados recientemente. Se debe asignar a la caché del valor de la clave (clave le permite insertar y recuperar el valor correspondiente de lo particular), y se especifica la capacidad máxima en la inicialización. Cuando se llena la memoria caché, se debe eliminar los elementos menos utilizados recientemente.

Se debe apoyar el siguiente: obtener los datos  get de datos y la escritura  put .

La adquisición de datos  get(key) - si la clave (key) está presente en la memoria caché, entonces el valor de la clave se adquirió (siempre positivo), en otro caso -1.
La escritura de datos  put(key, value) - si la clave no está presente, entonces el valor de los datos se escriben. Cuando se alcanza el límite de capacidad de caché, debe borrar los valores de datos utilizados menos recientemente antes de escribir nuevos datos para hacer espacio para el nuevo valor de datos.

Ejemplo:

LRUCache cache = new LRUCache (2 / * tamaño de búfer * /); 

cache.put (1 ,. 1.); 
Cache.put (2, 2); 
(. 1) cache.get; // devuelve 1. 
Cache.put (3,. 3); // esta operación hará que la tecla 2 void 
cache.get (2); // devuelve -1 (no encontrado) 
. cache.put (4 ,. 4); // esta operación hará que una tecla no válida 
caché. obtener (1); // devuelve -1 (no encontrado) 
cache.get (3.); // devuelve 3. 
cache.get (4); // devuelve 4

análisis:

LeetCode 146. LRU CacheLRU mecanismo de caché (C ++ / Java) se refieren a esta explicación.

procedimiento:

clase LRUCache { 

    LRUCache ( int capacidad) {
         este .La capacidad = capacidad;
        este .map = nuevo HashMap <> ();
        este .dummyHead = nuevo nodo (0, 0 );
        este .tail = nuevo nodo (0, 0 ); 

        dummyHead.prev = nulo ; 
        dummyHead.next = cola; 
        tail.prev = dummyHead; 
        tail.next = nulo ; 
    } 
    
    Int get (int clave) {
         si (map.containsKey (clave)) { 
            Nodo nodo = map.get (clave);
            int value = node.val; 
            removeNode (nodo); 
            addToHead (nodo); 
            volver valor; 
        } 
        Devolver -1 ; 
    } 
    
    Void put ( int clave, int value) {
         si (map.containsKey (clave)) { 
            Nodo nodo = map.get (clave); 
            removeNode (nodo); 
            map.remove (clave); 
            Tamaño -  ;
        }
        Nodo Node = nuevo nodo (clave, valor); 
        map.put (clave, nodo); 
        si (tamaño < capacidad) { 
            addToHead (nodo); 
            tamaño ++ ; 
        } Demás { 
            map.remove (tail.prev.key); 
            removeNode (tail.prev); 
            addToHead (nodo); 
        } 
    } 
    Privado  void removeNode (nodo Node) { 
        node.prev.next = node.next; 
        node.next.prev = node.prev; 
    } 
    Privada  vacíoaddToHead (nodo Node) { 
        node.next = dummyHead.next; 
        node.next.prev = nodo; 
        dummyHead.next = nodo; 
        node.prev = dummyHead; 
    } 
    Clase del nodo {
         int clave;
        int val; 
        Prev nodo; 
        Siguiente nodo; 
        pública Nodo ( int clave, int val) {
             este .key = llave;
            esta .val = Val; 
        } 
    } 
    Privada HashMap <Integer, Nodo> mapa;
    privada  int capacidad;
    privada dummyHead nodo;
    privada cola nodo;
    privada  int tamaño; 
} 

/ ** 
 * Su objeto LRUCache se creará una instancia y llamó como tal: 
 * LRUCache obj = new LRUCache (capacidad); 
 * Int param_1 = obj.get (clave); 
 * Obj.put (clave, valor); 
 * /

clase LRUCache { 

    LRUCache ( int capacidad) {
         este .La capacidad = capacidad; 
        mapa = nuevo LinkedHashMap <> (); 
    } 
    
    Int get ( int clave) {
         si (map.containsKey (clave)) {
             int value = map.get (clave); 
            map.remove (clave); 
            map.put (clave, valor); 
            volver valor; 
        } 
        Devolver -1 ; 
    } 
    
    Void put ( int clave, int valor) {
        si (map.containsKey (clave)) { 
            map.remove (clave); 
        } 
        Map.put (clave, valor); 
        si (map.size ()> capacidad) { 
            map.remove (map.keySet () iterador () siguiente ()..); 
        } 
    } 
    Privada  int capacidad;
    privada LinkedHashMap <Integer, Integer> mapa; 
} 

/ ** 
 * Su objeto LRUCache se creará una instancia y llamó como tal: 
 * LRUCache obj = new LRUCache (capacidad); 
 * Int param_1 = obj.get (clave); 
 * Obj.put (clave, valor); 
 * /