队列与双向队列

队列类

# python
# -*- coding: utf-8 -*-
"""
__title__ = ''
__author__ = 'wlc'
__mtime__ = '2017/10/13'
"""
class pythonQueue:
    def __init__(self):
        self.items = []
    #isEmpty
    def isEmpty(self):
        return self.items == []
    #enqueue
    def enqueue(self, element):
        self.items.insert(0, element)
    #dequeue
    def dequeue(self):
        return self.items.pop()
    #queue size
    def size(self):
        return len(self.items)

双向队列类

# python
# -*- coding: utf-8 -*-
"""
__title__ = ''
__author__ = 'wlc'
__mtime__ = '2017/10/13'
"""
class pythonDeque:
    def __init__(self):
        self.items = []
    #isEmpty
    def isEmpty(self):
        return self.items == []
    #size
    def size(self):
        return len(self.items)
    #addFront
    def addFront(self, item):
        self.items.append(item)
    #addRear
    def addRear(self, item):
        self.items.insert(0, item)
    #removeFront
    def removeFront(self):
        return self.items.pop()
    #removeRear
    def removeRear(self):
        return self.items.pop(0)

使用队列模拟打印机类

# python
# -*- coding: utf-8 -*-
"""
__title__ = ''
__author__ = 'wlc'
__mtime__ = '2017/10/13'
"""
class pythonPrinter:
    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
            if self.timeRemaining <= 0:
                self.currentTask = None
    #是否忙
    def busy(self):
        if self.currentTask == None:
            return False
        else:
            return True

    #开始下一个任务
    def startNextTask(self, task):
        """
        :param task: 此处task是一个pythonPrinterTask对象
        """
        self.currentTask = task
        self.timeRemaining = task.getPage() * 60 / self.pageRate

打印机任务类

# python
# -*- coding: utf-8 -*-
"""
__title__ = ''
__author__ = 'wlc'
__mtime__ = '2017/10/13'
"""
import random
class pythonPrinterTask:
    def __init__(self, timeStamp):
        #当前的时间戳
        self.timeStamp = timeStamp
        #假设打印页数在1-20之间
        self.page = random.randrange(1,21)
    #得到时间戳
    def getStamp(self):
        return self.timeStamp
    #得到打印页数
    def getPage(self):
        return self.page
    #计算等待时间
    def waitTime(self, currentTime):
        return currentTime - self.timeStamp

相关算法实现

# python3
# -*- coding: utf-8 -*-
"""
__title__ = ''
__author__ = 'wlc'
__mtime__ = '2017/10/13'
"""
from dataStructure.dS import pythonQueue
from dataStructure.dS import  pythonPrinter
from dataStructure.dS import  pythonPrinterTask
from dataStructure.dS import  pythonDeque
import random

def hotPotato(nameList, num):
    """
    :program:烫手山芋问题 约瑟夫环
    :param nameList:
    :param num:
    :return: 最后一个人
    """
    #实例化一个队列
    queue = pythonQueue.pythonQueue()
    #将名字依次放入队列
    for list in nameList:
        queue.enqueue(list)
    #直到队列size为1 之前依次执行队列首出队列并且进入队尾
    while queue.size() > 1:
        for i in range(num):
            queue.enqueue(queue.dequeue())
        queue.dequeue()
    return queue.dequeue()
##################################################################################

def printerTask(numSeconds, pageRate):
    """
    :program:模拟打印机排队过程
    :param numSeconds: 模拟时间长度单位秒
    :param pageRate: 打印机每分钟处理页数
    :return: 队列的平均等待时间
    """
    #实例化打印对象
    printer = pythonPrinter.pythonPrinter(pageRate)
    #list 用于保存task 等待时间
    waitList = []
    #实例化一个队列用于保存task队列
    tasksQueue = pythonQueue.pythonQueue()

    #模拟给定时间段的秒数
    for currentSecond in range(numSeconds):
        #随机生成一个任务3600秒内 假设一共有20个任务平均下来大约180秒产生一个新的任务
        if newTask():
            #如果是一个新的任务则将其实例化并且添加到队列中
            taskNew = pythonPrinterTask.pythonPrinterTask(currentSecond)
            tasksQueue.enqueue(taskNew)
        #如果打印机不忙并且打印队列不是空的 就将队列的队首给打印机 并且将该队首的等待时间计算出来放到waitList列表中
        if (not printer.busy()) and (not tasksQueue.isEmpty()):
            #取出队首
            taskQueue = tasksQueue.dequeue()
            #将等待时间放到list里边保存
            waitList.append(taskQueue.waitTime(currentSecond))
            #打印机开始下一个任务
            printer.startNextTask(taskQueue)
        #打印机开始一张一张的减去
        printer.tick()
    average = sum(waitList) / len(waitList)
    print("平均等待时间%6.2f %3d 任务正在等待" %(average, int(tasksQueue.size())))

def newTask():
    """
    #program:随机产生1-180的数字 用于模拟在180秒内平均会有一次打印任务
    :return: True False
    """
    var = random.randrange(1, 181)
    if var == 180:
        return True
    else:
        return False

##################################################################################
def palChecker(str):
    """
    program:回文检测 boob
    :param str: 输入字符串
    :return: true false
    """
    #实例化一个双向队列
    palDeque = pythonDeque.pythonDeque()
    #str 的每一个字符从尾部（index为0的位置）依次保存到双向队列中
    for str0 in str:
        palDeque.addRear(str0)
    #定义一个flag 若为false则返回
    flag = True
    #直到双向队列的大小>1 等于一意味着字符数为奇数 等于零 意味为偶数
    while palDeque.size() > 1 and flag:
        front = palDeque.removeFront()
        rear = palDeque.removeRear()
        if front != rear:
            flag = False
    return  flag



if __name__ == '__main__':
    queue = pythonQueue.pythonQueue()
    print(queue.isEmpty())
    queue.enqueue('dog')
    print(queue.size())
    print(queue.items)
    pop = queue.dequeue()
    print(pop)
    print(queue.isEmpty())
    ###################################################################
    var = input("请输入排队列表以空格分隔：")
    var = [str for str in var.split()]
    var1 = input("请输入规则num：")
    result = hotPotato(var, int(var1))
    print("最后一个人是：%s" %result)
    ###################################################################
    var = int(input("请输入时间（单位秒）："))
    var1 = int(input("打印机处理速率（页/分钟）："))
    printerTask(var, var1)
    for i in range(10):
        printerTask(var, var1)
    ###################################################################
    var = input("请输入要检测回文的字符串：")
    print("检测结果："+str(palChecker(var)))