队列的顺序和链式存储结构Java实现

队列的顺序存储结构

• 对于队列，是只允许在一端进行插入操作，在另一端进行删除操作的线性表。

首先，我们先看一下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();
    }
}