代码随想录算法训练营day10 | 232.用栈实现队列、225. 用队列实现栈

理论基础

在使用list实现stack时，添加元素(append)和删除(pop)元素时间复杂度为O(1)；而在使用list实现queue时，添加(append)元素是O(1)，而删除(pop(0))元素时间复杂度为O(n)

在使用deque实现stack时，和list一样高效，append和pop；在使用deque实现queue时，添加和删除元素(append和popleft)的时间复杂度还是O(1)，比list高效

实现stack

	list	deque
添加元素	append(x) 复杂度O(1)	append(x)  复杂度O(1)
删除元素	pop()  复杂度O(1)	pop()  复杂度O(1)

实现queue

	list	deque
添加元素	append(x) 复杂度O(1)	append(x) 复杂度O(1)
删除元素	pop(0)  复杂度O(n)	popleft() 复杂度O(1)

232.用栈实现队列

两个栈实现一个队列，一个输出栈，一个输入栈

class MyQueue:

    def __init__(self):
        self.stack1 = list()
        self.stack2 = list()

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

    def pop(self) -> int:
        if self.stack2:
            return self.stack2.pop()
        while self.stack1:
            self.stack2.append(self.stack1.pop())
        return self.stack2.pop()

    def peek(self) -> int:
        if self.stack2:
            return self.stack2[-1]
        while self.stack1:
            self.stack2.append(self.stack1.pop())
        return self.stack2[-1]

    def empty(self) -> bool:
        if not self.stack1 and not self.stack2:
            return True
        return False

优化点

pop 函数可在最开始判断是否为空

def pop(self) -> int:
                                                                                        
    """
    Removes the element from in front of queue and returns that element.
    """
    if self.empty():
        return None

peek函数可调用pop，然后将元素再放回去

def peek(self) -> int:
    """
    Get the front element.
    """
    ans = self.pop()
    self.stack_out.append(ans)
    return ans

225. 用队列实现栈

用两个队列实现栈

出栈的时候需要将有元素的队列只保留一个元素，其它都导入另一个队列

from collections import deque
class MyStack:
    def __init__(self):
        self.queue1 = deque()
        self.queue2 = deque()

    def push(self, x: int) -> None:
        if self.queue1:
            self.queue1.append(x)
        else:
            self.queue2.append(x)

    def pop(self) -> int:
        if self.empty():
            return None
        # 确保queue1不为空
        if self.queue2:
            self.queue1, self.queue2 = self.queue2, self.queue1
        for i in range(len(self.queue1)-1):
            self.queue2.append(self.queue1.popleft())
        return self.queue1.popleft()

    def top(self) -> int:
        res = self.pop()
        self.queue2.append(res)
        return res

    def empty(self) -> bool:
        return not (self.queue1 or self.queue2)

用一个队列实现栈，更加简洁

出栈的时候直接将当前队列的元素重新压进去，只到只剩下最后一个元素

from collections import deque
class MyStack:
    def __init__(self):
        self.queue = deque()

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

    def pop(self) -> int:
        if self.empty():
            return None
        for i in range(len(self.queue)-1):
            self.queue.append(self.queue.popleft())
        return self.queue.popleft()

    def top(self) -> int:
        res = self.pop()
        self.queue.append(res)
        return res

    def empty(self) -> bool:
        return not self.queue