【DW组队学习—LeetCode】day12

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
  提示：
• 1 <= capacity <= 3000
• 0 <= key <= 3000
• 0 <= value <= 104
• 最多调用 3 * 104次 get 和 put

需要注意的是当缓存不够时，最先被删除的是最久未被使用的点

尝试思路1：列表
根据指定长度，若列表不够长，则向里面添加，若够长，则进行更替或者更新
更替是删除最前面的元素，更新是删除原先的元素，均在列表末尾加入新元素

代码：

class LRUCache:

    def __init__(self, capacity: int):
        self.l = []
        self.capacity = capacity

    def get(self, key: int) -> int:
        for i in range(len(self.l)):
            if key in self.l[i]:
                return self.l[i][1]
        return -1

    def put(self, key: int, value: int) -> None:
        for i in range(len(self.l)):
            if self.l[i][0] == key:#key已存在
                self.l.remove(self.l[i])
                self.l.append([key, value])
                return
        if len(self.l) >= self.capacity:#key不存在
            self.l.remove(self.l[0])
        self.l.append([key, value])
                
# Your LRUCache object will be instantiated and called as such:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)

【错误】测试算例出错

虽然用的不是什么有技术含量的方法，看题解用的是哈希表，但个人觉得这个实例确实觉得在答案上有一定歧义。题目中说当缓存满时删除最久未使用的数据值，按照排入循序，最先删除的应该是[1,1]，但答案中先删除的是[2,2]，感觉题目描述还是有些不够严谨。也可能是我个人理解有误

148. 排序链表

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

输入：head = [4,2,1,3] 输出：[1,2,3,4]
【示例 2】

输入：head = [-1,5,3,4,0] 输出：[-1,0,3,4,5]
【示例 3】输入：head = [] 输出：[]
提示：

• 链表中节点的数目在范围 [0, 5 * 104] 内
• -10^5 <= Node.val <= 10^5

尝试思路：暴力法
直接将链表中所有数据提取出来，排序，然后写新的链表

代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def sortList(self, head: ListNode) -> ListNode:
        l = []
        node = ListNode(0, None)
        result = node
        while head:
            l.append(head.val)
            head = head.next
        l.sort()
        for i in l:
            node.next = ListNode(i, None)
            node = node.next
        return result.next

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.
提示：

• pop、top 和 getMin 操作总是在 非空栈 上调用。

尝试思路：用列表实现
增：append(number)
删：del l[index]
取顶：l[-1]
最小：min(l)

代码：

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.s = []


    def push(self, x: int) -> None:
        self.s.append(x)

    def pop(self) -> None:
        del self.s[-1]

    def top(self) -> int:
        return self.s[-1]

    def getMin(self) -> int:
        return min(self.s)


# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(x)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

【注】列表中几种删除元素方法及其区别：

1. remove: 删除单个元素，删除首个符合条件的元素，按值删除
2. pop: 删除单个或多个元素，按位删除(根据索引删除)，删除时会返回被删除的元素
3. del：它是根据索引(元素所在位置)来删除

一开始编写时用了remove所以一直不对，后来改用del才正确