一.队列概念
队列是一种先进先出的数据结构,类似我们排队,头节点出,尾节点进
二.定义Queue接口
public interface Queue<E> {
/**
* 向队列尾添加元素
* @return 添加成功返回true,添加失败返回false
*/
boolean add(E e);
/**
* 从队列头删除一个节点,并取出该元素
* @return 队头元素
*/
E pull();
/**
* 从队列头取出该元素,但是不删除该节点
* @return 队头元素
*/
E peek();
/**
* 判断队列是否为空
* @return 空为true,非空为false
*/
boolean isEmpty();
/**
* 判断队列是否为满
* @return 满为true,不满为false
*/
boolean isFull();
}
三.单向带哨兵循环链表实现队列
/**
* 单向哨兵循环链表实现队列
* @author JJH
* @param <E>
*/
public class LinkedListQueue<E> implements Queue<E> ,Iterable<E> {
/**
* 节点类
*/
private static class Node<E>{
private E value; //节点值
private Node<E> next; //下一个节点
public Node(E value, Node<E> next) {
this.value = value;
this.next = next;
}
}
//属性
//头节点
private Node<E> head = new Node<>(null,null);
//尾节点
private Node<E> tail = head;
//当前的节点数
private int size;
//总的容量
private int capcity = Integer.MAX_VALUE;
{
//可以把共有的方法写在构造代码块里
//尾节点的下一个是头节点
tail.next = head;
}
public LinkedListQueue(int capcity){
this.capcity = capcity;
}
public LinkedListQueue() {
}
@Override
public boolean add(E e) {
/**
* 向队尾添加一个元素需要改变三个指针:
* 1.首先新建一个节点,
* 2.将尾节点(尾指针)的next指向 新节点
* 3.将尾指针(tail) 指向 新节点
* 4.新节点 的 next指向头节点
*/
Node<E> newNode = new Node<>(e,head);
tail.next = newNode;
tail = newNode;
size++; //当前长度加一
return true;
}
@Override
public E pull() {
//先判断是否为空
if (isEmpty()) {
return null;
}
Node<E> first = head.next;
E value = first.value;
//特殊情况,如果只有一个节点,那么应该让尾指针指向head
if(first == tail){
tail.next = head;
}
head.next = first.next;
size--; //当前长度减一
return value;
}
@Override
public E peek() {
if(isEmpty()){
return null;
}
return head.next.value;
}
@Override
public boolean isEmpty() {
//当尾指针和头指针相等时候就是空的,否则不是空
return tail == head;
}
@Override
public boolean isFull() {
//当当前长度等于总长度时为满
return size == capcity;
}
@Override
public Iterator<E> iterator() {
return new Iterator<E>() {
//刚开始p指向哨兵的下一个节点,因为哨兵节点只是用来标记,不起存储作用
Node<E> p = head.next;
@Override
public boolean hasNext() {
//当p到指向头节点的时候表示循环完了,就停止
return p != head;
}
@Override
public E next() {
E value = p.value;
p = p.next;
return value;
}
};
}
}
四.环形数组实现队列
/**
* 环形数组实现队列
* @author JJH
*/
public class ArrayQueue<E> implements Queue<E> ,Iterable<E>{
private final Object[] array;
private int head;
private int tail;
public ArrayQueue(int capacity){
//为了给判断满的尾指针空出最后一个位置,我们把容量加一
array = new Object[capacity+1];
}
@Override
public boolean add(E e) {
//先判断是否为满
if(isFull()){
return false;
}
array[tail] = e;
//尾指针向后移动一个位置
tail = (tail+1) % array.length;
return true;
}
@Override
public E pull() {
if(isEmpty()){
return null;
}
E value = (E) array[head];
//头指针向后移动一个位置
head = (head+1) % array.length;
return value;
}
@Override
public E peek() {
if (isEmpty()) {
return null;
}
return (E) array[head];
}
@Override
public boolean isEmpty() {
//当头指针和位置一样时为空
return head == tail;
}
@Override
public boolean isFull() {
//当尾指针的下一个是头指针时,为满
//为了能够循环,所有要对数组长度取模
return (head+1) % array.length == head;
}
@Override
public Iterator<E> iterator() {
return new Iterator<E>() {
int p = head;
@Override
public boolean hasNext() {
return p != tail;
}
@Override
public E next() {
E value = (E) array[p];
p = (p+1) % array.length;
return value;
}
};
}
}
五.带当前size的环形数组
我们在环形数组中添加一个size,用来表示当前元素的个数,这样可以根据简便的判断空,满等
public class ArrayQueue2<E> implements Queue<E>,Iterable<E>{
private final Object[] array;
private int head;
private int tail;
private int size; //当前的元素个数
public ArrayQueue2(int capacity){
//因为添加了size,所以不用加一
array = new Object[capacity];
}
@Override
public boolean add(E e) {
//先判断是否为满
if(isFull()){
return false;
}
array[tail] = e;
//尾指针向后移动一个位置
tail = (tail+1) % array.length;
//当前元素个数加一
size++;
return true;
}
@Override
public E pull() {
if(isEmpty()){
return null;
}
E value = (E) array[head];
//头指针向后移动一个位置
head = (head+1) % array.length;
//当前元素个数减一
size--;
return value;
}
@Override
public E peek() {
if (isEmpty()) {
return null;
}
return (E) array[head];
}
@Override
public boolean isEmpty() {
//当size为0时为空
return size == 0;
}
@Override
public boolean isFull() {
//当size等于数组长度时为满
return size == array.length;
}
@Override
public Iterator<E> iterator() {
return new Iterator<E>() {
int p = head;
int count = 0;
@Override
public boolean hasNext() {
return count < size;
}
@Override
public E next() {
E value = (E) array[p];
p = (p+1) % array.length;
count++;
return value;
}
};
}
}