Leetcode12-#146/148/155

---

1 #146-LRU 缓存机制

• 题目：
  运用你所掌握的数据结构，设计和实现一个 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
  

• 分析：
  字典加双向链表

• 答案：

  	class Node:
  def __init__(self,key,val):
      self.key=key
      self.val=val
      self.next=None
      self.prev=None
      
  class LRUCache:
  def __init__(self, capacity: int):
      self.dic={}
      self.head=Node(None,None)
      self.tail=Node(None,None)
      self.head.next=self.tail
      self.tail.prev=self.head
      self.capacity=capacity
  
  def get(self, key: int) -> int:
      if not key in self.dic:
          return -1
      node=self.dic[key]
      self.delete(node)
      self.insert(node)
      return node.val        
  
  def insert(self,node):
      node.next,node.prev=self.head.next,self.head
      temp=self.head.next
      self.head.next=node
      temp.prev=node
  
  def delete(self,node):
      node.prev.next,node.next.prev=node.next,node.prev
  
  def put(self, key: int, value: int) -> None:
      if key in self.dic:
          node=self.dic[key]
          node.val=value
          self.delete(node)
          self.insert(node)
          return        
      if len(self.dic)==self.capacity:
          node=self.tail.prev
          self.delete(node)
          del self.dic[node.key]
      node=Node(key,value)
      self.dic[key]=node
      self.insert(node)
  
  	```
  

参考答案

---

2 #148-排序链表

• 题目：
  给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表。
  • 进阶：
    你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？
  • 示例1：
    

  输入：head = [4,2,1,3]
  输出：[1,2,3,4]
  

• 分析：
  递归思想
• 答案：

  class Solution:
  def sortList(self, head: ListNode) -> ListNode:
      if not head or not head.next: 
          return head
      slow = head
      fast = head
      # 用快慢指针分成两部分
      while fast.next and fast.next.next:
          slow = slow.next
          fast = fast.next.next
      # 找到左右部分, 把左部分最后置空
      mid = slow.next
      slow.next = None
      # 递归下去
      left = self.sortList(head)
      right = self.sortList(mid)
      # 合并
      return self.merge(left, right)
  
  def merge(self, left, right):
      dummy = ListNode(0)
      p = dummy
      l = left
      r = right
  
      while l and r:
          if l.val < r.val:
              p.next = l
              l = l.next
              p = p.next
          else:
              p.next = r
              r = r.next
              p = p.next
      if l:
          p.next = l
      if r:
          p.next = r
      return dummy.next
  

参考答案

---

3 #155-最小栈

• 题目：
  设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

  • push(x) —— 将元素 x 推入栈中。
  • pop() —— 删除栈顶的元素。
  • top() —— 获取栈顶元素。
  • getMin() —— 检索栈中的最小元素。
  • 示例：

  输入：
  ["MinStack","push","push","push","getMin","pop","top","getMin"]
  [[],[-2],[0],[-3],[],[],[],[]]	
  输出：
  [null,null,null,null,-3,null,0,-2]
  解释：
  MinStack minStack = new MinStack();
  minStack.push(-2);
  minStack.push(0);
  minStack.push(-3);
  minStack.getMin();   --> 返回 -3.
  minStack.pop();
  minStack.top();      --> 返回 0.
  minStack.getMin();   --> 返回 -2.
  

• 分析：

• 答案：

  class MinStack(object):
  
  def __init__(self):
      """
      initialize your data structure here.
      """
      self.stack = []
      
  
  def push(self, x):
      """
      :type x: int
      :rtype: void
      """
      if not self.stack:
          self.stack.append((x, x))
      else:
          self.stack.append((x, min(x, self.stack[-1][1])))
      
  
  def pop(self):
      """
      :rtype: void
      """
      self.stack.pop()
      
  
  def top(self):
      """
      :rtype: int
      """
      return self.stack[-1][0]
      
  
  def getMin(self):
      """
      :rtype: int
      """
      return self.stack[-1][1]
  

参考答案

---