leetcode 146\148\155

最新推荐文章于 2024-09-27 15:30:00 发布

Riccca

最新推荐文章于 2024-09-27 15:30:00 发布

阅读量97

点赞数

分类专栏： leetcode python 文章标签： leetcode

本文链接：https://blog.csdn.net/Riccca/article/details/113061297

版权

leetcode 同时被 2 个专栏收录

17 篇文章 0 订阅

订阅专栏

python

16 篇文章 0 订阅

订阅专栏

本文介绍了三种数据结构的实现：LRU缓存使用双向链表和哈希表实现高效查找和淘汰机制；排序链表采用归并排序的递归方法进行链表排序；最小栈通过辅助栈保持元素最小值。这些算法展示了在内存管理和高效操作方面的技巧。

摘要由CSDN通过智能技术生成

146 LRU缓存机制

# 双向链表，每个节点要存储key和value
class ListNode:
    def __init__(self, key = None, value=None):
        self.key = key
        self.value = value
        self.next = None
        self.prev = None


class LRUCache:

    def __init__(self, capacity: int):
        self.capacity = capacity
        self.hashmap = {}

        self.head = ListNode()
        self.tail = ListNode()
        self.head.next = self.tail
        self.tail.prev = self.head

    def move_node_to_tail(self, key):
        # 把node单独找出来，把该node的前后连接一下
        node = self.hashmap[key]
        node.prev.next = node.next
        node.next.prev = node.prev

        # 把node连接到tail的前一个
        node.next = self.tail 
        self.tail.prev.next = node
        node.prev = self.tail.prev
        self.tail.prev = node
    

    def get(self, key: int) -> int:
        if key in self.hashmap:
            self.move_node_to_tail(key)
        res =self.hashmap.get(key, -1)
        if res == -1:
            return res
        else:
            return res.value
    

    def put(self, key: int, value: int) -> None:
        if key in self.hashmap:
            self.move_node_to_tail(key)
            self.hashmap[key].value = value
        else:
            new = ListNode(key,value)
            if len(self.hashmap) == self.capacity:
                # 去掉hash表中第一个节点对应项
                self.hashmap.pop(self.head.next.key)
                # 删除head的后一个
                self.head.next = self.head.next.next
                self.head.next.prev = self.head
               
            # 插入到tail的前一个
            self.hashmap[key] = new
            self.tail.prev.next = new
            new.next = self.tail
            new.prev = self.tail.prev
            self.tail.prev = new

148 排序链表

归并排序，递归方法

# 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:
        if not head or not head.next: return head
        # 第一步，用双指针找中间节点，奇数找中间，偶数找中间两个节点的前一个
        slow,fast = head, head.next
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        mid = slow.next
        slow.next = None

        left = self.sortList(head)
        right = self.sortList(mid)

        res = ListNode()
        h = res

        while left and right:
            if left.val < right.val:
                h.next = left
                left = left.next
            else:
                h.next = right
                right = right.next
            h = h.next

        h.next = right if not left else left

        return res.next

155 最小栈

class MinStack:

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


    def push(self, x: int) -> None:
        if not self.stack: 
            self.stack.append((x,x))
        else:
            self.stack.append((x, min(x,self.stack[-1][1])))


    def pop(self) -> None:
        self.stack.pop()


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


    def getMin(self) -> int:
        return self.stack[-1][1]

# 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()