add 146 and update 0232 README

Author: lily-lee

README.md

@@ -16,6 +16,8 @@
 |     [11](./algorithms/0011)     |              [11. 盛最多水的容器](https://leetcode-cn.com/problems/container-with-most-water/)              |  [Go](./algorithms/0011/main.go)   |    中等    |
 |     [14](./algorithms/0014)     |                 [14. 最长公共前缀](https://leetcode-cn.com/problems/longest-common-prefix/)                 |  [Go](./algorithms/0014/main.go)   |    简单    |
 |     [79](./algorithms/0079)     |                        [79. 单词搜索](https://leetcode-cn.com/problems/word-search/)                        |  [Go](./algorithms/0079/main.go)   |    中等    |
+|    [146](./algorithms/0146)     |                      [146. LRU 缓存机制](https://leetcode-cn.com/problems/lru-cache/)                       |  [Go](./algorithms/0146/main.go)   |    中等    |
+|    [232](./algorithms/0232)     |             [232. 用栈实现队列](https://leetcode-cn.com/problems/implement-queue-using-stacks/)             |  [Go](./algorithms/0232/main.go)   |    简单    |
 |    [263](./algorithms/0263)     |                         [263. 丑数](https://leetcode-cn.com/problems/ugly-number/)                          |  [Go](./algorithms/0263/main.go)   |    简单    |
 | [offer47](./algorithms/offer47) |       [剑指 Offer 47. 礼物的最大价值](https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof/)       | [Go](./algorithms/offer47/main.go) |    中等    |
 

algorithms/0146/README.md

@@ -0,0 +1,48 @@
+#### [146. LRU 缓存机制](https://leetcode-cn.com/problems/lru-cache/)
+
+难度中等
+
+运用你所掌握的数据结构，设计和实现一个 [LRU (最近最少使用) 缓存机制](https://baike.baidu.com/item/LRU) 。
+
+实现 `LRUCache` 类：
+
+- `LRUCache(int capacity)` 以正整数作为容量 `capacity` 初始化 LRU 缓存
+- `int get(int key)` 如果关键字 `key` 存在于缓存中，则返回关键字的值，否则返回 `-1` 。
+- `void put(int key, int value)` 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。
+
+ 
+
+**进阶**：你是否可以在 `O(1)` 时间复杂度内完成这两种操作？
+
+ 
+
+**示例：**
+
+```
+输入
+["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
+[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
+输出
+[null, null, null, 1, null, -1, null, -1, 3, 4]
+
+解释
+LRUCache lRUCache = new LRUCache(2);
+lRUCache.put(1, 1); // 缓存是 {1=1}
+lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
+lRUCache.get(1);    // 返回 1
+lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
+lRUCache.get(2);    // 返回 -1 (未找到)
+lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
+lRUCache.get(1);    // 返回 -1 (未找到)
+lRUCache.get(3);    // 返回 3
+lRUCache.get(4);    // 返回 4
+```
+
+ 
+
+**提示：**
+
+- `1 <= capacity <= 3000`
+- `0 <= key <= 10000`
+- `0 <= value <= 105`
+- 最多调用 `2 * 105` 次 `get` 和 `put`

algorithms/0146/main.go

@@ -0,0 +1,88 @@
+package _0146
+
+type LRUCache struct {
+	cap  int
+	m    map[int]*Node
+	head *Node
+	tail *Node
+}
+
+type Node struct {
+	key   int
+	value int
+	prev  *Node
+	next  *Node
+}
+
+func Constructor(capacity int) LRUCache {
+	c := LRUCache{
+		cap:  capacity,
+		m:    map[int]*Node{},
+		head: &Node{},
+		tail: &Node{},
+	}
+	c.head.next = c.tail
+	c.tail.prev = c.head
+	return c
+}
+
+func (this *LRUCache) Get(key int) int {
+	node, ok := this.m[key]
+	if !ok {
+		return -1
+	}
+	this.addToFirst(node)
+	return node.value
+
+}
+func (this *LRUCache) addToFirst(node *Node) {
+	if this.head.next == node {
+		return
+	}
+	firstOld := this.head.next
+	prev := node.prev
+	next := node.next
+
+	if prev != nil {
+		prev.next = next
+	}
+	if next != nil {
+		next.prev = prev
+	}
+
+	firstOld.prev = node
+	node.next = firstOld
+	node.prev = this.head
+	this.head.next = node
+	this.m[node.key] = node
+}
+
+func (this *LRUCache) removeLast() {
+	last := this.tail.prev
+	delete(this.m, last.key)
+	prev := last.prev
+	this.tail.prev = prev
+	prev.next = this.tail
+}
+
+func (this *LRUCache) Put(key int, value int) {
+	node, ok := this.m[key]
+	if ok {
+		node.value = value
+	} else {
+		node = &Node{key: key, value: value}
+	}
+	this.addToFirst(node)
+	this.m[key] = node
+
+	if len(this.m) > this.cap {
+		this.removeLast()
+	}
+}
+
+/**
+ * Your LRUCache object will be instantiated and called as such:
+ * obj := Constructor(capacity);
+ * param_1 := obj.Get(key);
+ * obj.Put(key,value);
+ */

algorithms/0232/README.md

@@ -0,0 +1,55 @@
+#### [232. 用栈实现队列](https://leetcode-cn.com/problems/implement-queue-using-stacks/)
+
+难度简单
+
+请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（`push`、`pop`、`peek`、`empty`）：
+
+实现 `MyQueue` 类：
+
+- `void push(int x)` 将元素 x 推到队列的末尾
+- `int pop()` 从队列的开头移除并返回元素
+- `int peek()` 返回队列开头的元素
+- `boolean empty()` 如果队列为空，返回 `true` ；否则，返回 `false`
+
+ 
+
+**说明：**
+
+- 你只能使用标准的栈操作 —— 也就是只有 `push to top`, `peek/pop from top`, `size`, 和 `is empty` 操作是合法的。
+- 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
+
+ 
+
+**进阶：**
+
+- 你能否实现每个操作均摊时间复杂度为 `O(1)` 的队列？换句话说，执行 `n` 个操作的总时间复杂度为 `O(n)` ，即使其中一个操作可能花费较长时间。
+
+ 
+
+**示例：**
+
+```
+输入：
+["MyQueue", "push", "push", "peek", "pop", "empty"]
+[[], [1], [2], [], [], []]
+输出：
+[null, null, null, 1, 1, false]
+
+解释：
+MyQueue myQueue = new MyQueue();
+myQueue.push(1); // queue is: [1]
+myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
+myQueue.peek(); // return 1
+myQueue.pop(); // return 1, queue is [2]
+myQueue.empty(); // return false
+```
+
+
+
+ 
+
+**提示：**
+
+- `1 <= x <= 9`
+- 最多调用 `100` 次 `push`、`pop`、`peek` 和 `empty`
+- 假设所有操作都是有效的 （例如，一个空的队列不会调用 `pop` 或者 `peek` 操作）