Leetcode习题LRU缓存机制，排序链表，最小栈

LRU缓存机制

class ListNode:
    def __init__(self,key=None,value=None):
        self.key=key
        self.value=value
        self.prev=None
        self.next=None

class LRUCache:

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

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

        #初始化链表为head<-->tail
        
        self.head.next=self.tail
        self.tail.prev=self.head

    def move_node_to_header(self,key):
        node=self.hashmap[key] #哈希表指向的节点
        # prev<->node<->next  -->  prev<-> next...node
        node.prev.next=node.next  #node移到原next后面
        node.next.prev=node.prev  #prev<->next...node

        #将node插入头部节点前
        node.prev=self.head 
        node.next=self.head.next  #n原next到head后，head<->next ...node
        self.head.next.prev=node  #node插到head后next前 head<->node<->next
        self.head.next=node

    def add_node_to_header(self,key,value):
        new=ListNode(key, value)
        self.hashmap[key]=new
        new.prev=self.head
        new.next=self.head.next
        self.head.next.prev=new
        self.head.next=new

    def pop_tail(self):
        last_node=self.tail.prev 
        self.hashmap.pop(last_node.key) #去掉链表尾部的节点在哈希表的对应项
        last_node.prev.next=self.tail
        self.tail.prev=last_node.prev #去掉最久没被访问过的节点，即尾部tail之前的一个节点
        return last_node 


    def get(self, key: int) -> int:
        if key in self.hashmap:
            self.move_node_to_header(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.hashmap[key].value=value #如果key已经在哈希表中，更新该字典值对应节点的value
            self.move_node_to_header(key) #将该节点移到链表头部
        else:
            if len(self.hashmap)>=self.capacity:
                self.pop_tail() #容量已满，删除最不常用节点
            self.add_node_to_header(key,value)

对链表进行插入排序

class Solution:
    def insertionSortList(self, head: ListNode) -> ListNode:
        if not head:
            return head

        dummyHead=ListNode(0)
        dummyHead.next=head
        lastSorted=head
        curr=head.next

        while curr:
            if lastSorted.val<curr.val:
                lastSorted=lastSorted.next

            else:
                prev=dummyHead
                while prev.next.val<curr.val:
                    prev=prev.next

                lastSorted.next=curr.next
                curr.next=prev.next
                prev.next=curr
            curr=lastSorted.next

        return dummyHead.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:
            fast,slow=fast.next.next,slow.next

        mid,slow.next=slow.next, None  #中间分割，慢指针走到快的一半

        left,right=self.sortList(head),self.sortList(mid) #左右分别递归排序

        h=res=ListNode(0)
        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=left if left else right

        return res.next

最小栈

class MinStack:

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


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


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


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


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