基于python的数据结构与算法（北京大学）课程中的代码实现（队列部分）

• 什么是队列（Queue）？
  队列是一种有次序的数据集合，其特征是，新数据项的添加总发生在一端(通常称为"尾(rear)"端)；
  而现存数据项的移除总发生在另一端（通常称为”首(front)“端）
  当数据项加入队列，首先出现在队尾，随着首数据项的移除，它逐渐接近队首。
  新加入的数据项必须在数据集末尾等待。这种次序安排的原则称为 先进先出(FIFO:first in first out)或 先到先服务(first-come first-served)

• 队列的应用：
  
  

• 队列的基本操作：
  queue() 创建一个空队列对象，返回值为queue对象
  enqueue(item) 将数据项item添加到队尾，无返回值
  dequeue() 从队首移除数据项，返回值为队首数据项，队列被修改
  isEmpty() 测试是否为空队列，返回值为布尔型
  size() 返回队列中数据项的个数

  例如：
  

• python实现队列

class Queue():
def __init__(self):
self.queque = []
def enqueue(self,item):
self.queue.append(item)
def dequeue(self):
return self.queue.pop(0)
def isEmpty(self):
return self.queque == []
def size(self):
return len(self.queque)

标准代码选择将列表头当作队尾，列表尾当作队首。让enqueue（）的复杂度为O（n），dequeue的复杂度为O（1）。
标准代码如下：

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

• 队列解决热土豆问题（约瑟夫问题）
  什么是热土豆问题：
  类似“击鼓传花”问题，但将“击鼓”的过程设置为传递固定人数。
  算法思路：
  1.用队列来实现热土豆问题的算法，参加游戏的人名列表，以及传土豆次数num，算法返回最后剩下的人名。
  2.采用队列存放参加游戏的人名，按照传递土豆方向从队首排到队尾，游戏时，队首始终是持有土豆的人。
  3.游戏开始，只需要将队首的人出队，随即再到队尾入队，算是土豆的一次传递，传递了num次后，将队首的人移除，不再入队，如此反复，直到队里剩余1个人。

def HotPotato(namelist,num):
Q = Queue()
for name in namelist:
Q.enqueue(name)
while Q.size() > 1:
for i in range(num):
temp = Q.dequeue()
Q.enqueue(temp)
Q.dequeue()
return namelist[0]

print(HotPotato(['A','B','C','D','E','F'],4))

自写代码不够简洁，引入了一个可以忽略的变量temp，来进行出队入队时的存储，标准代码为：

def hotPotato(namelist,num):
simqueue = Queue()
for name in namelist:
simqueue.enqueue(name)

while simqueue.size() > 1:
for i in range(num):
simqueue.enqueue(simqueue.dequeue())
simqueue.dequeue()

return simqueue.dequeue()

• 队列模拟打印任务：
  打印任务具体实例配置如下：一个实验室，在任意的一个小时内，大约有10名学生在场，这一小时中，每人会发起两次打印任务，每次1-20页。
  打印机的性能是：以草稿模式打印的话，每分钟10页；以正常模式打印的话，打印质量好，但速度下降为每分钟5页。
  决策支持：找到一个让大家都不会等太久，又能尽量提高打印质量。

问题建模：

对象：打印任务、打印队列、打印机
打印任务的属性：提交时间，打印页数
打印队列的属性：具有FIFO性质的打印任务队列
打印机的属性：打印速度，是否在忙
过程：生成和提交打印任务：
确定生成概率：每180秒会有一个作业生成并提交，概率为每秒1/180
确定打印页数：实例是1-20页，也就是1-20页之间概率相同
过程：实施打印：
当前打印就是正在打印的作业
新作业开始打印时开始倒计时，回0表示打印完毕，可以处理下一个作业
模拟时间：
统一的时间框架：以秒均匀流逝的时间，设定结束时间
同步所有过程：在一个时间单位里，对生成打印任务和实施打印两个过程各处理一次

模拟流程：

创建打印队列对象。
时间按照秒的单位流逝。按照概率生成打印作业，加入打印队列；如果打印机空闲且队列不空，则取出队首作业打印，记录此作业等待时间；如果打印机忙，则按照打印速度进行1秒打印；如果当前作业打印完成，则打印机进入空闲。
时间用尽，开始统计平均等待时间。

class Printer:
def __init__(self,ppm):
self.pagerate = ppm # 打印速度
self.currentTask = None # 打印任务
self.timeRemaining = 0  # 任务倒计时

def tick(self):  # 打印1秒
if self.currentTask != None:
self.timeRemaining = self.timeRemaining - 1
if self.timeRemaining <= 0:
self.currentTask = None

def busy(self):  # 打印是否忙
if self.currentTask != None:
return True
else:
return False

def startNext(self,newtask):  # 打印新作业
self.currentTask = newtask
self.timeRemaining = newtask.getPages()*60/self.pagerate

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 newPrintTask():
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 newPrintTask():
task = Task(currentSecond)
printQueue.enqueue(task)

if (not labprinter.busy()) and (not printQueue.isEmpty()):
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()))

for i in range(10):
simulation(3600,10)