栈和队列专题(2)——队列

概念

队列（Queue）是只允许在一端进行入队操作（enqueue），另一段进行出队操作（dequeue）的容器。不允许在队列中间进行操作。

队列是一种先进先出（FIFO，first in first out）的线性表。

队列结构实现

顺序表实现

class Queue:
    def __init__(self):
        self.__list = []
    
    def enqueue(self, item):
        """往队列尾部添加一个元素"""
        self.__list.append(item)

    def dequeue(self):
        """从队列头部删除一个元素"""
        return self.__list.pop(0)

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

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

双向链表实现

# 定义节点类
class Node:
    def __init__(self, item):
        self.item = item
        self.next = None
        self.prev = None


class Queue:
    def __init__(self):
        self.__head = None
        self.__last = None
        self.__count = 0

    def is_empty(self):
        return self.__count == 0

    def size(self):
        return self.__count

    def enqueue(self, item):
        """入队的节点加在链表头部"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
            self.__last = node
        else:
            node.next = self.__head
            self.__head = node
        self.__count += 1

    def dequeue(self):
        """出队从链表尾部出队"""
        if not self.is_empty():
            if self.__count == 1:
                res = self.__last.item
                self.__last = None
                self.__head = None
            else:
                res = self.__last.item
                self.__last = self.__last.prev
            self.__count -= 1
            return res
        return None

双端队列

概念

双端队列(double-ended queue, deque)，是一种具有队列和栈的性质的数据结构。

双端队列的元素可以从双端弹出，其限定插入和删除操作也两端进行。双端队列可以在队列任意一端入队或出队。

相关操作

操作	说明
Deque()	创建一个空的双端队列
add_front()	在队头部加一个item元素
add_rear()	在队尾加一个元素
remove_front()	从队头部删除一个元素
remove_rear()	从队尾删除一个元素
is_empty()	判断队列是否为空
size()	返回队列大小

双端队列实现

顺序表实现

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

    def add_front(self, item):
        """队列的头部加一个元素"""
        self.__list.insert(0, item)
    
    def add_rear(self, item):
        """往队列尾部添加一个元素"""
        self.__list.append(item)

    def remove_front(self):
        """从队列头部删除一个元素"""
        return self.__list.pop(0)

    def remove_rear(self):
        """从队列尾部删除一个元素"""
        return self.__list.pop()

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

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

双向链表实现

# 节点类定义
class Node:
    def __init__(self, item):
        self.item = item
        self.next = None
        self.prev = None


class Deque:
    def __init__(self):
        self.__head = None
        self.__last = None
        self.__count = 0

    def is_empty(self):
        return self.__count == 0

    def size(self):
        return self.__count

    def add_front(self, item):
        """入队的节点加在链表头部"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
            self.__last = node
        else:
            node.next = self.__head
            self.__head = node
        self.__count += 1

    def add_rear(self, item):
        """入队节点加在链表尾部"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
            self.__last = node
        else:
            node.prev = self.__last
            self.__last.next = node
        self.__count += 1

    def remove_rear(self):
        """从链表尾部删除节点"""
        if not self.is_empty():
            if self.__count == 1:
                res = self.__last.item
                self.__last = None
                self.__head = None
            else:
                res = self.__last.item
                self.__last = self.__last.perv
            self.__count -= 1
            return res
        return None

    def remove_front(self):
        """从链表头部删除节点"""
        if not self.is_empty():
            if self.__count == 1:
                res = self.__head.item
                self.__head = None
                self.__last = None
            else:
                res = self.__head.item
                self.__head = self.__head.next
                self.__head.next.prev = None
            self.__count -= 1
            return res
        return None