《零基础Go语言算法实战》

【题目 4-8】用 Go 语言设计一个遵循最近最少使用（LRU）缓存约束的数据结构

实现 LRUCache 类。

● LRUCache(int capacity) ：初始化具有正大小容量的 LRU 缓存。

● int get(int key) ：如果 key 存在，则返回 key 的值；否则返回 -1。

● void put(int key, int value) ：如果键存在，则更新键的值；否则将键值对添加到缓存中。

如果密钥数量超过此操作的容量，则移除 LRU 的密钥。

● get() 和 put() 方法必须分别以 O(1) 的平均时间复杂度运行。

101

零基础

Go语言算法实战

【解答】

① 思路。

根据要求，可以通过双向链表来设计 LRUCache 对象及其 get()、put() 方法。

② Go 语言实现。

package main

import "fmt"

type LRUCache struct {

 capacity int

 head, tail *Node

 values map[int]*Node

}

type Node struct {

 key, value int

 prev, next *Node

}

func Constructor(capacity int) LRUCache {

 return LRUCache{

 values: map[int]*Node{},

 capacity: capacity,

 }

}

func (lr *LRUCache) Get(key int) int {

 node, ok := lr.values[key]

 if !ok {

 return -1

 }

 lr.moveToLast(node)

 return node.value

}

func (lr *LRUCache) moveToLast(node *Node) {

 if node == lr.tail {

 return

 }

 if node == lr.head {

 lr.head = lr.head.next

 lr.head.prev = nil

 } else {

 node.prev.next = node.next

 node.next.prev = node.prev

 }

 lr.tail.next = node

 node.prev = lr.tail

 lr.tail = lr.tail.next

 lr.tail.next = nil

}

func (lr *LRUCache) Put(key int, value int) {

 if _, ok := lr.values[key]; ok {

 lr.values[key].value = value

 lr.moveToLast(lr.values[key])

 return

 }

 if len(lr.values) < lr.capacity {

 lr.append(key, value)

 return

 }

 node := lr.head

 lr.moveToLast(node)

 delete(lr.values, node.key)

 lr.values[key] = node

 node.key = key

 node.value = value

}

func (lr *LRUCache) append(key, value int) {

 node := &Node{

 key: key,

 value: value,

 }

 if lr.tail == nil {

 lr.tail = node

 lr.head = node

 } else {

 lr.tail.next = node

 node.prev = lr.tail

 lr.tail = node

 }

 lr.values[key] = node

}

func main() {

 obj := Constructor(2)

 obj.Put(5, 88)

 res := obj.Get(5)

 fmt.Println(res)

}

//$ go run interview4-8.go 

//88