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

理论基础

栈

需要自己实现，主要就是先进后出

队列

有内置的数据结构，先进先出，排队 不能用，见最后

import queue
import Stack
def test_que():
    que=queue.Queue()
    que.put(0)
    que.put(1)
    que.put(2)
    que.put(3)
    while que.qsize()>0:
        print(que.get())

if __name__=="__main__":
    test_que()

232 用栈实现队列

232 用栈实现队列-资料链接

解题思路

自己实现栈，然后两个栈当pop时把元素放在另一个即可，然后pop之后记得放回去

class MyQueue(object):

    def __init__(self):
        # 初始化2个Stack

        class my_stack():
            def __init__(self):
                self.size=0
                self.arr=[]

            def push(self,x):
                self.arr.append(x)
                self.size+=1

            def pop(self):
                if self.isEmpty()==False:
                    res=self.arr[self.size-1]
                    self.arr.pop()
                    self.size-=1
                    return res
                else:
                    return None

            def isEmpty(self):
                if self.size==0:
                    return True
                else:
                    return False

        self.s1=my_stack()
        self.s2=my_stack()
        self.size=0

    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        if self.s1.isEmpty()==False:
            self.s1.push(x)
        else:
            self.s2.push(x)
        self.size+=1

    def pop(self):
        """
        :rtype: int
        """
        if self.empty():
            return None

        if self.s1.isEmpty()==False:
            while self.s1.size!=1:
                self.s2.push(self.s1.pop())
            res=self.s1.pop()
            while self.s2.size>0:
                self.s1.push(self.s2.pop())

        else:
            while self.s2.size != 1:
                self.s1.push(self.s2.pop())
            res=self.s2.pop()
            while self.s1.size>0:
                self.s2.push(self.s1.pop())

        self.size-=1
        return res

    def peek(self):
        """
        :rtype: int
        """
        if self.empty():
            return None

        if self.s1.isEmpty() == False:
            res=self.s1.arr[0]
        else:
            res = self.s2.arr[0]
        return res


    def empty(self):
        """
        :rtype: bool
        """
        if self.size==0:
            return True
        else:
            return False



# 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()


if __name__=="__main__":
    obj = MyQueue()
    obj.push(1)
    obj.push(2)
    obj.push(3)
    obj.push(4)
    param_2 = obj.pop()
    obj.push(5)
    param_2 = obj.pop()
    param_2 = obj.pop()
    param_2 = obj.pop()
    param_2 = obj.pop()
    # param_3 = obj.peek()
    #
    # param_4 = obj.empty()

225 用队列实现栈

225 用队列实现栈-资料链接

解题思路

注意只能用 from collections import deque 这个库

from collections import deque
class MyStack(object):

    def __init__(self):
        self.que1=deque()
        self.que2=deque()
        self.size=0

    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        if len(self.que1)>0:
            self.que1.append(x)
        else:
            self.que2.append(x)
        self.size+=1


    def pop(self):
        """
        :rtype: int
        """
        if self.empty():
            return None

        if len(self.que1) >0:
            while len(self.que1())>1:
                self.que2.append(self.que1.popleft())
            res=self.que1.popleft()
            while len(self.que2)>0:
                self.que1.append(self.que2.popleft())
        else:
            while len(self.que2)>1:
                self.que1.append(self.que2.popleft())
            res=self.que2.popleft()
            while len(self.que1)>0:
                self.que2.append(self.que1.popleft())

        self.size-=1
        return res


    def top(self):
        """
        :rtype: int
        """
        if self.empty():
            return None

        if len(self.que1) >0:
            res=self.que1[-1]
        else:
            res=self.que2[-1]
        return res


    def empty(self):
        """
        :rtype: bool
        """
        if self.size==0:
            return True
        else:
            return False



# 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()

if __name__=="__main__":
    obj = MyStack()
    obj.push(1)
    obj.push(2)
    param_3 = obj.top()
    param_2 = obj.pop()
    param_4 = obj.empty()