6.队列

总结
一、什么是队列？
1.先进者先出，这就是典型的“队列”结构。
2.支持两个操作：入队enqueue()，放一个数据到队尾；出队dequeue()，从队头取一个元素。
3.所以，和栈一样，队列也是一种操作受限的线性表。
二、如何实现队列？
1.队列API
public interface Queue<T> {
public void enqueue(T item); //入队
public T dequeue(); //出队
public int size(); //统计元素数量
public boolean isNull(); //是否为空
}
2.数组实现（顺序队列）：见下一条留言
3.链表实现（链式队列）：见下一条留言
4.循环队列（基于数组）：见下一条留言
三、队列有哪些常见的应用？
1.阻塞队列
1）在队列的基础上增加阻塞操作，就成了阻塞队列。
2）阻塞队列就是在队列为空的时候，从队头取数据会被阻塞，因为此时还没有数据可取，直到队列中有了数据才能返回；如果队列已经满了，那么插入数据的操作就会被阻塞，直到队列中有空闲位置后再插入数据，然后在返回。
3）从上面的定义可以看出这就是一个“生产者-消费者模型”。这种基于阻塞队列实现的“生产者-消费者模型”可以有效地协调生产和消费的速度。当“生产者”生产数据的速度过快，“消费者”来不及消费时，存储数据的队列很快就会满了，这时生产者就阻塞等待，直到“消费者”消费了数据，“生产者”才会被唤醒继续生产。不仅如此，基于阻塞队列，我们还可以通过协调“生产者”和“消费者”的个数，来提高数据处理效率，比如配置几个消费者，来应对一个生产者。
2.并发队列
1）在多线程的情况下，会有多个线程同时操作队列，这时就会存在线程安全问题。能够有效解决线程安全问题的队列就称为并发队列。
2）并发队列简单的实现就是在enqueue()、dequeue()方法上加锁，但是锁粒度大并发度会比较低，同一时刻仅允许一个存或取操作。
3）实际上，基于数组的循环队列利用CAS原子操作，可以实现非常高效的并发队列。这也是循环队列比链式队列应用更加广泛的原因。
3.线程池资源枯竭是的处理
在资源有限的场景，当没有空闲资源时，基本上都可以通过“队列”这种数据结构来实现请求排队。

 

#链表实现队列
class Node(object):
    def __init__(self,item,next=None):
        self.item = item
        self.next = next

class QueueError(ValueError):
    def __init__(self,text):
        print(text)

class Queue(object):
    def __init__(self):
        self.head = None
        self.tail = None

    def isEmpty(self):
        return self.head == None
    def enqueue(self,e):
        p = Node(e)
        if self.isEmpty():
            self.head = self.tail = p
        self.tail.next =p
        self.tail = self.tail.next

    def delqueue(self):
        if self.isEmpty():
            raise QueueError("no value")
        e = self.head.item
        self.head = self.head.next
        return e
    def top(self):
        if self.isEmpty():
            raise QueueError("no value")
        return self.head.item

if __name__ == "__main__":
    q = Queue()
    q.enqueue("1")
    q.enqueue("2")
    q.delqueue()
    print(q.top())

#list实现队列
class Node(object):
    def __init__(self,item,next=None):
        self.item = item
        self.next = next

class QueueError(ValueError):
    def __init__(self,text):
        print(text)

class Queue(object):
    def __init__(self,size):
        self.size = size#数组长度
        self.queue = []
    def __str__(self):
        return str(self.queue)
    def is_full(self):
        if len(self.queue) == self.size:
            return True
        return False
    def isEmpty(self):
        if len(self.queue) == 0:
            return True
        return False

    def enqueue(self,n):
        if self.is_full():
            return -1
        self.queue.append(n)

    def delqueue(self):
        if self.isEmpty():
            return -1
        head = self.queue[0]
        self.queue.remove(head)
        return head

    def top(self):
        if self.isEmpty():
            return -1
        head = self.queue[0]
        return head

    def getsize(self):
        return len(self.queue)


if __name__ == "__main__":
    q = Queue(5)
    q.enqueue("1")
    q.enqueue("2")
    q.delqueue()
    print(q.top())

"""
从细节上看，Python中的列表是由对其它对象的引用组成的连续数组。指向这个数组的指针及其长度被保存在一个列表头结构中。
这意味着，每次添加或删除一个元素时，由引用组成的数组需要该标大小（重新分配）。
幸运的是，Python在创建这些数组时采用了指数分配，所以并不是每次操作都需要改变数组的大小。
但是，也因为这个原因添加或取出元素的平摊复杂度较低。

不幸的是，在普通链表上“代价很小”的其它一些操作在Python中计算复杂度相对过高。

利用 list.insert方法在任意位置插入一个元素——复杂度O(N)
利用 list.delete或del删除一个元素——复杂度O(N)


列表的算法效率
可以采用时间复杂度来衡量：

index() O(1)
append O(1)
pop() O(1)
pop(i) O(n)
insert(i,item) O(n)
del operator O(n)
iteration O(n)
contains(in) O(n)
get slice[x:y] O(k)
del slice O(n)
set slice O(n+k)
reverse O(n)
concatenate O(k)
sort O(nlogn)
multiply O(nk)

O括号里面的值越大代表效率越低


列表和元组
列表和元组的区别是显然的：
列表是动态的，其大小可以该标 (重新分配)；
而元组是不可变的，一旦创建就不能修改。

list和tuple在c实现上是很相似的，对于元素数量大的时候，
都是一个数组指针，指针指向相应的对象，找不到tuple比list快的理由。
但对于小对象来说，tuple会有一个对象池，所以小的、重复的使用tuple还有益处的。

为什么要有tuple，还有很多的合理性。
实际情况中的确也有不少大小固定的列表结构，例如二维地理坐标等；
另外tuple也给元素天然地赋予了只读属性。

"""

 

"""
队列的存储结构中使用的最多的是循环队列。循环队列包括两个指针， front 指针指向队头元素， rear 指针指向队尾元素的下一个位置。 
队列为空的判断条件是： 
front == rear
队列满的判断条件是： 
(rear+1)%maxsize == front
队列长度的计算公式： 
(rear-front+maxsize)%maxsize
"""

class SqQueue(object):
    def __init__(self,maxsize):
        self.queue = [None]*maxsize
        self.maxsize = maxsize
        self.front = self.rear = 0

    def queueLength(self):
        return (self.rear - self.front +self.maxsize)% self.maxsize

    def isfull(self):
        return (self.rear+1)%self.maxsize == self.front

    def isempty(self):
        return self.rear == self.front

    def enqueue(self,e):
        if self.isfull():
            print("queue is full")
        else:
            self.queue[self.rear] = e
            self.rear = (self.rear+1)%self.maxsize

    def delqueue(self):
        if self.isempty():
            print("queue is empty")
        else:
            data = self.queue[self.front]
            #设为None，方便遍历
            self.queue[self.front] =None
            self.front = (self.front +1)%self.maxsize
            return data
    def showQueue(self):
        for i in range(self.maxsize):
            print(self.queue[i])

if __name__ == "__main__":

    q = SqQueue(5)

    q.enqueue(1)
    q.enqueue(2)

    q.enqueue(3)
    q.enqueue(4)
    print(q.delqueue())

    q.enqueue(5)
    q.delqueue()
    print("----------")
    q.enqueue(6)
    q.showQueue()
"""
1
----------
6
None
3
4
5
"""