python小练习11 -- 顺序队列和链式队列的实现

代码：

class QueueException(Exception):
    pass


class Queue:
    """
    顺序队列
    """

    def __init__(self, size):
        self.__size = size
        self.length = 0

    def is_empty(self):
        if self.__length == 0:
            return True
        else:
            return False

    def is_full(self):
        if self.__size == self.__length:
            return True
        elif self.__length < self.__size:
            return False
        else:
            raise QueueException

    @property
    def length(self):
        return self.__length

    @length.setter
    def length(self, length):
        if length <= self.__size:
            self.__length = length
        else:
            raise ValueError("length should be smaller than %d" % self.__size)
    
    @property   
    def size(self):
        return self.__size

    def enqueue(self, value):
        raise NotImplementedError

    def dequeue(self):
        raise NotImplementedError


class SQueue(Queue):
    def __init__(self, size):
        super(SQueue, self).__init__(size)
        self.__queue = []

    def enqueue(self, value):
        if not self.is_full():
            self.__queue.append(value)
            self.length += 1
            return True
        else:
            return False

    def dequeue(self):
        if not self.is_empty():
            val = self.__queue.pop(0)
            self.length -= 1
            return val
        else:
            return None


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

    @property
    def value(self):
        return self.__value

    @value.setter
    def value(self, value):
        if isinstance(value, int):
            self.__value = value
        else:
            raise ValueError("value should be an instance of int")

    @property
    def next(self):
        return self.__next

    @next.setter
    def next(self, node):
        if isinstance(node, Node) or node is None:
            self.__next = node
        else:
            raise ValueError("node should be an instance of Node")


class LQueue(Queue):
    """
    链式队列
    """

    def __init__(self, size):
        super(LQueue, self).__init__(size)
        self.__head = None
        self.__tail = None

    def enqueue(self, value):
        node = Node(value)
        if not self.is_full():
            if self.is_empty():
                self.__head = self.__tail = node
            else:
                self.__tail.next = node
                self.__tail = node
            self.length += 1
            return True
        else:
            return False

    def dequeue(self):
        if not self.is_empty():
            val = self.__head.value
            if self.__head == self.__tail:
                self.__head = self.__tail = None
            else:
                self.__head = self.__head.next
            self.length -= 1
            return val
        else:
            return None


if __name__ == "__main__":
    queue1 = SQueue(8)

    print("顺序队列测试")
    i = 1
    while not queue1.is_full():
        queue1.enqueue(i)
        i = i + 1

    while not queue1.is_empty():
        print(queue1.dequeue(), end=" ")
    print()
    print("顺序队列测试结束")

    print("链式队列测试")
    queue2 = LQueue(5)

    i = 1
    while not queue2.is_full():
        queue2.enqueue(i)
        i = i + 1

    while not queue2.is_empty():
        print(queue2.dequeue(), end=" ")
    print()
    print("链式队列测试结束")

测试结果：