数据结构与算法02 -- 队列，数组实现队列，环形队列
队列
队列是一个有序列表，可以用数组或是链表来实现
先进先出
队列的输出、输入是分别从前后端来处理，因此需要两个变量 front 以及 rear 记录队列前后端的下标，front 会随着数据输出而改变，而 rear 则是随着数据输入而改变。
maxSize记录该队列的最大容量
数据存入队列
addQueue
-
当 front == rear 时，即队列为空，将尾指针往后移
-
若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear 所指的数组元素中，否则无法存入数据。
rear == maxSize - 1 队列满
数组模拟队列
package queue;
import java.util.Scanner;
// array --> queue
public class Demo00 {
public static void main(String[] args) {
// test
// create an queue
ArrayQueue queue = new ArrayQueue(3);
char key = ' '; // 接受用户输入
Scanner scanner = new Scanner(System.in);
boolean loop = true;
// 输出一个菜单
while(loop){
System.out.println("s(show):show the queue");
System.out.println("e(exit):exit the app");
System.out.println("a(add):add data to the queue");
System.out.println("g(get):get data from the queue");
System.out.println("h(head):look head data");
key = scanner.next().charAt(0); // 接受一个字符
switch (key){
case 's':
queue.showQueue();
break;
case 'a':
System.out.println("please input a num");
int value = scanner.nextInt();
queue.addQueue(value);
break;
case 'g': // 取出数据
try{
int res = queue.getQueue();
System.out.printf("data is %d\n",res);
}catch (Exception e){
// handle exception
System.out.println(e.getMessage());
}
break;
case 'h':
try{
int res = queue.headQueue();
System.out.printf("head is %d\n",res);
}catch (Exception e){
System.out.println(e.getMessage());
}
break;
case 'e':
scanner.close();
loop = false;
break;
default:
break;
}
}
System.out.println("app exit");
}
}
// use array mimic queue -- write an ArrayQueue class
class ArrayQueue{
private int maxSize;
private int front; // point to queue head
private int rear; // point to queue tail
private int[] arr; // mimic queue
// create queue's constructor
public ArrayQueue(int arrMaxSize){
maxSize = arrMaxSize;
arr = new int[maxSize];
front = -1; // 指向队列头的前一个位置
rear = -1; // 指向队列尾的数据（即就是队列最后一个数据）
}
// 判断队列是否满
public boolean isFull(){
return rear == maxSize - 1;
}
// 判断队列是否为空
public boolean isEmpty(){
return rear == front;
}
// 添加数据到队列
public void addQueue(int n){
// 判断队列是否满
if(isFull()){
System.out.println("full");
return;
}
rear++; // 让 rear 后移
arr[rear] = n;
}
// 获取队列的数据，出队列
public int getQueue(){
// 判断队列是否空
if(isEmpty()){
// 通过抛出异常处理
throw new RuntimeException("empty");
}
front++; // front 后移
return arr[front];
}
// 显示队列所有数据
public void showQueue(){
// 遍历
if(isEmpty()){
System.out.println("empty queue");
}
for (int i = 0; i < arr.length; i++) {
System.out.printf("arr[%d] = %d\n",i,arr[i]);
}
}
// 显示队列的头数据，注意：不是取出数据
public int headQueue(){
// 判断
if(isEmpty()){
throw new RuntimeException("empty");
}
return arr[front+1]; // 因为front指向的是头的前一个数据
}
}
问题：目前数组使用一次就不能复用，没有充分的利用数组空间
改进：使用算法将数组改为环形队列 – 取模
数组模拟环形队列
- front 变量含义调整：front 就指向队列的第一个元素，也就是说 arr[front] 就是队列的第一个元素, front 初始值 = 0；
- rear 变量含义调整：rear 指向队列的最后一个元素的后一个位置，希望空出一个空间作为约定，rear 初始值 = 0；
- 当队列满时，条件是 [rear + 1] % maxSize == front
- 当队列为空的条件，rear == front
- 队列中有效的数据的个数：[rear + maxSize - front] % maxSize
package queue;
import java.util.Scanner;
// circle -- queue
public class Demo01 {
public static void main(String[] args) {
System.out.println("arr--circle queue");
circleQueue queue = new circleQueue(4); // 队列的有效数据最大是3
char key = ' '; // 接受用户输入
Scanner scanner = new Scanner(System.in);
boolean loop = true;
// 输出一个菜单
while(loop){
System.out.println("s(show):show the queue");
System.out.println("e(exit):exit the app");
System.out.println("a(add):add data to the queue");
System.out.println("g(get):get data from the queue");
System.out.println("h(head):look head data");
key = scanner.next().charAt(0); // 接受一个字符
switch (key){
case 's':
queue.showQueue();
break;
case 'a':
System.out.println("please input a num");
int value = scanner.nextInt();
queue.addQueue(value);
break;
case 'g': // 取出数据
try{
int res = queue.getQueue();
System.out.printf("data is %d\n",res);
}catch (Exception e){
// handle exception
System.out.println(e.getMessage());
}
break;
case 'h':
try{
int res = queue.headQueue();
System.out.printf("head is %d\n",res);
}catch (Exception e){
System.out.println(e.getMessage());
}
break;
case 'e':
scanner.close();
loop = false;
break;
default:
break;
}
}
System.out.println("app exit");
}
}
class circleQueue{
private int maxSize;
private int front; // point to queue head
private int rear; // point to queue tail
private int[] arr; // mimic queue
// create queue's constructor
public circleQueue(int arrMaxSize){
maxSize = arrMaxSize;
arr = new int[maxSize];
//front = 0; // 指向队列头
//rear = 0; // 指向队列尾的下一个数据
}
// 判断队列是否满
public boolean isFull(){
return (rear+1) % maxSize == front;
}
// 判断队列是否为空
public boolean isEmpty(){
return rear == front;
}
// 添加数据到队列
public void addQueue(int n){
// 判断队列是否满
if(isFull()){
System.out.println("full");
return;
}
arr[rear] = n;
// 将 rear 后移，必须考虑取模
rear = (rear+1) % (maxSize);
}
// 获取队列的数据，出队列
public int getQueue(){
// 判断队列是否空
if(isEmpty()){
// 通过抛出异常处理
throw new RuntimeException("empty");
}
// front 指向的是队列的第一个元素
// 1 先把 front 对应的值保存在临时变量中
// 2 把 front 后移
// 3 将临时保存的变量返回
int value = arr[front];
front = (front+1) % maxSize; // front 后移
return value;
}
// 显示队列所有数据
public void showQueue(){
// 遍历
if(isEmpty()){
System.out.println("empty queue");
}
// 从 front 开始遍历
for (int i = front; i < front+size(); i++) {
System.out.printf("arr[%d] = %d\n",i % maxSize,arr[i % maxSize]);
}
}
// 求出当前队列有效数据的个数
public int size(){
return (rear+maxSize-front) % maxSize;
}
// 显示队列的头数据，注意：不是取出数据
public int headQueue(){
// 判断
if(isEmpty()){
throw new RuntimeException("empty");
}
return arr[front]; // 因为front指向的是头的前一个数据
}
}