数据结构--队列

数据结构–队列

一、队列

队列与栈类似，其本身较为简单，队列遵循先进先出(first-in first-out, FIFO)原则，在队列的“尾部”掺入元素，在队列的“头部”移除元素

1.1 队列的抽象类型

名称	说明
Queue()	定义一个队列
enqueue()	插入元素
dequeue()	移除元素
size()	队列长度
isEmpty()	判断队列是否为空

1.2 队列的实现

代码如下：

class Queue:
    def __init__(self):
        self.queue = []			

    # enter queue
    def enQueue(self, item):
        self.queue.insert(0, item)

    # exit Queue
    def deQueue(self):
        self.queue.pop()

    # empty queue
    def isEmpty(self):
        return self.queue == []

    # length of Queue
    def size(self):
        return len(self.queue)

测试：

if __name__ == '__main__':
    q = Queue()
    print('the length of queue: ', q.size())
    q.enQueue(2)
    q.enQueue('queue')
    q.enQueue(3.5)
    print('the length of queue: ', q.size())
    q.deQueue()
    print('the length of queue: ', q.size())
    
------------------------
the length of queue:  0
the length of queue:  3
the length of queue:  2

从代码中可以看出，采用 insert() 插入元素，因此插入元素的时间复杂度为O(n)，移除时间复杂度为O(1).

1.3 数数字游戏

规定有n个人，设定一个数num，n个人从1依次数下去，数到num的人退出游戏，然后继续从1开始数，知道只剩一个人即为胜利者。
代码如下：

def transformNumber(itemList, num):
    q = Queue()
	# 将人员加入队列
    for i in itemList:
        q.enQueue(i)

    while q.size() > 1:
        for j in range(num):
            q.enQueue(q.deQueue())

        q.deQueue()
    print('the last item is: ', q.deQueue())

测试：

if __name__ == '__main__':
    itemList = ['Bob', 'Jack', 'John', 'Bettye', 'Ben', 'Hanrry', 'Jane', 'Susan', 'Pack']
    num = 6
    transformPotato(itemList, num)

-----------------
the last item is:  Jack

二、 双端队列

顾名思义，即可在队尾执行插入和移除操作，也可在对头执行插入和移除操作。

2.1 双端队列的抽象数据类型

名称	说明
Deque()	定义一个队列
addFront()	对头插入元素
addRear()	队尾插入元素
rmFront()	对头移除元素
rmRear()	队尾移除元素
size()	队列长度
isEmpty()	判断队列是否为空

2.2 双端队列的实现

代码如下：

class Deque:
    def __init__(self):
        self.deque = []

    def isEmpty(self):
        return self.deque == []

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

    # 队头插入
    def addFront(self, item):
        self.deque.append(item)

    # 队尾插入
    def addRear(self, item):
        self.deque.insert(0, item)

    # 队头删除
    def rmFront(self):
        self.deque.pop()

    # 队尾删除
    def rmRear(self):
        self.deque.pop(0)

测试：

if __name__ == '__main__':
    dq = Deque()
    dq.addFront(2)
    dq.addRear('tiger')
    dq.addFront(5)
    dq.addRear('panda')
    print('the length of deque: ', dq.size())
    dq.rmRear()
    print('the length of deque: ', dq.size())
    dq.rmFront()
    print('the length of deque: ', dq.size())

--------------------
the length of deque:  4
the length of deque:  3
the length of deque:  2

在队尾的插入和移除操作的时间复杂度均为O(n)，在对头的插入和移除操作的时间复杂度均为O(1)。

2.2 双端队列的应用（回文检测）

假设有个序列：werew，可以才看出从前顺序和从后顺序是一样的，那就称其为回文。
代码如下：

def checker(word):
    dq = Deque()
    for i in word:
        dq.addFront(i)

    flag = True
    while dq.size()> 1 and not dq.isEmpty():
        if not (dq.rmFront() == dq.rmRear()):
            flag = False
            break

    if flag is True:
        print('该单词属于回文单词')
    else:
        print('该单词不属于回文单词')