python实现队列的基本操作，出队、入队，计算队长

队列是数据结构中常用的一种类型，它和排队是情形一样，先进队列中的元素出队时一定是先出来的，定义一端为队首（队列元素出队的一端），另外一端为队尾（队列元素进队的一端）；循环队列就是将队列的两个指针（首尾指针连接起来，可以更加方便进行操作）

顺序队操作:

class Queue(object):
	#初始化一个队列
    def __init__(self):
        self.__list = []

    # 入队
    def pushqueue(self,item):
        #尾部进队，头部出队
        self.__list.append(item)
        #头部进队，尾部出队
        # self.__list.insert(0,item)

    # 出队
    def putqueue(self):
        return self.__list.pop(0)
        # return self.__list.pop()

    # 判断是否为空
    def is_empty(self):
        return self.__list == []

    # 判断长度
    def size(self):
        return len(self.__list)

if __name__ == '__main__':
    s = Queue()
    s.pushqueue(1)
    s.pushqueue(2)
    s.pushqueue(3)
    print('进队之后的长度', s.size())
    print(s.putqueue(),end=' ')
    print(s.putqueue(),end=' ')
    print(s.putqueue(),end=' ')
    print('出队之后的长度',s.size())

链队的操作

'''链队的完成'''

class QueueNode(object):
    # 定义队列的结点
    def __init__(self):
        self._queue = None
        self._quenext = None


class DefineQueue(object):

    # 初始化队列
    def __init__(self):
        self._queuehead = QueueNode()
        #初始化一个对象
        tqueue = QueueNode()
        #使front和rear同时指向初始化的对象
        self._front = tqueue
        self._rear = tqueue

    # 判断队列为空
    def is_empty(self):
        #如果front和rear指向的值相同则为空
        if self._front == self._rear:
            return True
        else:
            return False

    #队长
    def getlength(self):
        #判断是否为空
        if self.is_empty():
            return
        else:
            #初始化对象
            quenode = self._front
            #计数
            count = 0
            #从第一个元素开始，到等于rear结束，每执行一次计数器+1，对象向后移动一位
            quenode = self._front._quenext
            while quenode != self._rear:
                count += 1
                quenode = quenode._quenext
            count += 1
            return count

    # 进队
    def put(self, put_data):
        # 实例化队列结点
        que_data = QueueNode()
        #将需要添加的数据赋值给实例化对象的数据域
        que_data._queue = put_data
        #尾指针的next指向新加入的数据
        self._rear._quenext = que_data
        #尾指针向后移动一个位置
        self._rear = que_data

    # 出队
    def push(self):
        #判断队列是否为空
        if self.is_empty():
            return 'Error'
        else:
            #出队的元素等于队列的第一个元素
            putqueue = self._front._quenext
            #将要出队的元素的next赋值给front的next
            self._front._quenext = putqueue._quenext
            #只有一个元素，若出队之后则front等于rear
            if self._rear == putqueue:
                self._rear = self._front
            #返回出队的元素
            return putqueue._queue

    #遍历队列元素
    def getqueue(self):
        #队列为空则没有返回值
        if self.is_empty():
            return
        else:
            #遍历的第一个对象为front.next指向的内容
            quenode =self._front._quenext
            #如果front等于rear，则遍历完成
            while quenode != self._rear:
                #打印遍历的值
                print(quenode._queue,end=' ')
                #向后移动一个位置
                quenode = quenode._quenext
            print(quenode._queue,end=' ')


if __name__ == '__main__':
    node = DefineQueue()
    for i in range(5):
        node.put(i)
    print('遍历链队元素:',end=' ')
    node.getqueue()
    print('\n链队的长度',node.getlength())
    print('出队元素:',node.push(),end=' ')