Python数据结构篇（二）—— 顺序队列和优先队列的实现

一、前言

继上一篇介绍了顺序栈和链式栈的实现后，本篇主要介绍顺序队列和优先队列的实现。

二、顺序队列的实现

首先来看一下顺序队列的实现，就是我们常说的 “FIFO”（先进先出）队列，它主要包括的方法有：取第一个元素（first方法）、进入队列（enqueue方法）、出队列（dequeue方法）、清空队列（clear方法）、判断队列是否为空（empty方法）、获取队列长度（length方法），具体的实现看下面的源代码。同样，这里在取队列的第一个元素、以及出队列的时候，也需要判断下队列是否为空。另外关于类成员变量的公有性、保护性、私有性在上一篇中已经说过了，这里也不赘述了。

	class Queue:
	    """
	    Sequential Queue implement
	    """
	
	    def __init__(self):
	        """
	        initialize an empty Queue, __queue means it's a private member
	        """
	        self.__queue = []
	
	    def first(self):
	        """
	        get the first element of Queue
	        :return: if Queue is empty return None, else return the first element
	        """
	        return None if self.isEmpty() else self.__queue[0]
	
	    def enqueue(self, obj):
	        """
	        enqueue an element into Queue
	        :param obj: object to be enqueued
	        """
	        self.__queue.append(obj)
	
	    def dequeue(self):
	        """
	        dequeue the first element from Queue
	        :return: if Queue is empty return None, else return the dequeued element
	        """
	        return None if self.isEmpty() else self.__queue.pop(0)
	
	    def clear(self):
	        """
	        clear the whole Queue
	        """
	        self.__queue.clear()
	
	    def isEmpty(self):
	        """
	        judge the Queue is empty or not
	        :return: bool value
	        """
	        return self.length() == 0
	
	    def length(self):
	        """
	        get the length of Queue
	        :return:
	        """
	        return len(self.__queue)

三、优先队列的实现

其次，再来看下优先队列的实现。优先队列简单说就是一个有序队列，排序的规则就是自定义的优先级大小。在下面的代码实现中，主要使用的是数值大小进行比较排序，数值越小则优先级越高，理论上应该把优先级高的放在队列首位。值得注意的是，笔者这里用list来实现的时候恰好顺序是反的，即list中元素是从大到小的顺序，这样做的好处是取队列的第一个元素、以及出队列这两个操作的时间复杂度为O(1)，仅仅入队列操作的时间复杂度为O(n)。如果是按照从小到大的顺序，那么将会产生两个时间复杂度为O(n)，一个时间复杂度为O(1)。

	class PriorQueue:
	    """
	    Priority Queue implement
	    """
	
	    def __init__(self, objs=[]):
	        """
	        initialize a Priority Queue, and the default queue is empty
	        :param objs: object list for initializing
	        """
	        self.__prior_queue = list(objs)
	        # sort from maximum to minimum, and the minimum has the highest priority
	        # so that the efficiency of "dequeue" will be O(1)
	        self.__prior_queue.sort(reverse=True)
	
	    def first(self):
	        """
	        get the highest priority element of Priority Queue, O(1)
	        :return: if Priority Queue is empty return None, else return the highest priority element
	        """
	        return None if self.isEmpty() else self.__prior_queue[-1]
	
	    def enqueue(self, obj):
	        """
	        enqueue an element into Priority Queue, O(n)
	        :param obj: object to be enqueued
	        """
	        index = self.length()
	        while index > 0:
	            if self.__prior_queue[index - 1] < obj:
	                index -= 1
	            else:
	                break
	        self.__prior_queue.insert(index, obj)
	
	    def dequeue(self):
	        """
	        dequeue the highest priority element from Priority Queue, O(1)
	        :return: if Priority Queue is empty return None, else return the dequeued element
	        """
	        return None if self.isEmpty() else self.__prior_queue.pop()
	
	    def clear(self):
	        """
	        clear the whole Priority Queue
	        """
	        self.__prior_queue.clear()
	
	    def isEmpty(self):
	        """
	        judge the Priority Queue is empty or not
	        :return: bool value
	        """
	        return self.length() == 0
	
	    def length(self):
	        """
	        get the length of Priority Queue
	        :return:
	        """
	        return len(self.__prior_queue)

四、其他数据结构实现

关于其他常用数据结构的实现，可参考下面的链接：

1. Python数据结构篇（一）—— 顺序栈和链栈的实现
2. Python数据结构篇（三）—— 链表的实现（待更新）
3. Python数据结构篇（四）—— 二叉树的实现（待更新）