代码随想录算法训练营第十天| 理论基础、232.用栈实现队列、225. 用队列实现栈

理论基础

栈：

定义：栈是一种线性数据结构，栈中的元素只能先入后出。最早进入的元素存放的位置叫作栈底，最后进入的元素存放的位置叫作栈顶。栈这种数据结构既可以用数组实现，也可以用链表实现。

（1）入栈（push）：入栈操作就是把新元素放入栈中，只允许从栈顶一侧放入元素，新元素的位置将会成为新的栈顶。
（2）出栈（pop）：出栈操作就是把元素从栈中弹出，只有栈顶元素才允许出栈，出栈元素的前一个元素将会成为新的栈顶。
在python语言中，列表很好的实现了栈的功能，.append()方法相当于入栈，.pop()方法相当于出栈。
————————————————
版权声明：本文为CSDN博主「算法程序员&mlh」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_43061415/article/details/123434773

要点：python中列表就可以实现栈的功能，并且最早进入的元素存放的位置叫作栈底，最后进入的元素存放的位置叫作栈顶

队列：

队列（queue）是一种线性数据结构，不同于栈的先入后出，队列中元素只能先入先出。队列的出口端叫队头，队列的入口端叫队尾。与栈类似，队列这种数据结构既可以用数组实现，也可以用链表实现。并且用数组实现时，为了入队操作的方便，把队尾位置规定为最后入队元素的下一位。

（1）入队（enqueue）：入队操作就是把新元素放入队列中，只允许在队尾的位置放元素，新元素的下一个位置将会成为新的队尾。
（2）出队（dequeue）：出队操作就是把元素移出队列，只允许在队头一侧移出元素，出队元素的后一个元素将会成为新的队头。
不断的出队和入队操作会导致队列可实际使用的容量很小，用数组实现的队列可以采用循环队列的方式来维持队列容量的恒定。
在python语言中提供了多种队列工具，比如collections.dequeue，queue.Queue等。
————————————————
版权声明：本文为CSDN博主「算法程序员&mlh」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_43061415/article/details/123434773

232. 用栈实现队列

代码：

class MyQueue:

    def __init__(self):
        self.stack_in = []
        self.stack_out = []


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


    def pop(self) -> int:
        if self.empty():
            return None
        if self.stack_out:
            return self.stack_out.pop()
        else:
            for i in range(len(self.stack_in)):
                self.stack_out.append(self.stack_in.pop())
            return self.stack_out.pop()


    def peek(self) -> int:
        ans = self.pop()
        self.stack_out.append(ans)
        return ans


    def empty(self) -> bool:
        return not (self.stack_out or self.stack_in)



# Your MyQueue object will be instantiated and called as such:
# obj = MyQueue()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.peek()
# param_4 = obj.empty()

注意点：调用成员变量和方法的时候要记得加上self.

225. 用队列实现栈

代码：

from collections import deque
class MyStack:

    def __init__(self):
        self.queue_in = deque()
        self.queue_out = deque()


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


    def pop(self) -> int:
        if self.empty():
            return None
        else:
            for i in range(len(self.queue_in) - 1):
                self.queue_out.append(self.queue_in.popleft())
            self.queue_in, self.queue_out = self.queue_out, self.queue_in
            return self.queue_out.popleft()


    def top(self) -> int:
        if self.empty():
            return None
        else:
            return self.queue_in[-1]


    def empty(self) -> bool:
        return len(self.queue_in) == 0



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

注意点：

        """
        Python普通的Queue或SimpleQueue没有类似于peek的功能
        也无法用索引访问，在实现top的时候较为困难。

        用list可以，但是在使用pop(0)的时候时间复杂度为O(n)
        因此这里使用双向队列，我们保证只执行popleft()和append()，因为deque可以用索引访问，可以实现和peek相似的功能

        in - 存所有数据
        out - 仅在pop的时候会用到
        """
        """
        1. 首先确认不空
        2. 因为队列的特殊性，FIFO，所以我们只有在pop()的时候才会使用queue_out
        3. 先把queue_in中的所有元素（除了最后一个），依次出列放进queue_out
        4. 交换in和out，此时out里只有一个元素
        5. 把out中的pop出来，即是原队列的最后一个
        
        tip：这不能像栈实现队列一样，因为另一个queue也是FIFO，如果执行pop()它不能像
        stack一样从另一个pop()，所以干脆in只用来存数据，pop()的时候两个进行交换
        """