feat: add golang solution to lc problem: No.0146

No.0146.Lru Cache

Author: maolonglong

solution/0100-0199/0146.Lru Cache/README.md

@@ -392,6 +392,79 @@ impl LRUCache {
 }
 ```
 
+### **Go**
+
+```go
+type node struct {
+	key, val   int
+	prev, next *node
+}
+
+type LRUCache struct {
+	capacity   int
+	cache      map[int]*node
+	head, tail *node
+}
+
+func Constructor(capacity int) LRUCache {
+	head := new(node)
+	tail := new(node)
+	head.next = tail
+	tail.prev = head
+	return LRUCache{
+		capacity: capacity,
+		cache:    make(map[int]*node, capacity),
+		head:     head,
+		tail:     tail,
+	}
+}
+
+func (this *LRUCache) Get(key int) int {
+	n, ok := this.cache[key]
+	if !ok {
+		return -1
+	}
+	this.moveToFront(n)
+	return n.val
+}
+
+func (this *LRUCache) Put(key int, value int) {
+	n, ok := this.cache[key]
+	if ok {
+		n.val = value
+		this.moveToFront(n)
+		return
+	}
+	if len(this.cache) == this.capacity {
+		back := this.tail.prev
+		this.remove(back)
+		delete(this.cache, back.key)
+	}
+	n = &node{key: key, val: value}
+	this.pushFront(n)
+	this.cache[key] = n
+}
+
+func (this *LRUCache) moveToFront(n *node) {
+	this.remove(n)
+	this.pushFront(n)
+}
+
+func (this *LRUCache) remove(n *node) {
+	n.prev.next = n.next
+	n.next.prev = n.prev
+	n.prev = nil
+	n.next = nil
+}
+
+func (this *LRUCache) pushFront(n *node) {
+	n.prev = this.head
+	n.next = this.head.next
+	this.head.next.prev = n
+	this.head.next = n
+}
+```
+
 ### **...**
 
 ```

solution/0100-0199/0146.Lru Cache/README_EN.md

@@ -341,6 +341,79 @@ impl LRUCache {
 }
 ```
 
+### **Go**
+
+```go
+type node struct {
+	key, val   int
+	prev, next *node
+}
+
+type LRUCache struct {
+	capacity   int
+	cache      map[int]*node
+	head, tail *node
+}
+
+func Constructor(capacity int) LRUCache {
+	head := new(node)
+	tail := new(node)
+	head.next = tail
+	tail.prev = head
+	return LRUCache{
+		capacity: capacity,
+		cache:    make(map[int]*node, capacity),
+		head:     head,
+		tail:     tail,
+	}
+}
+
+func (this *LRUCache) Get(key int) int {
+	n, ok := this.cache[key]
+	if !ok {
+		return -1
+	}
+	this.moveToFront(n)
+	return n.val
+}
+
+func (this *LRUCache) Put(key int, value int) {
+	n, ok := this.cache[key]
+	if ok {
+		n.val = value
+		this.moveToFront(n)
+		return
+	}
+	if len(this.cache) == this.capacity {
+		back := this.tail.prev
+		this.remove(back)
+		delete(this.cache, back.key)
+	}
+	n = &node{key: key, val: value}
+	this.pushFront(n)
+	this.cache[key] = n
+}
+
+func (this *LRUCache) moveToFront(n *node) {
+	this.remove(n)
+	this.pushFront(n)
+}
+
+func (this *LRUCache) remove(n *node) {
+	n.prev.next = n.next
+	n.next.prev = n.prev
+	n.prev = nil
+	n.next = nil
+}
+
+func (this *LRUCache) pushFront(n *node) {
+	n.prev = this.head
+	n.next = this.head.next
+	this.head.next.prev = n
+	this.head.next = n
+}
+```
+
 ### **...**
 
 ```

solution/0100-0199/0146.Lru Cache/Solution.go

@@ -1,105 +1,68 @@
-type list struct{   //双向链表,用于保存key:value
-    prev,next *list
-    key,val int
+type node struct {
+	key, val   int
+	prev, next *node
 }
 
 type LRUCache struct {
-    _len,_cap int
-    front,back *list    //头尾指针
-    umap map[int]*list  //hash表
+	capacity   int
+	cache      map[int]*node
+	head, tail *node
 }
-  
 
 func Constructor(capacity int) LRUCache {
-    return LRUCache{
-        _len : 0,
-        _cap : capacity,
-        front: nil,
-        back : nil,
-        umap : make(map[int]*list,capacity),
-    }
+	head := new(node)
+	tail := new(node)
+	head.next = tail
+	tail.prev = head
+	return LRUCache{
+		capacity: capacity,
+		cache:    make(map[int]*node, capacity),
+		head:     head,
+		tail:     tail,
+	}
 }
 
-
 func (this *LRUCache) Get(key int) int {
-    if node,ok := this.umap[key];ok{  //存在
-        
-        this.push_front(node)
-        return node.val
-    }
-    
-    return -1
+	n, ok := this.cache[key]
+	if !ok {
+		return -1
+	}
+	this.moveToFront(n)
+	return n.val
 }
 
-
-func (this *LRUCache) Put(key int, value int)  {
-    if node,ok := this.umap[key];ok{ 
-        node.val = value
-        this.push_front(node)
-        return 
-    }
-    
-    //找不到
-    if this._len == this._cap{
-        delete(this.umap,this.back.key)
-        this.pop_back()
-    }else{
-        this._len++
-    }
-    
-    node := &list{
-        prev:nil,
-        next:nil,
-        key:key,
-        val:value,
-    }
-    
-    this.umap[key] = node
-    this.insert_front(node)  
+func (this *LRUCache) Put(key int, value int) {
+	n, ok := this.cache[key]
+	if ok {
+		n.val = value
+		this.moveToFront(n)
+		return
+	}
+	if len(this.cache) == this.capacity {
+		back := this.tail.prev
+		this.remove(back)
+		delete(this.cache, back.key)
+	}
+	n = &node{key: key, val: value}
+	this.pushFront(n)
+	this.cache[key] = n
 }
 
-
-func (this *LRUCache) push_front(node *list){
-    switch node{    //先删除，再插入
-    case this.front:
-        return
-    case this.back:
-        this.pop_back()
-    default:
-        node.prev.next = node.next
-        node.next.prev = node.prev
-    }
-    
-    this.insert_front(node)
+func (this *LRUCache) moveToFront(n *node) {
+	this.remove(n)
+	this.pushFront(n)
 }
 
-func (this *LRUCache) pop_back(){
-    if this.back.prev != nil{ //链表长度大于1
-        this.back.prev.next = nil
-    }else{                      //链表长度小于等于1
-        this.front = nil
-    }
-    
-    this.back = this.back.prev
+func (this *LRUCache) remove(n *node) {
+	n.prev.next = n.next
+	n.next.prev = n.prev
+	n.prev = nil
+	n.next = nil
 }
 
-
-func (this *LRUCache)insert_front(node *list){
-    if this.back == nil{
-        //空表
-        this.back = node
-    }else{ //头插法
-        node.next = this.front
-        this.front.prev = node
-    }
-    
-    this.front = node
+func (this *LRUCache) pushFront(n *node) {
+	n.prev = this.head
+	n.next = this.head.next
+	this.head.next.prev = n
+	this.head.next = n
 }
-
-
-/**
- * Your LRUCache object will be instantiated and called as such:
- * obj := Constructor(capacity);
- * param_1 := obj.Get(key);
- * obj.Put(key,value);
- */