1 用陣列建立一個固定大小的棧

append 實現push(); pop 實現pop()

class arraystack:
    def __init__(self,size):  # 開始怎麼調都不成功，init 竟然寫成了int
        self.stackData=[]
        self.len=size
    def push(self,obj):
        if len(self.stackData)==self.len:
            raise Exception("The stack is full")
        else:
            self.stackData.append(obj)
    def pop(self):
        if len(self.stackData)==0:
            raise Exception("The stack is empty")
        else:
            value=self.stackData.pop()
            return value
    def peek(self):
        if len(self.stackData)==0:
            raise Exception("The stack is empty")
        else:
            value=self.stackData[-1]
            return value
        
 

2 用陣列建立一個固定大小的佇列

設定start 和end 指標控制佇列的頭尾，如果end和start 到size-1了（length=size），則跳回0位置

class arrayqueue:
    def __init__(self,size):
        self.queue=[]
        self.lenn=size
        self.end=0
        self.start=0
    length=0  #在def之外，是類變數
    def push(self,obj):
        if self.length==self.lenn:
            raise Exception("The queue is full")
        else:
            self.length+=1
            self.queue.append(obj)
            self.end=self.nextIndex(self.lenn,self.end)
            
    def poll(self):
        if self.length==0:
            raise Exception("The queue is empty")
        else:
            self.length-=1
            return self.queue.pop(self.start)
            self.start=self.nextIndex(self.lenn,self.start)
    def nextIndex(self,size,size2):
        return 0 if size2 == size-1 else size2+1
 

3 設計一個有getmin功能的棧

時間複雜度為O（1）

3.1 建立兩個棧，連續壓入最小值（若元素比當前min大，則min棧壓入min棧的棧頂元素），彈出時一起彈出

class getmin1:
    def __init__(self):
        self.data=[]
        self.minstack=[]
    def push(self,obj):
        self.data.append(obj)
        if (len(self.minstack)==0)or obj<self.getmin():
            self.minstack.append(obj)
        else:
            self.minstack.append(self.getmin())
    def pop(self):
        if len(self.minstack)==0:
            raise Exception("The stack is empty")
        self.minstack.pop()
        return self.data.pop()
    def getmin(self):
        if len(self.minstack)==0:
            raise Exception("The stack is empty")
        else:
            return self.minstack[-1]
 

3.2 只壓入比當前棧頂更小或相等的值，返回的時候，如果min和data相等，則min棧也彈出，否則不彈

class getmin2:
    def __init__(self):
        self.data=[]
        self.minstack=[]
    def push(self,obj):
        self.data.append(obj)
        if (len(self.minstack)==0)or obj<=self.getmin():
            self.minstack.append(obj)
    def pop(self):
        if len(self.minstack)==0:
            raise Exception("The stack is empty")
        value2=self.getmin()
        value1=self.data.pop()
        if value1==value2:
            self.minstack.pop()
        return value1
    def getmin(self):
        if len(self.minstack)==0:
            raise Exception("The stack is empty")
        else:
            return self.minstack[-1]

4 用佇列實現棧功能

用兩個佇列，pop時候，每次依次倒入另一個佇列直到剩一個元素，則返回剩下的那個，然後交換這兩個佇列

class queue_stack:
    def __init__(self):
        self.queue=[]
        self.helpp=[]
    def push(self,obj):
        self.queue.append(obj)
    def pop(self):
        while len(self.queue)!=1:
            self.helpp.append(self.queue.pop(0))# pop(0)-取首元素
        re=self.queue.pop()
        self.queue,self.helpp=self.helpp,self.queue
        return re
    def peek(self):
        while len(self.queue)!=1:
            self.helpp.append(self.queue.pop(0))
        re=self.queue.pop()
        self.helpp.append(re)
        self.queue,self.helpp=self.helpp,self.queue
        return re

python轉換的時候，a,b=b,a 則實現java/c的swap功能；pop(0)元素則刪除並返回隊首元素

5 用佇列實現棧功能

用兩個棧，stack負責push，helpp棧負責pop：每次從stack全部倒入help棧(help 棧為空時倒入，並且一次性全部倒入），然後從help棧裡pop

class stack_queue:
    def __init__(self):
        self.stack=[]
        self.helpp=[]
    def push(self,obj):
        self.stack.append(obj)
    def pop(self):
        if len(self.helpp)==0:
            while len(self.stack)!=0:
                self.helpp.append(self.stack.pop())
        re=self.helpp.pop()
        return re
    def peek(self):
        if len(self.helpp)==0:
            while len(self.stack)!=0:
                self.helpp.append(self.stack.pop())
        re=self.helpp[-1]
        return