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("链式队列测试结束")