代码随想录算法训练营第十天| LeetCode232.用栈实现队列 、LeetCode225. 用队列实现栈

栈和队列：

        栈是先进后出，队列是先进先出

用python怎么实现栈和队列呢？

        将列表当做堆栈来使用：

                列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

        将列表当做队列使用：

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

                用list可以，但是在使用pop(0)的时候时间复杂度为O(n)。也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。
                因此可以使用双向队列，我们保证只执行popleft()和append()，因为deque可以用索引访问，可以实现和peek相似的功能

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

一、LeetCode232.用栈实现队列

        1：题目描述（232.用栈实现队列）

        请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

        实现 MyQueue 类：

•                 void push(int x) 将元素 x 推到队列的末尾
•                 int pop() 从队列的开头移除并返回元素
•                 int peek() 返回队列开头的元素
•                 boolean empty() 如果队列为空，返回 true ；否则，返回 false

        说明：

•                 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
•                 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

         2：解题思路

        这道题是要用栈来实现队列，区别在于栈是先进后出，队列是先进先出，因此要实现先进入栈的元素，先出来，所以我们可以用两个栈来进行操作。一个用来进行push(入栈)，一个用来进行pop(出栈)。

        第一步：先初始化两个栈，stack_in = []，stack_out = []。

        第二步：实现void push(int x)函数，将x推到队列的末尾，即栈的末尾，列表的append()可以将元素添加到列表的末尾，stack_in.append(x)。

        第三步：实现int pop() 从队列的开头移除并返回元素

                首先判断队列是否为空，为空直接返回None。

                判断stack_out是否为空，不为空，则将stack_out中最后一个元素弹出（因为stack_out是用来出栈的，此时stack_out中的出栈顺序与队列的出队列的顺序一直，需要将stack_out中所有的元素全部弹出，才能往stack_out中添加新的元素，不然出栈的顺序就与队列的不一样了）。

                stack_out为空，则说明现在没有需要出栈的元素，将stack_in中的元素从后往前依次加入到stack_out中（因为要保持先进先出，stack_in后面的元素的后进入的，因此要先加入stack_out中，这样才能保证stack_out在出栈的时候，先进入元素先出来），stack_in中的元素全部加入stack_out中后，就可以使用列表的pop()函数，将最后一个元素（及先进入队列的元素）弹出，并返回元素的值。

        第四步：实现int peek() 返回队列开头的元素

                我们可以直接调用第三步实现的pop()函数，然后用一个变量承接弹出的元素（即队列开头的元素），再把弹出的元素，加回到stack_out中。

        第五步：boolean empty() 如果队列为空，返回 true ；否则，返回 false

                直接判断stack_in，stack_out其中一个栈是否为空，只要有一个不为空，则表明队列不为空，反之，队列为空。

class MyQueue:

    def __init__(self):
        self.stack_in = []        # 主要进行push-入栈
        self.stack_out = []       # 主要进行pop-出栈


    def push(self, x):
        self.stack_in.append(x)       # 往stack_in中push数字


    def pop(self):
        if self.empty():
            return None

        if self.stack_out:            # 当stack_out（出栈）不为空时
            return self.stack_out.pop()        # 将stack_out中的最后一个元素弹出（pop）
        else:                          # 当stack_out（出栈）为空时
            for i in range(len(self.stack_in)):         # 将stack_in中的元素全部添加到stack_out
                self.stack_out.append(self.stack_in.pop())      # 依次将stack_in中的最后一个元素弹出（pop），添加到stack_out中
            return self.stack_out.pop()                 # 将stack_out中最后一个元素弹出并返回，即是将队列的开头元素弹出并返回


    def peek(self):
        res = self.pop()              # 调用self.pop()，将stack_out中的最后一个元素弹出，即是将队列的开头元素弹出
        self.stack_out.append(res)    # 再把弹出的元素重新放到stack_out的最后位置
        return res                    # 返回弹出的最后一个元素


    def empty(self):
        if self.stack_out or self.stack_in:         # 当stack_out和stack_in中有一个不为空，返回False
            return False
        else:
            return True

二、LeetCode225. 用队列实现栈

        1：题目描述（225. 用队列实现栈）

        请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

        实现 MyStack 类：

•                 void push(int x) 将元素 x 压入栈顶。
•                 int pop() 移除并返回栈顶元素。
•                 int top() 返回栈顶元素。
•                 boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

        注意：

•                 你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
•                 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

        2：解题思路

        用队列来实现栈，就是要实现，先进入的元素后出，后进入的元素先出。

        解法一：使用两个队列来实现栈

        第一步：使用deque()初始化两个队列,queue_in（负责存数据），queue_out（在pop的时候用）

        第二步：实现void push(int x) 将元素 x 压入栈顶

                使用append(x)，往queue_in中添加元素

        第三步：实现int pop() 移除并返回栈顶元素

                首先判断栈是否为空，为空则直接返回None

                然后获取存数据的队列queue_in的长度，我们需要将queue_in最后一个元素之前的元素按照从前往后依次加入到queue_out中（因为栈是后进入的元素，先出，所以需要将最后一个元素之前的元素依次加到另外一个队列中），这样queue_in中的元素就是需要弹出的元素（栈中最先弹出的元素）

                但是我们规定了queue_in是用来存数据的，queue_out是在pop()时使用的，所以我们将queue_in和queue_out两个队列进行交换，这样需要弹出的元素就在queue_out中了，我们再弹出这个元素。

        第四步：实现int top() 返回栈顶元素

                首先也需要判断栈是否为空，为空则直接返回None

                因为我们是用列表实现的队列，栈顶的元素就是列表的最后一个元素，我们直接返回列表的最后一个元素

        第五步：实现boolean empty() 如果栈是空的，返回 true ；否则，返回 false 

                因为一直是queue_in在存数据，所以我们只要判断queue_in的长度是否等于0，等于0则表示栈是空的，反之则不是空的。

# 使用两个队列来实现栈
class MyStack:

    def __init__(self):
        self.queue_in = deque()             # 初始化一个队列,往队列中存数据
        self.queue_out = deque()            # 在pop的时候使用


    def push(self, x):
        self.queue_in.append(x)        # 将元素入队列


    def pop(self):
        if self.empty():
            return None
        size = len(self.queue_in)           # 获取队列的长度
        # 将队列中最后一个元素之前的元素依次从队列中取出，再加入queue_out队列
        for i in range(size-1):
            self.queue_out.append(self.queue_in.popleft())
        
        # 将queue_in和queue_out进行交换,保证queue_in一直是存数据的
        self.queue_in, self.queue_out = self.queue_out, self.queue_in
        # 这样queue_out中剩余的最后一个元素就是栈顶的元素 
        return self.queue_out.popleft()
           


    def top(self):
        if self.empty():
            return None
        # 直接返回队列中的最后一个元素
        return self.queue_in[-1]


    def empty(self):
        if len(self.queue_in) == 0:        # 只要stack_in中存了数据，所以判断stack_in的长度为不为0即可
            return True
        else:
            return False

         解法二：使用一个队列来实现栈

        我们只需要将队列中最后一个元素之前的元素弹出，再将弹出的元素依次添加进队列，这样将最后一个元素之前的元素全部进行移动后，最后一个元素成为了第一个元素，此时弹出元素就实现了栈的后进入的元素，先出

        第一步：使用deque()初始化一个队列,queue

        第二步：实现void push(int x) 将元素 x 压入栈顶

                使用append(x)，往queue中添加元素

        第三步：实现int pop() 移除并返回栈顶元素

                首先判断栈是否为空，为空则直接返回None

                然后获取存数据的队列queue的长度，我们需要将queue最后一个元素之前的元素按照从前往后依次弹出，再加入到queue中（因为栈是后进入的元素，先出，所以需要将最后一个元素移动到队列的开头位置），这样queue中的第一个元素就是需要弹出的元素（栈中最先弹出的元素），我们再弹出这个元素。

        第四步：实现int top() 返回栈顶元素

                首先也需要判断栈是否为空，为空则直接返回None

                因为我们是用列表实现的队列，栈顶的元素就是列表的最后一个元素，我们直接返回列表的最后一个元素

        第五步：实现boolean empty() 如果栈是空的，返回 true ；否则，返回 false 

                只要判断queue是否为空，为空则表示栈是空的，反之则不是空的。

# 使用一个队列来实现栈
class MyStack:

    def __init__(self):
        self.queue = deque()             # 初始化一个队列

    def push(self, x):
        self.queue.append(x)        # 将元素入队列

    def pop(self):
        if self.empty():
            return None
        size = len(self.queue)           # 获取队列的长度
        # 将队列中最后一个元素之前的元素依次从队列中取出，再加入队列
        for i in range(size-1):
            self.queue.append(self.queue.popleft())
        # 这样队列的第一个元素，就是栈顶元素
        return self.queue.popleft()
           
    def top(self):
        if self.empty():
            return None
        # 直接返回队列中的最后一个元素
        return self.queue[-1]

    def empty(self):
        if self.queue:
            return False
        else:
            return True