数据结构-队列

队列概述

队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。

–队尾(rear)——允许插入的一端

–队头(front)——允许删除的一端

队列特点：先进先出(FIFO)

队列的结构

如下图所示：

线性表的操作主要包括：

（1）清空队列

（2）判断是否为空

（3）元素的个数

（4）入队列

（5）出队列

（6）取对头元素

接口

由此，对队列的抽象数据类型定义Queue接口如下：

[java]  view plain  copy

1. package queue;  
2.   
3. public interface Queue {  
4.     /** 
5.      * 清空队列 
6.      */  
7.     public void clear();  
8.     /** 
9.      * 出队列 
10.      * @return 
11.      */  
12.     public Object deQueue();  
13.     /** 
14.      * 判断是否为空 
15.      * @return 
16.      */  
17.     public boolean isEmpty();  
18.     /** 
19.      * 取对头元素 
20.      * @return 
21.      */  
22.     public Object peek();  
23.     /** 
24.      * 入队列 
25.      * @param obj 
26.      */  
27.     public void push(Object obj);  
28.     /** 
29.      * 元素的个数 
30.      * @return 
31.      */  
32.     public int size();  
33. }  

顺序循环队列

结构模型

•存在问题

设数组长度为M，则：

–当front=0,rear=M时，再有元素入队发生溢出—— 真溢出 

–当front!=0,rear=M时，再有元素入队发生溢出—— 假溢出

•解决方案

–队首固定，每次出队剩余元素向下移动——浪费时间

–循环队列

»基本思想：把队列 设想成环形，让sq[0]接在sq[M-1]之后，若rear+1==M,则令rear=0;

源代码

[java]  view plain  copy

1. package queue;  
2. /** 
3.  * 顺序循环队列 
4.  * @author Administrator 
5.  * 
6.  */  
7. public class ArrayQueue implements Queue {  
8.     private static  int  DEFAULT_SIZE = 10;   
9.     private Object array[] = null;  
10.     private int front, rear, count; //队首，队尾标注和队列的大小  
11.       
12.     public ArrayQueue() {  
13.         array = new Object[DEFAULT_SIZE];  
14.         front = rear = count = 0;  
15.     }  
16.   
17.     public boolean isEmpty() {  
18.         if((rear == front) && (0 == count))  
19.             return true;  
20.         else  
21.             return false;  
22.     }  
23.   
24.     public int size() {  
25.         return count;  
26.     }  
27.   
28.     @Override  
29.     public void push(Object obj) {  
30.         if((rear == front) && (count>0))  
31.             expand();  
32.         array[rear] = obj;  
33.         rear = (rear+1)%DEFAULT_SIZE;  
34.         count ++;  
35.     }  
36.       
37.     @Override  
38.     public Object deQueue() {  
39.         if(0 == count) {  
40.             throw new IllegalStateException("队列已空，无数据元素可出队列！");  
41.         } else {  
42.             Object obj = array[front];  
43.             front = (front+1)%DEFAULT_SIZE;  
44.             count --;  
45.             return obj;  
46.         }  
47.     }  
48.       
49.   
50.     @Override  
51.     public Object peek() {  
52.         if(0 == count) {  
53.             throw new IllegalStateException("队列已空，无数据元素可出队列！");  
54.         } else return array[front];  
55.     }  
56.   
57.     @Override  
58.     public void clear() {  
59.         for(int i=0; i<DEFAULT_SIZE; i++) {  
60.             array[i] = null;  
61.         }  
62.         front = rear = count = 0;  
63.     }  
64.       
65.     private void expand() {  
66.             Object newArray[] = new Object[2*DEFAULT_SIZE];  
67.             for(int i=0; i<count; i++) {  
68.                 newArray[i] = array[(front+i)%DEFAULT_SIZE];  
69.             }  
70.             array = newArray;  
71.             front = 0;   
72.             rear = count;  
73.             DEFAULT_SIZE = 2*DEFAULT_SIZE;  
74.     }  
75.       
76.     public String toString() {  
77.         String str= "[";  
78.         for(int i=0; i<count; i++) {  
79.             str =str + array[(front+i)%DEFAULT_SIZE];  
80.             str += ",  ";  
81.         }  
82.         str += "]";  
83.         return str;   
84.     }  
85.           
86. }  

链式队列

结构模型

设队首、队尾指针front和rear,front指向头结点，rear指向队尾

源代码

[java]  view plain  copy

1. package queue;  
2.   
3. /** 
4.  * 链队列的结点 
5.  * @author luoweifu 
6.  * 
7.  */  
8. class Node{  
9.     Object data;    //数据元素  
10.     Node next;      //后驱结点  
11.     public Node() {  
12.         this(null);  
13.     }  
14.     public Node(Object data) {  
15.         this.data = data;  
16.         this.next = null;  
17.     }  
18. }  
19. /** 
20.  * 链队列 
21.  * @author Administrator 
22.  * 
23.  */  
24. public class LinkQueue implements Queue{  
25.     private Node front,rear;    //队头指针和队尾指针  
26.     private int size;  
27.     public LinkQueue() {  
28.         front = rear = new Node();  
29.         size = 0;  
30.     }  
31.     @Override  
32.     public void clear() {  
33.         front.next = null;  
34.         rear = front;  
35.         size = 0;  
36.     }  
37.   
38.     @Override  
39.     public Object deQueue() {  
40.         Node p = front.next;  
41.         front.next = p.next;  
42.         rear = p.next;  
43.         size --;  
44.         return p.data;  
45.     }  
46.   
47.     @Override  
48.     public boolean isEmpty() {  
49.         if(size == 0)  
50.             return true;  
51.         else   
52.             return false;  
53.     }  
54.   
55.     @Override  
56.     public Object peek() {  
57.         return front.next.data;  
58.     }  
59.   
60.     @Override  
61.     public void push(Object obj) {  
62.         Node p = new Node(obj);  
63.         rear.next = p;  
64.         rear = p;  
65.         size ++;  
66.     }  
67.   
68.     @Override  
69.     public int size() {  
70.         return size;  
71.     }  
72.       
73.     public String toString() {  
74.         StringBuilder sb= new StringBuilder("[");  
75.         Node p = front;  
76.         while((p=p.next) != null) {  
77.             sb.append(p.data + ", ");  
78.         }  
79.         sb.append("]");  
80.         return sb.toString();     
81.     }  
82. }  

测试队列

[java]  view plain  copy

1. package queue;  
2.   
3. public class Test {  
4.     /** 
5.      * 测试队列 
6.      * 测试结果：各项功能正确无误 
7.      * @param args 
8.      */  
9.     public static void main(String[] args) {  
10.         //Queue queue = new LinkQueue();  
11.         Queue queue = new ArrayQueue();  
12.         for(int i=0; i<10; i++) {  
13.             queue.push(i);  
14.         }  
15.         System.out.println(queue);  
16.         Object obj1 = queue.deQueue();  
17.         Object obj2 = queue.deQueue();  
18.         System.out.println("count:" + queue.size() + "  obj1:" + obj1 + "  obj2:" + obj2);  
19.         System.out.println(queue);  
20.         System.out.println("peek:" + queue.peek());  
21.         //System.out.println(test.toString());  
22.           
23.         for(int i=0; i<12; i++) {  
24.             queue.push(i+10);  
25.         }  
26.     }  
27. }  

结果

[0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  ]
count:8  obj1:0  obj2:1
[2,  3,  4,  5,  6,  7,  8,  9,  ]
peek:2