java数据结构——队列、循环队列（Queue）

每天进步一点点，坚持就是成功。

1、队列

 1 /**
 2  * 人无完人，如有bug，还请斧正
 3  * 继续学习Java数据结构————队列（列队） 
 4  * 队列和栈一样，都是使用数组，但是队列多了一个队头，队头访问数据，队尾插入数据
 5  * 队列的重要数据特性————先进先出
 6  * 入队、出队、队满、队空、查看
 7  */
 8 public class Queue {
 9     private long arr[];
10     private int Maxsize;// 最大容量
11     private int front;// 队头，访问数据
12     private int rear;// 队尾，插入数据
13     private int elements;// 有效数据
14  
15     public Queue(int size) {
16         this.Maxsize = size;
17         arr = new long[Maxsize];
18         front = 0;// 下标为0开始访问
19         rear = -1;// 相当于栈的指针
20         elements = 0;
21     }
22     // 有效数据
23     public void show() {
24         System.out.println(elements);
25     }
26     // 查看当前指向数据
27     public long peek() {
28         return arr[front];
29     }
30     // 入队
31     public void add(int value) {
32         arr[++rear] = value;
33         elements++;
34     }
35     // 出队
36     public long remove() {
37         long value = arr[front++];// 队头从0开始
38         elements--;
39         return value;
40     }
41     // 队满
42     public boolean isEmpty() {
43         return elements == 0;
44     }
45     // 队空
46     public boolean isFull() {
47         return elements == Maxsize;
48     }
49  
50     public static void main(String[] args) {
51         Queue q = new Queue(3);
52         q.add(52);
53         q.add(2);
54         q.add(6);
55          
56         while(!q.isEmpty()){
57             System.out.print(q.remove()+" ");//先进先出
58         }
59          
60     }
61  
62 }

 

 

2、循环队列

队列存在弊端，超过最大长度就会抛出异常，这是不好的，所以我们必须了解循环队列，即使超过长度在添加也是可行的。

 1 //循环队列
 2 public class Queue {
 3     private long arr[];
 4     private int Maxsize;// 最大容量
 5     private int front;// 队头，访问数据
 6     private int rear;// 队尾，插入数据
 7     private int elements;// 有效数据
 8 
 9     public Queue(int size) {
10         this.Maxsize = size;
11         arr = new long[Maxsize];
12         front = 0;// 下标为0开始访问
13         rear = -1;// 相当于栈的指针
14         elements = 0;
15     }
16 
17     // 有效数据
18     public void show() {
19         System.out.println(elements);
20     }
21 
22     // 查看当前指向数据
23     public long peek() {
24         return arr[front];
25     }
26 
27     // 入队
28     public void add(int value) {
29         if (rear == arr.length - 1) {// rear初始值为-1，下标0-99
30             rear = -1;// 重置队尾
31         }
32         arr[++rear] = value;// 这时候指向第一个位置
33         elements++;
34     }
35 
36     // 出队
37     public long remove() {
38         long value = arr[front++];// 先执行该句，front是否等于arr.length
39         if (front == arr.length) {// 2+1=3
40             front = 0;// 重置队头
41         }
42         elements--;
43         return value;
44     }
45 
46     // 队满
47     public boolean isEmpty() {
48         return elements == 0;
49     }
50 
51     // 队空
52     public boolean isFull() {
53         return elements == Maxsize;
54     }
55 
56     public static void main(String[] args) {
57         Queue q = new Queue(3);
58         q.add(52);
59         q.add(2);
60         q.add(6);
61         q.add(6);
62         q.add(6);
63 
64         while (!q.isEmpty()) {
65             System.out.print(q.remove() + " ");// 先进先出
66         }
67 
68     }
69 
70 }

 

 

　　

转载于:https://www.cnblogs.com/hardhp74520/p/11305560.html