代码随想录算法训练营第十天| 理论基础、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()的时候两个进行交换
        """

你可能感兴趣的:(链表,数据结构)