python 三种存储数据的方式 Stack 、Queue、链表（无序、有序）

1、Stack

python 中Stack的实现方式

class Stack:
    def __init__(self):
        self.items=[]
    def isEmpty(self):
        return self.items==[]
    def push(self,item):
        self.items.append(item)
    def pop(self):
        return self.items.pop()
    def peek(self):
        return self.items[len(self.items)-1]
    def size(self):
        return len(self.items)

用Stack检验（）是否匹配的问题

from Stack import Stack
def check(symbolString):
    s=Stack()
    balanced=True
    index=0
    while index<len(symbolString) and balanced:
        symbol=symbolString[index]
        if symbol=="(":
            s.push(symbol)
        else:
            if s.isEmpty():
                balanced=False
            else:
                s.pop()
        index+=1
    if balanced and s.isEmpty():
        return True
    else:
        return False
print(check("((()))"))
print(check("(()))"))

检验{【（）】}是否匹配

from Stack import Stack
def check2(symbolString):
    index=0
    s=Stack()
    balanced=True
    while index<len(symbolString) and balanced:
        symbol=symbolString[index]
        if symbol in "({[":
            s.push(symbol)
        else:
            if s.isEmpty():
                balanced=False
            else:
                a=s.pop()
                if not match(a,symbol):
                    balanced=False
        index+=1
    if balanced and s.isEmpty():
        return True
    else:
        return False
def match(s1,s2):
    opens="({["
    ends=")}]"
    return opens.index(s1)==ends.index(s2)
print(check2("([{}])"))
print(check2("([{]})"))

用Stack将十进制转化为16进制一下的任意进制

from Stack import Stack
def ten_to_whatever(number,base):
    s=Stack()
    biao="0123456789ABCDEF"
    while number>0:
        s.push(number%base)
        number//=base
    a=""
    while not s.isEmpty():
        a+=biao[s.pop()]
    return a
print(ten_to_whatever(100,16))

用Stack实现中缀转后缀（中缀和后缀的定义可以百度）

from Stack import Stack
def convert(suanshi):
    prec={}
    prec["*"]=3
    prec["/"]=3
    prec["+"] = 2
    prec["-"] = 2
    prec["("] = 1
    s=Stack()
    output=[]
    tokenlist=suanshi.split()
    for token in tokenlist:
        if token in "0123456789" or token in "ABCDEFGHIGKLMNOPQRSTUVWXYZ":
            output.append(token)
        elif token=="(":
            s.push(token)
        elif token==")":
            item=s.pop()
            while item!="(":
                output.append(item)
                item=s.pop()
        else:
            while(not s.isEmpty())and (prec[s.peek()])>=prec[token]:
                output.append(s.pop())
            s.push(token)
    while not s.isEmpty():
        output.append(s.pop())
    return " ".join(output)
print(convert("( A + B ) * C"))

后缀算法的具体计算数值

from Stack import Stack
def jisuan(input_string):
    s=Stack()
    tokenlist=input_string.split()
    for token in tokenlist:
        if token in "0123456789":
            s.push(int(token))
        else:
            a2=s.pop()
            a1=s.pop()
            result=doMath(token,a1,a2)
            s.push(result)
    return s.pop()
def doMath(op,op1,op2):
    if op=="*":
        return op1*op2
    elif op == "/":
        return op1 / op2
    elif op=="+":
        return op1+op2
    else:
        return op1-op2
print(jisuan("3 6 + 2 *"))

2、Queue

python中Queue的实现

class Queue:
    def __init__(self):
        self.items=[]
    def isEmpyt(self):
        return self.items==[]
    def enqueue(self,item):
        self.items.insert(0,item)
    def dequeue(self):
        return self.items.pop()
    def size(self):
        return len(self.items)

用Queue模拟打印机的打印

from Queue import Queue
import random

class printer:
    def __init__(self,ppm):
        self.pagerate=ppm #打印时间
        self.currentTask=None #当前打印任务
        self.timeRemaining=0#任务倒计时（还剩下多少任务）
    def tick(self):
        if self.currentTask!=None:
            self.timeRemaining=self.timeRemaining-1#每调用一次tick函数判断当前任务是否为空，不为空则任务倒计时减去1秒
            if self.timeRemaining<=0:
                self.currentTask=None  #如果任务倒计时小于零，说明没有任务
    def busy(self):#判断打印机是否在工作，在工作返回true，不在工作返回false
        if self.currentTask!=None:
            return True
        else:
            return False
    def startNext(self,newtask):#将打印任务作为参数传入
        self.currentTask=newtask#打印任务赋值给当前打印任务
        self.timeRemaining=newtask.getPages()*60/self.pagerate#打印结束倒计时等于总页数除以每分钟打印的页数*60秒->总共需要多少秒

class Task:
    def __init__(self,time):
        self.timestamp=time #打印作业被生成的时间
        self.pages=random.randrange(1,21)#打印作业的页数
    def getStamp(self):
        return self.timestamp #获得打印作业生成的时间
    def getPages(self):
        return self.pages #获得打印作业的页数
    def waitTime(self,currenttime):
        return currenttime-self.timestamp #计算等待时间

def newPringTask():
    num=random.randrange(1,181) #随机数，1/180分之一的概率生成新的作业
    if num==180:
        return True
    else:
        return False

def simulation(numSeconds,pagesPerMinute):
    labprinter=printer(pagesPerMinute)#初始化打印对象
    printQueue=Queue()#打印队列
    waitingtimes=[]#等待时间的队列
    for currentSecond in range(numSeconds):
        if newPringTask():#如果碰到了随机数，
            task=Task(currentSecond)#生成打印任务
            printQueue.enqueue(task)#将打印任务加入队列
        if(not labprinter .busy()) and (not printQueue.isEmpyt()):#如果打印机空闲并且有打印任务
            nexttask=printQueue.dequeue()#打印任务出队列
            waitingtimes.append(nexttask.waitTime(currentSecond))#将这个作业的等待时间加入列表
            labprinter.startNext(nexttask)#将新的打印任务传入
        labprinter.tick()#打印一秒
    averageWait=sum(waitingtimes)/len(waitingtimes)#计算平均等待时长
    print("Average Wait %6.2f secs %3d tasks remaining ." %(averageWait,printQueue.size()))#打印平均等待时长和队列中剩余的作业
if __name__ == '__main__':
    for i in range(10):
        simulation(3600,10)#模拟十次，每次市场设置为3600秒，打印速度设置为每分钟十页
        

双端队列的实现

class Deque:
    def __init__(self):
        self.items=[]
    def isEmpty(self):
        return self.items==[]
    def addFront(self,item):
        self.items.append(item)
    def addRear(self,item):
        self.items.insert(0,item)
    def removeFront(self):
        return self.items.pop()
    def removeRear(self):
        return self.items.pop(0)
    def size(self):
        return len(self.items)

双端队列模拟回纹词的判定

from Deque import Deque
def hui_wen_ci(myStr):
    deque=Deque()
    pd=True
    for i in myStr:
        deque.addRear(i)
    while pd and deque.size()>1:
        first=deque.removeFront()
        last=deque.removeRear()
        if first!=last:
            pd=False
    return pd
if __name__ == '__main__':
    print(hui_wen_ci("上海自来水来自海上"))

3、链表（无序）

无序链表的实现

class Node:
    def __init__(self,initdata):
        self.data=initdata
        self.next=None
    def getData(self):
        return self.data
    def getNext(self):
        return self.next
    def setData(self,newdata):
        self.data=newdata
    def setNext(self,newnext):
        self.next=newnext
class UnorderedList:
    def __init__(self):
        self.head=None
    def isEmpty(self):
        return self.head==None
    def add(self,item):
        temp=Node(item)
        temp.setNext(self.head)
        self.head=temp
    def search(self,item):
        current=self.head
        found=False
        while current!=None and not found:
            if current.getData()==item:
                found=True
            else:
                current=current.getNext()
        return found
    def size(self):
        current=self.head
        count=0
        while current!=None:
            count=count+1
            current=current.getNext()
        return count
    def remove(self,item):
        current=self.head
        previous=None
        found=False
        while not found:
            if current.getData()==item:
                found=True
            else:
                previous=current
                current=current.getNext()
        if current==None:
            self.head=current.getNext()
        else:
            previous.setNext(current.getNext())

4、链表（有序）

有序链表的实现

class Node:
    def __init__(self,initdata):
        self.data=initdata
        self.next=None
    def getData(self):
        return self.data
    def getNext(self):
        return self.next
    def setData(self,newdata):
        self.data=newdata
    def setNext(self,newnext):
        self.next=newnext
class OrderedList:
    def __init__(self):
        self.head=None
    def search(self,item):
        current=self.head
        found=False
        stop=False
        while current!=None and not found and not stop:
            if current.getData()==item:
                found=True
            else:
                if current.getData()>item:
                    stop=True
                else:
                    current=current.getNext()
        return found
    def add(self,item):
        current=self.head
        previous=None
        stop=False
        while current!=None and not stop:
            if current.getData()>item:
                stop=True
            else:
                previous=current
                current=current.getNext()
        temp=Node(item)
        if previous==None:
            temp.setNext(self.head)
            self.head=temp
        else:
            temp.setNext(current)
            previous.setNext(temp)