134. Estrategia de almacenamiento en caché de LRU

Diseñe una estructura de datos para la estrategia de caché de uso menos reciente (LRU). Debe admitir las siguientes operaciones: obtener datos y escribir datos. obtener (clave) Obtener datos: si la clave existe en el caché

Idea: Los datos más recientes se colocan al principio de la lista vinculada, si el tamaño excede el tamaño, se eliminan los datos finales.

struct Node
{     Node ()     {         key = -1;         value = 0;         next = nullptr;         pre = nullptr; // Fácil de eliminar     }

    valor int;
    int clave;
    Nodo * siguiente;
    Nodo * pre;
};

class LRUCache { public:     / *     * @param capacidad: Un entero     * / LRUCache (int capacidad) {     // hacer inicialización si es necesario     size_ = capacidad;     head_ = nullptr;     tail_ = nullptr; }

      / *
      * @param key: un entero
      * @return: un entero
      * /
      int get (int key) {           // escribe tu código aquí           auto it = cacheMap_.find (key);           if (it! = cacheMap_.end ())           {               moveNodeToHead (it-> first);               devolverlo-> segundo-> valor;           }           return -1;       }

      / *
      * @param key: un número entero
      * @param value: un número entero
      * @return: nada
      * /
      void set (int key, int value) {           // escribe tu código aquí

          auto it = cacheMap_.find (clave);
          if (it! = cacheMap_.end ())
          {                it-> second-> value = value;                moveNodeToHead (clave);           }           else           {               if (cacheMap_.size () == size_)               {                   deleteTail ();               }

              if (cacheMap_.size () == 0)
              {                   Nodo * cur = new Node ();                   cur-> valor = valor;                   cur-> key = key;                   head_ = cur;                   tail_ = cur;                   cacheMap_ [clave] = cur;                   regreso;               }

              Nodo * cur = new Node ();
              cur-> valor = valor;
              cur-> key = key;
              // insertar head
              cur-> next = head_;
              cabeza _-> pre = cur;
              head_ = cur;

              cacheMap_ [clave] = cur;
          }

      }

 

      void moveNodeToHead (clave int)
      {           std :: unordered_map <int, Node *> :: iterator it = cacheMap_.find (clave);             Nodo * cur = it-> segundo;           if (head_ == cur) // head           {               return;           }

          if (tail_ == cur) // tail
          {               tail_ = cur-> pre;               tail _-> next = nullptr;               cur-> siguiente = head_;               cabeza _-> pre = cur;               cur-> pre = nullptr;               head_ = cur;               regreso;           }          // mid           cur-> pre> next = cur-> next;           cur-> siguiente-> pre = cur-> pre;
            

          cur-> siguiente = head_;
          cabeza _-> pre = cur;
          cur-> pre = nullptr;
          head_ = cur;
      }

      vacío deleteTail ()
      {           clave int = -1;           if (nullptr == tail_)           {               return;           }           Nodo * cur = tail_;           if (tail_ == head_) // solo un nodo           {               key = cur-> key;               cacheMap_.erase (clave);               eliminar cur;               head_ = nullptr;               tail_ = nullptr;               regreso;           }           tail_ = cur-> pre;           clave = cur-> clave;           tail _-> next = nullptr;           cacheMap_.erase (clave);           eliminar cur;

        







            












          cur = nullptr;

        
      }

privado:
    std :: unordered_map <int, Node *> cacheMap_;
    Nodo * head_;
    Nodo * tail_;
    int size_;

};
prueba void ()
{     caché LRUCache (2);     cache.set (2,1);     cache.set (1, 1);     int a = cache.get (2);     cache.set (4, 1);     int b = cache.get (1);     b = cache.get (2);

    / * Caché LRUCache (1);
    cache.set (2, 1);
    int a = cache.get (2);
    cache.set (3, 2);
    int b = cache.get (2);
    b = cache.get (3); * /
}

int main ()
{     prueba ();     getchar ();     return 0; }