顺序队列
概念：
队列是一种先进先出的线性表，只允许在一端插入，另一端删除。允许插入的一端称为队尾，允许删除的一端称为队头
顺序队列的实现：
import org.junit.jupiter.api.Test;
/**
* 顺序队列
* @author wydream
*
*/
public class QueueSequence {
private String[] arr;//队列数组
private int end=0;//队尾标志
//向队列中添加元素
public void push(String[] arr,String value) {
if(end<arr.length) {
arr[end]=value;
end++;
return;
}else {
System.out.println("队列已经满了");
return;
}
}
//取出队列元素
public String pop(String[] arr) {
String rs;
if(arr[0]==null) {
System.out.println("队列为空,请先向队列中添加元素");
return null;
}else {
rs=arr[0];
arr[0]=null;
move(arr);
return rs;
}
}
//队列元素向前移动
public void move(String[] arr) {
for(int i=0;i<arr.length-1;i++) {
if(arr[i+1]!=null) {
arr[i]=arr[i+1];
}else{
arr[i]=null;
break;
}
}
}
@Test
public void test() {
String[] arr=new String[10];
push(arr,"北京");
push(arr,"上海");
push(arr,"广东");
push(arr,"杭州");
push(arr,"苏州");
push(arr,"扬州");
pop(arr);
pop(arr);
pop(arr);
pop(arr);
}
}
循环队列
概念：
顺序队列的不足：顺序队列在进行插入操作时，直接在队尾插入就可以，此时时间复杂度为O(1)，但是在出列是在队头，即下标为0的位置，也就意味着队列中所有的元素都得向前移动，此时时间复杂度为0(n)，效率较低。
队列出列时不需要所有的元素都移动，引入两个指针即可，一个头指针front指向队头元素，一个尾指针rear指向队尾元素，此时队列出列只需移动指针即可。但是此种情况下会出现一种溢出情况（如下图），此时队列中任然是有空间的可以存放元素的，但是尾指针已经溢出，于是就有了循环队列。
front指向队头，rear指向队尾的下一个位置；队为空的判断：front==rear；队为满的判断：(rear+1)%MAXSIZE==front
实现循环队列：
/**
* java实现循环队列
* @author wydream
*
*/
import org.junit.jupiter.api.Test;
public class QueueArray {
Object[] arr=new Object[10];;//对象数组，队列最多存储a.length-1个对象
int front=0;//队首下标
int rear=0;//队尾下标
/**
* 将一个对象追加到队列尾部
*/
public boolean enqueue(Object obj) {
if((rear+1)%arr.length==front) {
return false;
}
arr[rear]=obj;
rear=(rear+1)%arr.length;
return true;
}
//出队列
public Object dequeue() {
if(rear==front) {
return null;
}
Object obj=arr[front];
front=(front+1)%arr.length;
return obj;
}
@Test
public void test() {
QueueArray q=new QueueArray();
System.out.println(q.enqueue("北京"));
System.out.println(q.enqueue("上海"));
System.out.println(q.enqueue("广东"));
System.out.println(q.enqueue("深圳"));
for(int i=0;i<4;i++){
System.out.println(q.dequeue());
}
}
}
