python_3_队栈实现

1 数组实现循环队

class Queue:
    def __init__(self):
        self.list = []
        self.limit = 0
        self.head = 0
        self.trail = 0

    def MyQueue(self,limit):
        self.list = [0] * limit
        self.limit = limit

    def EnQueue(self,val):
        if (self.trail + 1) % self.limit == self.head:
            print("队列满了")
        else:
            self.list[self.trail] = val
            self.trail = (self.trail + 1) % self.limit

    def DeQueue(self):
        if self.trail == self.head:
            print("队列为空")
        else:
            val = self.list[self.head]
            self.head = (self.head + 1) % self.limit
            return val

    def is_empty(self):
        if self.trail == self.head:
            return True
        else:
            return False

    def is_full(self):
        if (self.trail + 1) % self.limit == self.head:
            return True
        else:
            return False

    def length(self):
        return (self.trail - self.head + self.limit) % self.limit
    

2 数组实现顺序栈

顺序栈的实现：https://zhuanlan.zhihu.com/p/97881563
https://blog.youkuaiyun.com/qq_42730750/article/details/107870002
链栈的实现：https://blog.youkuaiyun.com/dangfulin/article/details/110098134
https://blog.youkuaiyun.com/qq_42730750/article/details/107870084

class Stack:
    def __init__(self):
        self.arr = [] * limit
        self.size = 0
        self.limit = 0

    def MyStack(self,limit):
        self.arr = [0] * limit
        self.limit = limit

    def pushstack(self,val):
        if self.size == self.limit:
            print("栈满")
        else:
            self.arr[self.size] = val
            self.size = self.size + 1

    def popstack(self):
        if self.size == 0:
            print("没有元素")
        else:
            val = self.arr[self.size-1]
            self.size = self.size - 1
            print(val)

S1 = Stack()
S1.MyStack(5)
S1.pushstack(1)
S1.pushstack(2)
S1.pushstack(3)
S1.pushstack(4)
S1.pushstack(5)
S1.popstack()
S1.pushstack(10)
S1.popstack()

3 关于栈题目

3.1 （1）第一问

class Stack:                       # 普通栈操作
    def __init__(self):            # 初始化栈参数
        self.arr = [0]
        self.size = 0
        self.limit = 0

    def Mystack(self, limit):
        self.arr = [0] * limit
        self.limit = limit

    def push(self,val):
        if self.size == self.limit:
            print("栈满")
        else:
            self.arr[self.size] = val
            self.size += 1

    def pop(self):
        if self.size == 0:
            print("栈为空")
        else:
            self.size = self.size - 1
            val = self.arr[self.size]
            print("已出栈的数为" + str(val))

    def travl(self):                         # 遍历栈
        if self.size == 0:
            print("栈为空")
        else:
            for i in range(self.size):
                print(self.arr[i])

    def is_empty(self):                     # 栈判空
        if self.size == 0:
            return True

    def getTopval(self):                   # 得到栈顶元素
        val = self.arr[self.size-1]
        return val


class Stack2:                       # 特殊栈类
    def __init__(self):             # 初始化两个栈
        self.S = Stack()            # 普通栈
        self.S_min = Stack()        # 最小值栈

    def mystack(self,limit):        # 设定参数
        self.S.Mystack(limit)
        self.S_min.Mystack(limit)

    def Push(self,val):             # 给两个栈入栈
        self.S.push(val)
        if self.S_min.is_empty():
            self.S_min.push(val)
        elif self.S_min.getTopval() > val:     # 如果栈顶的数大于输入的数，则入栈，此时最小栈栈顶是最小值
            self.S_min.push(val)
        else:
            val = self.S_min.getTopval()       # 如果栈顶的数小于输入的数，则复制栈顶数再次入栈，此时最小栈栈顶也是最小值
            self.S_min.push(val)

    def Pop(self):
        self.S.pop()
        self.S_min.pop()

    def travl(self):         # 同名函数应该不会混掉把
        self.S.travl()
        self.S_min.travl()

    def getTopval(self):
        val = self.S_min.getTopval()
        return val

St = Stack2()
St.mystack(10)
St.Push(3)
St.Push(4)
St.Push(2)
St.Push(2)
St.Push(7)
St.travl()
St.Pop()
St.Pop()
St.Pop()
print()
print(St.getTopval())

4 双队列实现栈

class Queue:
    def __init__(self):
        self.list = []
        self.limit = 0
        self.head = 0
        self.trail = 0

    def MyQueue(self,limit):
        self.limit = limit + 1
        self.list = [0] * self.limit      # self.limit是用自己的值，不是外面传来的

    def EnQueue(self,val):
        if (self.trail + 1) % self.limit == self.head:
            print("队列满了")
        else:
            self.list[self.trail] = val
            self.trail = (self.trail + 1) % self.limit

    def DeQueue(self):
        if self.trail == self.head:
            print("队列为空")
        else:
            val = self.list[self.head]
            self.head = (self.head + 1) % self.limit
            return val

    def is_empty(self):
        if self.trail == self.head:
            return True

    def is_full(self):
        if (self.trail + 1) % self.limit == self.head:
            return True

    def length(self):
        return (self.trail - self.head + self.limit) % self.limit


class Stack:
    def __init__(self):
        self.Q1 = Queue()
        self.Q2 = Queue()

    def MyStack(self,limit):
        self.Q1.MyQueue(limit)
        self.Q2.MyQueue(limit)

    def is_full(self):
        if self.Q1.is_full():
            return True

    def Push(self,val):                  # 一个队列满，就算栈满
        if self.Q2.is_empty():          # 如果Q1和Q2都为空，加入Q1
            self.Q1.EnQueue(val)


    def Pop(self):
        if self.Q1.is_empty() and self.Q2.is_empty():  # 如果Q1和Q2都为空
            print("栈为空")
        elif self.Q1.is_empty() is not True and self.Q2.is_empty():
            while self.Q1.length() > 1:                # 当Q1只剩下一个元素时输出
                val = self.Q1.DeQueue()                # 输出后，Q1此时必须没有元素
                self.Q2.EnQueue(val)
            val = self.Q1.DeQueue()
            return val
        elif self.Q2.is_empty() is not True and self.Q1.is_empty():  # 如果Q1是空，Q2不为空
            while self.Q2.length() > 1:                 # 当Q2只剩下一个元素时输出
                val = self.Q2.DeQueue()                 # 输出后，Q2此时必须没有元素
                self.Q1.EnQueue(val)
            val = self.Q2.DeQueue()
            return val

s = Stack()
s.MyStack(5)
s.Push(1)
s.Push(2)
s.Push(3)
print(s.Pop())
print(s.Pop())
s.Push(4)
s.Push(5)
print(s.Pop())
print(s.Pop())

5 双栈实现队列

class Stack:                       # 普通栈操作
    def __init__(self):            # 初始化栈参数
        self.arr = [0]
        self.size = 0
        self.limit = 0

    def Mystack(self, limit):
        self.arr = [0] * limit
        self.limit = limit

    def push(self,val):
        if self.size == self.limit:
            print("栈满")
        else:
            self.arr[self.size] = val
            self.size += 1

    def pop(self):
        if self.size == 0:
            print("栈为空")
        else:
            self.size = self.size - 1
            val = self.arr[self.size]
            return val

    def travl(self):                         # 遍历栈
        if self.size == 0:
            print("栈为空")
        else:
            for i in range(self.size):
                print(self.arr[i])

    def is_empty(self):                     # 栈判空
        if self.size == 0:
            return True

    def getTopval(self):                   # 得到栈顶元素
        val = self.arr[self.size-1]
        return val

    def is_man(self):
        if self.size == self.limit:
            return True

class Queue:
    def __init__(self):
        self.S1 = Stack()                  # 这里一定要加括号啊，也不至于浪费30分钟
        self.S2 = Stack()

    def myQueue(self,limit):
        self.S1.Mystack(limit)
        self.S2.Mystack(limit)

    def push(self,val):             # 入栈
        if self.S1.is_man() is not True:
            self.S1.push(val)
        elif self.S1.is_man() and self.S2.is_empty():
            while self.S1.is_empty() is not True:          # 只要s1中有元素，就将s1种元素全部放入s2中
                num = self.S1.pop()
                self.S2.push(num)
            self.S1.push(val)                             # 排空s1后，继续入栈s1
        else:
            print("栈满")

    def pop(self):
        if self.S2.is_empty():                           # 如果s2是空的，说明数据都在s1那边，导过来
            while self.S1.is_empty() is not True:        # 如果s1有数字
                num = self.S1.pop()
                self.S2.push(num)
            val = self.S2.pop()
            return val
        elif self.S2.is_empty() is not True:           # 如果s2不空，将s2输出出去
            val = self.S2.pop()
            return val

q1 = Queue()
q1.myQueue(10)
q1.push(1)
q1.push(2)
q1.push(3)
q1.push(4)
q1.push(5)
q1.push(6)
print(q1.pop())
print(q1.pop())
print(q1.pop())
print(q1.pop())
print(q1.pop())
print(q1.pop())