【隊列】用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())