定义
队列是一种运算受限制的线性表，元素的添加与删除在表的两端，可添加元素的称为队尾，可删除元素的一端称为队头，顺序存储的队列称为顺序栈，将头尾相接的队列称为循环队列。平时很少用到，先把代码贴出来。
代码(来源：https://www.cnblogs.com/CherishFX/p/4608880.html)
队列顺序存储结构实现
public class Queue<E> {
private Object[] data=null;
private int maxSize; //队列容量
private int front; //队列头，允许删除
private int rear; //队列尾，允许插入
//构造函数
public Queue(){
this(10);
}
public Queue(int initialSize){
if(initialSize >=0){
this.maxSize = initialSize;
data = new Object[initialSize];
front = rear =0;
}else{
throw new RuntimeException("初始化大小不能小于0：" + initialSize);
}
}
//判空
public boolean empty(){
return rear==front?true:false;
}
//插入
public boolean add(E e){
if(rear== maxSize){
throw new RuntimeException("队列已满，无法插入新的元素！");
}else{
data[rear++]=e;
return true;
}
}
//返回队首元素，但不删除
public E peek(){
if(empty()){
throw new RuntimeException("空队列异常！");
}else{
return (E) data[front];
}
}
//出队
public E poll(){
if(empty()){
throw new RuntimeException("空队列异常！");
}else{
E value = (E) data[front]; //保留队列的front端的元素的值
data[front++] = null; //释放队列的front端的元素
return value;
}
}
//队列长度
public int length(){
return rear-front;
}
}
循环队列的顺序存储实现
import java.util.Arrays;
public class LoopQueue<E> {
public Object[] data = null;
private int maxSize; // 队列容量
private int rear;// 队列尾，允许插入
private int front;// 队列头，允许删除
private int size=0; //队列当前长度
public LoopQueue() {
this(10);
}
public LoopQueue(int initialSize) {
if (initialSize >= 0) {
this.maxSize = initialSize;
data = new Object[initialSize];
front = rear = 0;
} else {
throw new RuntimeException("初始化大小不能小于0：" + initialSize);
}
}
// 判空
public boolean empty() {
return size == 0;
}
// 插入
public boolean add(E e) {
if (size == maxSize) {
throw new RuntimeException("队列已满，无法插入新的元素！");
} else {
data[rear] = e;
rear = (rear + 1)%maxSize;
size ++;
return true;
}
}
// 返回队首元素，但不删除
public E peek() {
if (empty()) {
throw new RuntimeException("空队列异常！");
} else {
return (E) data[front];
}
}
// 出队
public E poll() {
if (empty()) {
throw new RuntimeException("空队列异常！");
} else {
E value = (E) data[front]; // 保留队列的front端的元素的值
data[front] = null; // 释放队列的front端的元素
front = (front+1)%maxSize; //队首指针加1
size--;
return value;
}
}
// 队列长度
public int length() {
return size;
}
//清空循环队列
public void clear(){
Arrays.fill(data, null);
size = 0;
front = 0;
rear = 0;
}
}
队列的链式存储结构的实现
public class LinkQueue<E> {
// 链栈的节点
private class Node<E> {
E e;
Node<E> next;
public Node() {
}
public Node(E e, Node next) {
this.e = e;
this.next = next;
}
}
private Node front;// 队列头，允许删除
private Node rear;// 队列尾，允许插入
private int size; //队列当前长度
public LinkQueue() {
front = null;
rear = null;
}
//判空
public boolean empty(){
return size==0;
}
//插入
public boolean add(E e){
if(empty()){ //如果队列为空
front = new Node(e,null);//只有一个节点，front、rear都指向该节点
rear = front;
}else{
Node<E> newNode = new Node<E>(e, null);
rear.next = newNode; //让尾节点的next指向新增的节点
rear = newNode; //以新节点作为新的尾节点
}
size ++;
return true;
}
//返回队首元素，但不删除
public Node<E> peek(){
if(empty()){
throw new RuntimeException("空队列异常！");
}else{
return front;
}
}
//出队
public Node<E> poll(){
if(empty()){
throw new RuntimeException("空队列异常！");
}else{
Node<E> value = front; //得到队列头元素
front = front.next;//让front引用指向原队列头元素的下一个元素
value.next = null; //释放原队列头元素的next引用
size --;
return value;
}
}
//队列长度
public int length(){
return size;
}
}
基于LinkedList的队列结构
/**
* 使用java.util.Queue接口,其底层关联到一个LinkedList（双端队列）实例.
*/
import java.util.LinkedList;
import java.util.Queue;
public class QueueList<E> {
private Queue<E> queue = new LinkedList<E>();
// 将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回 true，
//如果当前没有可用的空间，则抛出 IllegalStateException。
public boolean add(E e){
return queue.add(e);
}
//获取，但是不移除此队列的头。
public E element(){
return queue.element();
}
//将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，
//此方法通常要优于 add(E)，后者可能无法插入元素，而只是抛出一个异常。
public boolean offer(E e){
return queue.offer(e);
}
//获取但不移除此队列的头；如果此队列为空，则返回 null
public E peek(){
return queue.peek();
}
//获取并移除此队列的头，如果此队列为空，则返回 null
public E poll(){
return queue.poll();
}
//获取并移除此队列的头
public E remove(){
return queue.remove();
}
//判空
public boolean empty() {
return queue.isEmpty();
}
}
网友评论