实现一个简单的队列（底层数组）

队列的特点

  1. 先进先出（FIFO）
  2. 允许在表的一端插入数据，在另一端删除数据

 

所需元素

  1. 数组queueArray
  2. 指向队头的指针front
  3. 指向队尾的指针rear
  4. 记录队列元素数量的elements
  5. 数组的初始化大小maxSize

 

分析实现

　　1. 在实例化队列类时确定数组大小并初始化数组
　　2. 确定队列具有的功能：

　　　　（1）EnQueue(Object obj) 　　插入元素，即元素入队，并且是在队尾入队

　　　　（2）DeQueue() 　　删除元素，即元素出队，并且是在队头出队

　　　　（3）isEmpty()　　判空

　　　　（4）isFull() 　　判满

　　　　（5）getHead() 　　查看队头元素，只查看，不删除

　　　　（6）length()　　查看队列长度

　　　　（7）clear()　　清空队列

 

代码实现

 1 public class Queue {
 2 
 3     /**
 4      * queueArray 底层数组
 5      * front 队头
 6      * rear 队尾
 7      * elements 队列元素
 8      * maxSize 数组最大容量
 9      */
10     private Object[] queueArray;
11     private int front;
12     private int rear;
13     private int elements;
14     private int maxSize;
15 
16     /**
17      * 初始化操作
18      * @param maxSize
19      */
20     public Queue(int maxSize) {
21         this.maxSize = maxSize;
22         this.queueArray = new Object[maxSize];
23         this.front = 0;
24         this.rear = 0;
25         this.elements = 0;
26     }
27 
28     /**
29      * 判断队列是否为空
30      * @return
31      */
32     public boolean isEmpty() {
33         return (elements == 0);
34     }
35 
36     /**
37      * 判断队列是否为满队列
38      * @return
39      */
40     public boolean isFull() {
41         return (elements == maxSize);
42     }
43 
44     /**
45      * 插入元素，即元素入队，并且是在队尾入队
46      * @param data
47      */
48     public void enQueue(Object data) {
49         if (isFull()) {
50             throw new RuntimeException("队列已满");
51         }
52         queueArray[rear++] = data;
53         elements++;
54     }
55 
56     /**
57      * 删除元素，即元素出队，并且是在队头出队
58      * @return
59      */
60     public Object deQueue() {
61         if (isEmpty()) {
62             throw new RuntimeException("空队列");
63         }
64         // 其实这里并没有真正删除数组里的元素，只是访问指针往上移，即不提供访问被删除元素的方式
65         Object data = queueArray[front++];
66         elements--;
67         return data;
68     }
69 
70     /**
71      * 查看队头元素，只查看，不删除
72      * @return
73      */
74     public Object getHead() {
75         Object data = queueArray[front];
76         return data;
77     }
78 
79     /**
80      * 查看队列长度
81      * @return
82      */
83     public int length() {
84         return elements;
85     }
86 
87     /**
88      * 清空队列
89      */
90     public void clear() {
91         while (front != rear) {
92             deQueue();
93         }
94     }
95 }

 

测试

 1 public class QueueTest {
 2 
 3     public static void main(String[] args) {
 4 
 5         Queue queue = new Queue(4);
 6 
 7         System.out.println("队列是否为空? " + queue.isEmpty());
 8 
 9         queue.enQueue(11);
10         queue.enQueue(2);
11         queue.enQueue(5);
12         queue.enQueue(67);
13 
14         System.out.println("队列是否已满? " + queue.isFull());
15         System.out.println("队头元素： " + queue.getHead());
16         System.out.println("队列长度： " + queue.length());
17 
18         System.out.print("打印队列元素： ");
19         while (!queue.isEmpty()) {
20             Object o = queue.deQueue();
21             System.out.print(o + "\t");
22         }
23         System.out.println();
24 
25         /*queue.enQueue(5);
26         queue.enQueue(67);*/
27         // 清空队列
28         queue.clear();
29         System.out.println("清空队列后，队列是否为空? " + queue.isEmpty());
30     }
31 }

 

结果

队列是否为空? true
队列是否已满? true
队头元素： 11
队列长度： 4
打印队列元素： 11    2    5    67    
清空队列后，队列是否为空? true

 

 

总结

  1. 只允许在队尾rear插入元素；
  2. 只允许在队头front删除元素；
  3. 本例子插入和删除都是队头队尾指针的移动，所存储的元素并不会移动；
  4. 删除的元素其实还存在数组中，只是不提供访问的方法；
  5. 使用数组实现，扩容困难。

 

posted @ 2018-06-29 19:19  shadowdoor  阅读(1268)  评论(0)  编辑  收藏  举报