Python学习笔记（四）——队列

1.基于列表：

class Queue:
    def __init__(self):
        self._qList = list()
    
    def isEmpty(self):
        return len(self) == 0
    
    def __len__(self):
        return len(self._qList)
    
    def enqueue(self, item):
        self._qList.append(item)
    
    def dequeue(self):
        assert not self.isEmpty(), "Cannot dequeue from an empty queue."
        return self._qList.pop(0)

2.基于循环数组：

# Implementation of the Queue ADT using a circular array. 

import Array

class Queue:
    def __init__(self, maxSize):
        self._count = 0
        self._front = 0
        self._back = maxSize - 1
        self._qArray = Array (maxSize)
    
    def isEmpty(self):
        return self._count == 0
    
    def isFull(self):
        return self._count == len(self._qArray)
    
    def __len__(self):
        return self._count
    
    # Adds the given item to the queue.
    def enquene(self, item):
        assert not self.isFull(), "Cannot enqueue to a full queue."
        maxSize = len(self._qArray)
        self._back = (self._back + 1) % maxSize
        self._qArray[self._back] = item
        self._count += 1

    # Removes and returns the first item in the queue. 
    def dequene(self):
        assert not self.isEmpty(), "Cannot dequeue from an empty queue"
        item = self._qArray[self._front]
        maxSize = len(self._qArray)
        self._front = (self._front + 1) % maxSize
        self._count -= 1
        return item

3.基于链表：

class Queue:
    def __init__(self):
        self._qhead = None
        self._qtail = None
        self._count = 0
    
    def isEmpty(self):
        return self._qhead is None
    
    def __len__(self):
        return self._count
    
    def enqueue(self, item):
        node = _QueueNode(item)
        if self.isEmpty():
            self._qhead = node
        else:
            self._qtail.next = node
    
        self._qtail = node
        self._count += 1
    
    def dequene(self):
        assert not self.isEmpty(), "Cannot dequeue from an empty queue."
        node = self._qhead
        if self._qhead is self._qtail:
            self._qtail = None
        self._qhead = self._qhead.next
        self._count -= 1
        return node.item

class _QueueNode(object):
    def __init__(self, item):
        self.item = item
        self.next = None

四、Priority Queue

1.unbound priority queue

# Implementation of the unbounded Priority Queue ADT using a Python list 
# with new items appended to the end. 
class PriorityQueue:
    def __init__(self):
        self._qList = list()
    
    def isEmpty(self):
        return len(self) == 0
    
    def __len__(self):
        return len(self._qList)
    
    def enqueue(self, item, priority):
        entry = _PriorityQEntry(item, priority)
        self._qList.append(entry)
    
    def dequene(self):
        assert not self.isEmpty(), 'Cannot dequeue from an empty queue.'
        highest = self._qList[0].priority
        entry = self._qList[0]
        for i in range(self.__len__()):
            if self._qList[i].priority < highest:
                highest = self._qList[i].priority
                entry = self._qList[i]
        index = self._qList.index(entry)
        self._qList.pop(index)
        return entry.item
class _PriorityQEntry(object):
    def __init__(self, item, priority):
        self.item = item
        self.priority = priority


queue = PriorityQueue()
queue.enqueue(1,2)
queue.enqueue(2,7)
queue.enqueue(3,8)
queue.enqueue(4,0)
queue.enqueue(5,9)
queue.enqueue(6,1)
for i in range(6):
    print(queue.dequene())

'''
output:
4
6
1
2
3
5

'''

2.bounded queue

from array import Array 
from llistqueue import Queue 
class BPriorityQueue:
    def __init__(self, numLevels):
        self.numLevels = numLevels
        self._qSize = 0
        self._qLevels = Array(numLevels)
        for i in range(numLevels):
            self._qLevels[i] = Queue()
        
    def isEmpty(self):
        return len(self) == 0
    
    def __len__(self):
        return self._qSize
    
    def enqueue(self, item, priority):
        assert priority >= 0 and priority < self.numLevels,\
            "Invalid priority level."
        self._qLevels[priority].enqueue(item)
        self._qSize += 1
    
    def dequeue(self):
        assert not self.isEmpty(), "Cannot dequeue from an empty queue."
        i = 0
        p = len(self._qLevels)
        while i < p and self._qLevels[i].isEmpty():
            i += 1
        return self._qLevels[i].dequene()

b = BPriorityQueue(5)
b.enqueue(1,4)
b.enqueue(2,3)
b.enqueue(3,2)
b.enqueue(4,0)
b.enqueue(5,1)
for i in range(5):
    print(b.dequeue())

'''
output:
4
5
3
2
1

'''

五、模拟飞机检票

未解决