一、概述
队列是一种基于先进先出(FIFO)的数据结构，是一种只能在一端进行插入,在另一端进行删除操作的特殊线性表，它按照先进先出的原则存储数据，先进入的数据，在读取数据时先读被读出来。
二、链式队列
2.1 API设计
| 类名 | Queue |
|---|---|
| 构造方法 | Queue()：创建Queue对象 |
| 成员方法 | 1.public boolean isEmpty()：判断队列是否为空，是返回true，否返回false 2.public int size():获取队列中元素的个数 3.public T dequeue():从队列中拿出一个元素 4.public void enqueue(T t)：往队列中插入一个元素 |
| 成员变量 | 1.private Node head:记录首结点 2.private int N:当前栈的元素个数 3.private Node last:记录最后一个结点 |
2.2 实现
public class Queue<T> implements Iterable<T> {
// 记录首节点
private Node head;
//记录最后一个结点
private Node last;
//记录队列中元素的个数
private int N;
private class Node {
public T item;
public Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
}
public Queue() {
head = new Node(null, null);
last = null;
N = 0;
}
//判断队列是否为空
public boolean isEmpty() {
return N == 0;
}
//返回队列中元素的个数
public int size() {
return N;
}
// 向队列中插入元素t
public void enqueue(T t) {
if (last == null) {
last = new Node(t, null);
head.next = last;
} else {
Node oldLast = last;
last = new Node(t, null);
oldLast.next = last;
}//个数+1
N++;
}
// 从队列中拿出一个元素
public T dequeue() {
if (isEmpty()) {
return null;
}
Node oldFirst = head.next;
head.next = oldFirst.next;
N--;
if (isEmpty()) {
last = null;
}
return oldFirst.item;
}
@Override
public Iterator iterator() {
return new QIterator();
}
private class QIterator implements Iterator<T> {
private Node n = head;
@Override
public boolean hasNext() {
return n.next != null;
}
@Override
public T next() {
Node node = n.next;
n = n.next;
return node.item;
}
}
}
2.3 测试
public class Test {
public static void main(String[] args) throws Exception {
Queue<String> queue = new Queue<>();
queue.enqueue("a");
queue.enqueue("b");
queue.enqueue("c");
queue.enqueue("d");
for (String str : queue) {
System.out.print(str + " ");
}
System.out.println("-----------------------------");
String result = queue.dequeue();
System.out.println("出列了元素：" + result);
System.out.println(queue.size());
}
}
三、顺序队列
3.1 API设计
| 类名 | ArrayQueue |
|---|---|
| 构造方法 | ArrayQueue()：创建ArrayQueue对象 |
| 成员方法 | 1.public boolean isEmpty()：判断队列是否为空，是返回true，否返回false 2.public int size():获取队列中元素的个数 3.public T dequeue():从队列中拿出一个元素 4.public void enqueue(T t)：往队列中插入一个元素 |
| 成员变量 | 1.private T[] queue:存储元素的数组 2.private int N:当前队列的元素个数 |
3.2 实现
/**
* 顺序队列
*
* @date 2021/6/22 23:03
*/
public class ArrayQueue<T> implements Iterable<T> {
private T[] queue;
private int N;
public ArrayQueue(int capacity) {
this.queue = (T[]) new Object[capacity];
this.N = 0;
}
public boolean isEmpty() {
return N == 0;
}
public int size() {
return N;
}
// 出队
public T dequeue() {
// 从数组头部出队列
T t = queue[0];
// 移动剩余元素
for (int i = 0; i < N; i++) {
queue[i] = queue[i + 1];
}
return t;
}
// 入队
public void enqueue(T t) {
queue[N] = t;
N++;
}
@Override
public Iterator<T> iterator() {
return new SIterator();
}
private class SIterator implements Iterator<T> {
private int index;
public SIterator(){
this.index = 0;
}
@Override
public boolean hasNext() {
return index < N;
}
@Override
public T next() {
return queue[index++];
}
}
}
3.3 测试
public class QueueTest {
public static void main(String[] args) throws Exception {
ArrayQueue<String> queue = new ArrayQueue<>(100);
queue.enqueue("a");
queue.enqueue("b");
queue.enqueue("c");
queue.enqueue("d");
for (String str : queue) {
System.out.print(str + " ");
}
System.out.println("-----------------------------");
String result = queue.dequeue();
System.out.println("出列了元素：" + result);
System.out.println(queue.size());
}
}