剑指Offfer练习记录 栈

没什么说的常规两个列表当做栈，既然是栈就不能用pop（0）这种操作。

class CQueue:

    def __init__(self):
        self.stackA=[]
        self.stackB=[]
       

    def appendTail(self, value: int) -> None:
        self.stackA.append(value)
       

    def deleteHead(self) -> int:
        if not self.stackB:
            while self.stackA:
                self.stackB.append(self.stackA.pop())


        if not self.stackB:
            return -1
        else:
            return self.stackB.pop()

使用heapq小顶堆 能AC但不符合要求，每次push pop 需要更新整个堆。完全是用来熟悉python 怎么生成堆。

import heapq
class MinStack:

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

    def updateHeap(self):
        self.heap=[]
        for num in self.stack:
            heapq.heappush(self.heap,num)
    
    def push(self, x: int) -> None:
        self.stack.append(x)
        self.updateHeap()

    def pop(self) -> None:
        if not self.stack:
            pass
        else :    
            self.stack.pop()
            self.updateHeap()
            return None

    def top(self) -> int:
        if not self.stack:
            return None
        else :
            return self.stack[-1]
            
    def min(self) -> int:
        if not self.stack:
            return None
        else: 
            self.updateHeap()
            return self.heap[0]

维护两个栈的操作

class MinStack:
    def __init__(self):
        self.stackA, self.stackB = [], []

    def push(self, x: int) -> None:
        self.stackA.append(x)
        if not self.stackB or self.stackB[-1] >= x:
            self.stackB.append(x)
    #如果B栈顶数大或等于新压的数则压入
    def pop(self) -> None:
        if self.stackA.pop() == self.stackB[-1]:
            self.stackB.pop()
    #如果A栈弹出的数和B栈顶一样大 则B弹出
    def top(self) -> int:
        return self.stackA[-1]

    def min(self) -> int:
        return self.stackB[-1]

利口上题解用的queue包，我用的list。解法是按思路2来的。

class MaxQueue:

    def __init__(self):
        self.stackA=[]#正常的队列
        self.stackB=[]#单调队列

    def max_value(self) -> int:
        if not self.stackB:
            return -1
        else:
            return self.stackB[0]
            
    def push_back(self, value: int) -> None:
        self.stackA.append(value)
        
        #当单调队列不为空时，弹出所以比添加值小的元素
        while self.stackB and self.stackB[-1]<value:
            self.stackB.pop()
        #然后向单调队列加入添加值
        self.stackB.append(value)
        
    def pop_front(self) -> int:
        if not self.stackB:
            return -1
        else:
            temp=self.stackA.pop(0) 
            if temp==self.stackB[0]:
                self.stackB.pop(0)
            return temp