【队列】用python实现队列

分别采用有序列表、单链表和双链表实现了队列的基本功能，涵盖入列、出列等。

方法一：基于有序队列的实现

class Quene(object):
    def __init__(self):
        self.data = []

    def __repr__(self):
        return f"Quene({self.data})"

    def enquene(self, value):
        # 入队列
        self.data.append(value)

    def dequene(self):
        # 出队列
        if self.isEmpty():
            raise IndexError("dequene from empty quene")
        else:
            return self.data.pop(0)

    def isEmpty(self):
        return len(self.data) == 0

    def rotate(self,times):
        # 队列的顺序翻转
        for _ in range(times):
            self.enquene(self.dequene())

方法二：基于单向链的实现

"""
利用单链表实现队列
"""

class Node(object):
    def __init__(self, value, next=None):
        self.value = value
        self.next = next

    def __repr__(self):
        return self.value

class Quene(object):
    def __init__(self):
        self.head = None

    def __repr__(self):
        data = []
        current = self.head
        if current is None:
            return None
        else:
            while current:
                data.append(current.value)
                current = current.next
        return str(data)

    def enquene(self, value):
        # 入队列
        new_node = Node(value)
        if self.isEmpty():
            self.head = new_node
        else:
            current = self.head
            while current.next is not None:
                current = current.next
            current.next = new_node

    def dequene(self):
        # 出队列
        if self.isEmpty():
            raise IndexError("dequene from empty quene")
        else:
            current = self.head
            self.head = self.head.next
            return current.value

    def isEmpty(self):
        return self.head is None

    def rotate(self,times):
        # 队列的顺序翻转
        for _ in range(times):
            self.enquene(self.dequene())

if __name__ == '__main__':
    quene = Quene()
    quene.enquene(3)
    print(quene)
    quene.enquene(4)
    print(quene)
    quene.enquene(5)
    print(quene)
    quene.rotate(2)
    print(quene)

方法三：基于双向链的实现

class Node(object):
    def __init__(self, value, prev=None, next=None):
        self.value = value
        self.prev = prev
        self.next = next

    def __repr__(self):
        return self.value

class Quene(object):
    def __init__(self):
        self.head = None

    def __repr__(self):
        data = []
        current = self.head
        if current is None:
            return None
        else:
            while current:
                data.append(current.value)
                current = current.next
        return str(data)

    def enquene(self, value):
        # 入队列
        new_node = Node(value)
        if self.isEmpty():
            self.head = new_node
        else:
            current = self.head
            while current.next is not None:
                current = current.next
            current.next = new_node
            new_node.prev = current

    def dequene(self):
        # 出队列
        if self.isEmpty():
            raise IndexError("dequene from empty quene")
        else:
            current = self.head
            self.head = current.next
            current.next = None
            if self.head is not None:
                self.head.prev = None
            return current.value

    def isEmpty(self):
        return self.head is None

    def rotate(self, times):
        # 队列的顺序翻转
        for _ in range(times):
            self.enquene(self.dequene())