ChatGPT帮我实现LRU

1. 内存受限

不知道从什么时候开始，什么东西都有了限制，一个咖啡杯只能装下500ml水，一块新买的内存也被标好了容量，姑娘的心里再装不下另一个人，我开始怀疑有什么东西是可以无限的，不像在小时候，我总觉得世界到处都是无限的。

当然也许有一天，制造工艺提升内存成了白菜价，我们可以用较小的价格买到更大的内存，可以依然是受限的，应用随着硬件的提升也会放肆的吃掉更多的内存。

在学习操作系统时，对于内存的管理，会涉及到一些算法，但是这些算法比较通用的。因为内存受限，乃至空间受限这个问题也是普遍存在的。

2. 淘汰算法

在空间受限的情况下，为了能继续放入一些东西，我们需要释放一些空间。常见的算法有如下几种

1. 随机 : 很好理解，就是随机淘汰
2. LRU : least recent used 最近最少使用，即把最久没有被访问的数据淘汰掉
3. LFU ：least frequent used 最不经常使用，即把访问次数最小的数据淘汰掉
4. FIFO: 先进先出， 把最先put进来的数据淘汰掉

页面置换算法在不同的使用情况下都有其独特的优点和劣势。因此，选择哪种页面置换算法取决于实际应用的特定需求。

例如，如果内存使用情况稳定，那么 LFU 算法可能是最佳选择，因为它能够替换使用最少的页面。然而，如果需要模拟缓存中频繁发生的模式变化，那么 LRU 算法可能是更好的选择，因为它基于最近的历史记录来决策。

最后，值得注意的是，在实际应用中，常常采用混合策略，以结合各种页面置换算法的优点。这样可以提高系统的整体性能和灵活性。

2. LRU算法

最后，我们请出ChatGPT来帮我们实现一段LRU算法

class Node:
    def __init__(self, key, value):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = {}
        self.head = Node(0, 0)
        self.tail = Node(0, 0)
        self.head.next = self.tail
        self.tail.prev = self.head

    def get(self, key):
        if key not in self.cache:
            return -1
        node = self.cache[key]
        self._remove(node)
        self._add(node)
        return node.value

    def put(self, key, value):
        if key in self.cache:
            self._remove(self.cache[key])
        node = Node(key, value)
        self._add(node)
        self.cache[key] = node
        if len(self.cache) > self.capacity:
            node = self.head.next
            self._remove(node)
            del self.cache[node.key]

    def _remove(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev

    def _add(self, node):
        node.prev = self.tail.prev
        node.next = self.tail
        self.tail.prev.next = node
        self.tail.prev = node