队列 | Python数据结构

队列抽象数据类型

Queue（）创建一个空队列。它不需要参数，且会返回一个空队列

enqueue（item）在队列的尾部添加一个元素。它不需要一个元素作为参数，不返回任何值

dequeue（）从队列的头部移除一个元素。它不需要参数，且会返回一个元素，并修改队列的内容。

is_empty（）检查队列是否为空。它不需要参数，且会返回一个布尔值。

size（）返回队列中元素的数目。它不需要参数，且会返回一个整数。

class MyQueue(object):
    def __init__(self):
        self.items = []

    def enqueue(self, item):
        self.items.append(item)

    def dequeue(self):
        return self.items.pop(0)

    def is_empty(self):
        return self.items == []

    def size(self):
        return len(self.items)

传土豆问题

这个游戏中，孩子们围成一圈，并依次尽可能快地传递一个土豆，大家停止传递，此时手中有土豆地孩子就得退出游戏。

其实这个问题可以见简化成如下问题

def hot_potato(name_list, num):
    q = MyQueue()
    for name in name_list:
        q.enqueue(name)

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

        q.dequeue()

    return q.dequeue()

模拟打印任务

主要步骤

1. 创建一个打印任务队列。每个任务到来时都会有一个时间戳。一开始，队列是空的。

2. 针对每一秒（currentSecond），执行以下操作。

3. 是否有新创建的打印任务？如果是，以currentSecond作为其时间戳并将该任务加入到队列中。

4. 如果打印机空闲，并且有正在等待执行的任务，执行以下操作：

1. 从队列中取出第一个任务并提交给打印机
  
2. 将该任务的等待时间存入一个列表，以备后用
  
3. 根据该任务的页数，计算执行时间

3. 打印机进行一秒的打印，同时从该任务的执行时间中减去一秒

4. 如果打印任务执行完毕，或者说任务需要的时间减为0，则说明打印机回到空闲状态。

5. 模拟完成后，根据等待时间列表中的值计算平均等待时间

Python实现

创建3个类：Printer、Task和PrintQueue。它们分别模拟打印机、打印任务和队列

class Printer(object):
    def __init__(self, ppm):
        self.pagerate = ppm     # 初始化打印速度
        self.current_task = None    # 打印任务为空
        self.time_ramaining = 0

    def tick(self):
        if self.current_task:
            self.time_ramaining = self.time_ramaining - 1
            if self.time_ramaining <= 0:
                self.current_task = None

    def busy(self):
        if self.current_task:
            return True
        else:
            return False

    def start_next(self, new_task):
        self.current_task = new_task
        self.time_ramaining = new_task.getPages() * 60 / self.pagerate


class Task(object):
    def __init__(self, time):
        self.timestamp = time
        self.pages = random.randrange(1, 21)

    def get_stamp(self):
        return self.timestamp

    def wait_time(self, current_time):
        return current_time - self.timestamp


def newPrintTask():
    num = random.randrange(1, 181)
    if num == 180:
        return True
    else:
        return False


def simulation(num_seconds, pages_perminute):
    labprinter = Printer(pages_perminute)
    printQueue = MyQueue()
    waitingtimes = []
    for currentSecond in range(num_seconds):
        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()))

双端队列

抽象数据类型

Deque（）创建一个空的双端队列。它不需要参数，且会返回一个空的双端队列。

add_front（）将一个元素添加到双端队列的前端。它接受一个元素作为参数，没有返回值。

add_rear（item）将一个元素添加到双端队列的后端。它接受一个元素作为参数，没有返回值。

remove_front（）从双端队列的前端移除一个元素。它不需要参数，且会返回一个元素，并修改双端队列的内容

remove_rear（）从双端队列的后端移除一个元素。它不需要参数，且会返回一个元素，并修改双端队列的内容。

is_empty（）检查双端队列是否为空。它不需要参数，且会返回一个布尔值

size（）返回双端队列中元素的数目。它不需要参数，且返回一个整数

class MyDeque(object):
    def __init__(self):
        self.items = []

    def add_front(self, item):
        self.items.insert(0, item)

    def add_rear(self, item):
        self.items.append(item)

    def remove_front(self):
        return self.items.pop(0)

    def remove_rear(self):
        return self.items.pop()

    def is_empty(self):
        return self.items == []

    def size(self):
        return len(self.items)

回文检测

def pal_checker(string):
    char_deque = MyDeque()

    for ch in string:
        char_deque.add_rear(ch)

    still_equal = True

    while char_deque.size() > 1 and still_equal:
        front = char_deque.remove_front()
        rear = char_deque.remove_rear()
        if front != rear:
            still_equal = False

    return still_equal