¿Se puede explicar el principio de funcionamiento de la caché LRU y en qué situaciones se aplica?

La caché LRU (Least Recently Used) es una estructura de datos que almacena una cantidad limitada de elementos y, cuando se llena, elimina el elemento que no ha sido utilizado durante más tiempo.

Principio de funcionamiento:

• Cuando se accede a un elemento, se vuelve el "más reciente".
• Si la caché está llena y se necesita agregar un nuevo elemento, se elimina el elemento al que no se ha accedido durante más tiempo.

Esto permite utilizar la memoria de manera eficiente, manteniendo los datos más relevantes.

Aplicaciones:

• Caché de resultados de consultas a bases de datos.
• Caché de imágenes o archivos en memoria.
• En sistemas con recursos limitados para optimizar el acceso a los datos.

Ejemplo en Go (simplificado):

// Usamos el contenedor list para mantener el orden de uso
import (
    "container/list"
)

type LRUCache struct {
    capacity int
    cache    map[int]*list.Element
    list     *list.List
}

type entry struct {
    key   int
    value int
}

func NewLRUCache(capacity int) *LRUCache {
    return &LRUCache{
        capacity: capacity,
        cache:    make(map[int]*list.Element),
        list:     list.New(),
    }
}

func (c *LRUCache) Get(key int) (int, bool) {
    if elem, ok := c.cache[key]; ok {
        c.list.MoveToFront(elem)
        return elem.Value.(*entry).value, true
    }
    return 0, false
}

func (c *LRUCache) Put(key, value int) {
    if elem, ok := c.cache[key]; ok {
        c.list.MoveToFront(elem)
        elem.Value.(*entry).value = value
        return
    }
    if c.list.Len() == c.capacity {
        back := c.list.Back()
        if back != nil {
            c.list.Remove(back)
            delete(c.cache, back.Value.(*entry).key)
        }
    }
    elem := c.list.PushFront(&entry{key, value})
    c.cache[key] = elem
}