大话数据结构八：队列的顺序存储结构（循环队列）

1. 什么是队列？

队列(queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

2. 队列的特点:

队列是一种先进先出(First In First out)的线性表，允许插入的一端称为队尾，允许删除的一端称为队头。

3. 队列顺序存储有什么不足？

使用数组实现的顺序存储，当做出队列操作时，所有的元素都需要向前移动一位，性能很低。

4. 什么是循环队列？

队列头尾相接的顺序存储结构称为循环队列。

如图所示：front记住队头元素下标，rear记住队尾元素的下一个元素。

注意：

1. 只凭等式front=rear是无法判断队空还是队满，所以我们约定当队列头指针front在队尾指针rear的下一个位置上时,作为队列"已满"的标志，当队列满时,数组中还会有一个空闲位置。

2. 我们也可以设置一个标志变量flag，当（front == rear && flag == 0） 队列为空， 当（front == rear && flag == 1）队列为满。

5. Java使用数组实现循环队列:

[java]  view plain  copy

 

1. //循环队列的顺序存储结构（数组实现）  
2. public class LoopQueue<T> {  
3.     private Object[] arr; // 对象数组，队列最多存储  
4.     private int front; // 记住队首下标位置  
5.     private int rear; // 记住队尾下标的下一个位置  
6.     private static final int DEFAULT_SIZE = 3; // 定义数组默认长度  
7.   
8.     public LoopQueue() {  
9.         this(DEFAULT_SIZE);  
10.     }  
11.   
12.     public LoopQueue(int size) {  
13.         arr = new Object[size];  
14.         front = 0;  
15.         rear = 0;  
16.     }  
17.   
18.     // 将元素追加到队列尾部  
19.     public boolean enqueue(T data) {  
20.         if ((rear + 1) % arr.length == front) { // 判断队列是否已满  
21.             System.out.println("队列已满,无法入队..");  
22.             return false;  
23.         }  
24.         arr[rear] = data; // 将元素data赋值到队尾  
25.         System.out.println(data + "入队..");  
26.         rear = (rear + 1) % arr.length; // real下标向后移一位,若到最后则转到数组头部  
27.         return true;  
28.     }  
29.   
30.     // 队列头部的第一个元素出队  
31.     @SuppressWarnings("unchecked")  
32.     public T dequeue() {  
33.         if (rear == front) { // 判断队列是否为空  
34.             System.out.println("队列已空,无法出队..");  
35.             return null;  
36.         }  
37.         Object data = arr[front];  
38.         System.out.println(data + "出队..");  
39.         front = (front + 1) % arr.length; // front下标向后移一位,若到最后则转到数组头部  
40.         return (T) data;  
41.     }  
42.   
43.     // 获取队列中元素个数  
44.     public int size() {  
45.         return (rear - front + arr.length) % arr.length;  
46.     }  
47.   
48.     public static void main(String[] args) {  
49.         LoopQueue<String> queue = new LoopQueue<String>();  
50.         queue.enqueue("张三");  
51.         queue.dequeue();  
52.         queue.enqueue("李四");  
53.         queue.enqueue("王五");  
54.         queue.enqueue("赵六");  
55.         queue.dequeue();  
56.         queue.enqueue("田七");  
57.         queue.dequeue();  
58.         queue.enqueue("周八");  
59.         System.out.println("队列中元素个数为: " + queue.size());  
60.     }  
61. }  

6. 循环队列的不足:

如果只是顺序存储，算法的性能不咋的，但是循环队列却不得不面临数组可能溢出的问题，有什么好的解决办法吗？

请见下节 -- 链队列，未完待续 . . .