python数据结构学习笔记-2016-11-05-01-队列ADT及其实现

       8.1 队列ADT

       队列(queue)：只能在一端插入元素，在另一端删除元素的容器。其特点是先进先出(first-in first-out, FIFO)。

       插入元素的一端称为后端(back)，也称为队尾，删除元素德一端称为前端(front)，也称为队头。

       其具有如下属性：

• Queue()：创建空队列；
• isEmpty()：判断当前队列是否为空；
• length()：返回队列长度；
• enqueue()：添加元素到队尾；
• dequeue()：从队头删除元素。

       8.2 队列的实现

       有三种方式可以实现队列，分别是python列表、数组以及链表。

       基于python列表的实现

       这种方式最简单。

#-*-coding: utf-8-*-

# 使用python列表实现队列

class Queue(object):
    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)

       从以上操作可以看出，length()和isEmpty()的时间复杂度是O(1)。enqueue()和dequeue()的时间复杂度是O(n)。

       基于数组的实现

       这里的数组可以看成一个环形数组(circular array)，另外还需要两个指针，一个指向队头，另一个指向队尾。如下图：

       其特点是在插入和删除元素时，其他元素不需要进行移位，只需要移动两个指针便可。

       在进行插入元素时，如果数组还有足够的容量，添加新元素，back指针向后移动一位。删除元素时，只需把要删除元素所在位置设置为None，再将front指针后移一位即可。但也有可能碰到以下特殊情况：

       在这种情况下，由于我们使用的是环形数组，新元素会被添加到数组索引0的位置，而back指针也会移动至该位置。

       数组实现方式的缺陷显然是容量有限。

#-*-coding: utf-8-*-

# 使用数组来实现队列

from myarray import Array

class Queue(object):
    def __init__(self, maxSize):
        self._count = 0
        self._front = 0 # 初始化front指针指向索引0的位置
        self._back = maxSize - 1 # 初始化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

    def enqueue(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

    def dequeue(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

       基于数组的实现方式，所有方法的时间复杂度都是O(1)，因为没有元素移位出现。

       基于链表的实现

       基于链表的实现方式，是在一个链表上使用头指针和尾指针，头指针指向队头，尾指针指向队尾。

#-*-coding: utf-8-*-

# 使用链表实现队列

class Queue(object):
    def __init__(self):
        self._qhead = None
        self._qtail = None
        self._count = 0

    def isEmpty(self):
        return self._count == 0

    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 dequeue(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

        在链表实现方式中，所有方法的时间复杂度都是O(1)。