队列的实现(JAVA)

Posted 2020-07-30 小人物702

       定义

                     队列（queue）是一种特殊的线性表，它只允许在表的前端进行删除，在表的后端进行插入。

              进行插入端的称为队尾，进行删除端的称为队头。队列是先进先出原则的。队列的实现同样可以

              使用两种方式来实现，一种是数的实现方式，另一种是链表的实现方式。

       队列的实现 

                    我们已经知道队列已经有两种方式实现，虽然底层的实现方式不同，但是其具有的方法是相同

            的，我们采用接口定义其具有的操作。

[java] view plain copy

 

1. package com.kiritor;  
2. /** 
3.  * 队列FIFO的接口 
4.  * @author Kiritor 
5.  * */  
6. public interface Queue<T> {  
7.   
8.     /** 
9.      * 入队：从队尾加入一个元素 
10.      * @param t 
11.      * */  
12.      void add(T t);  
13.      /** 
14.       * 出队：移走队头元素并返回 
15.       * @return 当前队头元素*/  
16.       T remove();  
17.      /** 
18.       * 当前队列的元素个数*/  
19.       int size();  
20.       /** 
21.        * 判断当前队列是否为空 
22.        * @return */  
23.       boolean isEmpty();  
24.       /** 
25.        * 只是返回队头元素，并未删掉 
26.        * @return t*/  
27.       T front();    
28. }  

 

           队列的数组实现

 

[java] view plain copy

 

1. package com.kiritor;  
2.   
3. import java.util.Arrays;  
4.   
5. /** 
6.  * 基于数组实现的队列 
7.  * @author Kiritor*/  
8. public class ArrayQueue<T> implements Queue<T>{  
9.   
10.     private T[] data;  
11.     private int size;//元素个数  
12.     private int front;//队列中第一个对象的位置  
13.     private int rear;//队列中当前对象的位置  
14.     public ArrayQueue() {  
15.         data = (T[]) new Object[10];  
16.         size = 0;  
17.         front =0;  
18.         rear = 0;  
19.     }  
20.     @Override  
21.     public void add(T t) {  
22.         if(isFull())  
23.         {  
24.             resize();  
25.             front = 0;  
26.         }  
27.         rear = (front+size)%data.length;  
28.         System.out.println(rear);  
29.         data[rear] = t;  
30.         size++;  
31.     }  
32.   
33.     @Override  
34.     public T remove() {  
35.          if (isEmpty()) {    
36.                 throw new RuntimeException("队列为空!");    
37.             }    
38.             T tempData = data[front];    
39.             data[front] = null;    
40.             //思考一下这里有必要进行除法运算吗?  
41.             
42.             front = (front + 1) % (data.length);  
43.             size--;    
44.             return tempData;    
45.     }  
46.   
47.     @Override  
48.     public int size() {  
49.         return size;  
50.     }  
51.   
52.     @Override  
53.     public boolean isEmpty() {  
54.         return size == 0;  
55.     }  
56.   
57.     @Override  
58.     public T front() {  
59.          if (isEmpty()) {    
60.                 throw new RuntimeException("队列为空!");    
61.             }    
62.             return data[front];  
63.     }  
64.   
65.     /** 
66.      * 判断当前队列是否已满 
67.      * @return*/  
68.     public boolean isFull()  
69.     {  
70.         return size == data.length;  
71.     }  
72.     /** 
73.      * 扩容，2倍 
74.      * */  
75.     public void resize()  
76.     {  
77.         /*注意重新扩容的时候并不需要去设置size 
78.          * 队列的大小并不能通过数组的大小直观的显示出来。 
79.          * 但是栈就可以直观的通过数组的大小显示出来*/  
80.         T[] tmp = (T[]) new Object[data.length*2];  
81.         System.arraycopy(data, 0, tmp, 0, data.length);    
82.         data = tmp;    
83.         tmp = null;//引用置为空，便于gc处理    
84.     }  
85.     public static void main(String[] args) {  
86.         ArrayQueue<String> q = new ArrayQueue<String>();    
87.         q.add("a");    
88.         q.add("b");    
89.         q.add("c");    
90.         q.add("d");    
91.         q.add("e");    
92.         q.add("f");    
93.         q.add("g");    
94.         q.add("h");    
95.         q.add("i");    
96.         q.add("j");         
97.         q.add("k");    
98.         q.add("l");    
99.         q.add("m");    
100.         while( !q.isEmpty() ){    
101.             String temp = q.remove();    
102.             System.out.println(temp);    
103.         }    
104.     }  
105. }  

 

              队列的链表实现

 

[java] view plain copy

 

1. package com.kiritor;  
2. /** 
3.  * 队列的链表实现 
4.  * @author Kiritor 
5.  * @param <T>*/  
6. public class LinkQueue<T> implements Queue<T> {  
7.   
8.     private Node head;  
9.     private Node rear;  
10.     private int size;  
11.     public LinkQueue() {  
12.         head = null;  
13.         rear = null;  
14.         size = 0;  
15.     }  
16.     class Node  
17.     {  
18.         T data;  
19.         Node next;  
20.         public Node() {  
21.             //无参构造  
22.         }  
23.         public Node(T t)  
24.         {  
25.             this.data = t;  
26.         }  
27.     }  
28.     /** 
29.      * 从队列的尾部插入结点*/  
30.     @Override  
31.     public void add(T t) {  
32.         Node node = new Node(t);  
33.         /*如果是队列则头部和尾部都执行Node*/  
34.         if(isEmpty())     
35.             head = node;  
36.         else  
37.            rear.next = node;  
38.         rear = node;  
39.         size++;//队列长度+1  
40.     }  
41.   
42.     /** 
43.      * 从队列的头部删除 
44.      * @return T*/  
45.     @Override  
46.     public T remove() {  
47.         T  tmp;  
48.         if(isEmpty()){  
49.              new NullPointerException("队列是空的!");  
50.              tmp = null;  
51.         }  
52.         else  
53.         {  
54.             if(null==head.next )  
55.                 rear = null;  
56.             tmp = head.data;  
57.             head = head.next;  
58.             size--;  
59.         }  
60.         return tmp;  
61.     }  
62.   
63.     @Override  
64.     public int size() {  
65.         return size;  
66.     }  
67.   
68.     @Override  
69.     public boolean isEmpty() {  
70.         return head == null;  
71.     }  
72.     /** 
73.      * 查看队列头部,不做任何处理*/  
74.     @Override  
75.     public T front() {  
76.         if(head !=null)  
77.            return head.data;  
78.         return null;  
79.     }  
80.     public static void main(String[] args) {  
81.         LinkQueue<String> q = new LinkQueue<String>();    
82.         q.add("a");    
83.         q.add("b");    
84.         q.add("c");    
85.         q.add("d");    
86.         q.add("e");    
87.         q.add("f");    
88.         q.add("g");    
89.         q.add("h");    
90.         q.add("i");    
91.         q.add("j");         
92.         q.add("k");    
93.         q.add("l");    
94.         q.add("m");    
95.         System.out.println(q.size);  
96.         while( !q.isEmpty() ){    
97.             String temp = q.remove();    
98.             System.out.println(temp);    
99.             System.out.println(q.size());  
100.         }    
101.     }  
102. }  

                  看下链队列的演示操作吧