队列的顺序存储结构
- 对于队列,是只允许在一端进行插入操作,在另一端进行删除操作的线性表。
首先,我们先看一下Queue的接口实现:
public interface Queue<E> extends Iterable<E>{
//获取队列中的元素个数
int getSize();
//判空
boolean isEmpty();
//增加元素
void enqueue(E e);
E dequeue();
//获取队头
E getFront();
//获取队尾
E getRear();
//清空队列
void clear();
}
在队列中也有顺序存储和链式存储结构。对于顺序存储结构来说,我们也可以利用ArrayList的类来实现队列的存储结构。对于队列我们直接来研究代码。
package DS01.动态数组;
import java.util.Iterator;
/**
* @author 七夏
* @param <E>
* 顺序队列
*/
public class ArrayQueue<E> implements Queue<E>{
private ArrayList<E> list;
public ArrayQueue(){
list = new ArrayList<>();
}
@Override
public int getSize() {
return list.getSize();
}
@Override
public boolean isEmpty() {
return list.isEmpty();
}
@Override
public void enqueue(E e) {
list.addLast(e);
}
@Override
public E dequeue() {
return list.removeFirst();
}
@Override
public E getFront() {
return list.getFirst();
}
@Override
public E getRear() {
return list.getLast();
}
@Override
public void clear() {
list.clear();
}
@Override
public Iterator<E> iterator() {
return list.iterator();
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(String.format("ArrayQueue: %d/%d \n",getSize(),list.getCapacity()));
sb.append('[');
if(isEmpty()){
sb.append(']');
}else{
for (int i = 0; i < getSize(); i++) {
sb.append(list.get(i));
if(i == list.getSize()-1){
sb.append(']');
}else{
sb.append(',');
}
}
}
return sb.toString();
}
}
队列的链式存储结构(以下是之前编写的代码,后面是使用LinkedList所实现的)
队列的链式存储结构其实和栈都是类似的,里面必须有一个Node类,用于存储每个元素的结点,它也必循由next指针,用于指向下一个元素结点,并且它必须有对头和队尾指针front和rear。
它的入队是从队尾插入,而出队是从对头删除。
class LinkedQueue<E>{
private Node<E> front,rear;//声明队头和队尾指针
public int size;
public LinkedQueue(){//初始化(让队头和队尾相等)
this.front = new Node<E>();
this.rear = this.front;
this.size = 0;
}
private class Node<E>{//结点Node类
E e;
private Node<E> next;
public Node(){
this(null,null);
}
public Node(E e){
this(e,null);
}
public Node(E data,Node<E> next){
this.e = data;
this.next = next;
}
public String toString(){
return e.toString();
}
}
public boolean isEmpty(){
return size==0;
}
//入队
public void EnQueue(E e){
Node<E> q = new Node<E>(e);//创建一个新的结点将值赋予结点
rear.next = q;//队尾结点的next指向新结点
rear = q;//然后将新结点地址赋予队尾结点(即,队尾结点现在成为入队的新结点)
size++;//长度+1
}
//出队
public void DeQueue(){
if(front==rear){//判断队列是否为空
System.out.println("队列已为空");
return;
}
front.next = front.next.next;//将队列的第一个结点“舍弃”
if(front.next==null){//如果对头结点的下一个结点为null,说明队列为空
rear = front;
}
size--;//长度-1
}
public int getSize(){
return size;
}
public String toString(){
StringBuilder sb = new StringBuilder();
sb.append('[');
if(isEmpty()){
return sb.append(']').toString();
}else{
Node<E> p = front;
for(int i=1;i<=size;i++){
sb.append(p.next.e);
p = p.next;
if(i==size){
return sb.append("]").toString();
}
sb.append(',');
}
}
return null;
}
}
利用LinkedList类所实现:
package DS02.动态链表;
import DS01.动态数组.Queue;
import java.util.Iterator;
/**
* @author 七夏
* @param <E>
* @version 1.0
* 链式队列
*/
public class LinkedQueue<E> implements Queue<E> {
private LinkedList<E> list;
public LinkedQueue(){
list = new LinkedList<>();
}
@Override
public int getSize() {
return list.getSize();
}
@Override
public boolean isEmpty() {
return list.isEmpty();
}
@Override
public void enqueue(E e) {
list.addLast(e);
}
@Override
public E dequeue() {
return list.removeFirst();
}
@Override
public E getFront() {
return list.getFirst();
}
@Override
public E getRear() {
return list.getLast();
}
@Override
public void clear() {
list.clear();
}
@Override
public Iterator<E> iterator() {
return list.iterator();
}
}