数据结构与算法（5）队列

​ 不知道你有没有过在餐厅打饭的经历，我们排的队其实就是我们今天所讲的主题，我们在排队的时候，在队列头部的人打好饭离开，新来的人排在队尾。这就是入队和出队的操作。所以，队列的特性就是先进先出。有了这个概念，就可以开始今天的主题。先给出这篇文章的大致脉络：

首先，使用java语言描述了队列的基本操作，有链式存储和顺序

然后，介绍循环队列和一系列需要注意的知识点

最后，对队列进行一个总结。

OK，开始今天的文章。

一、队列基本操作

1、队列的基本认识

队列的基本特性就是先进先出（FIFO）。也就是第一个进去的元素，第一个出来。现在给出一个标准的定义：

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

既然是线性表，按照存储方式那就有两种存储方式，基于数组的顺序存储方式和基于链表的链式存储方式。

队列按照实现方式也分为两种：

①、单向队列（Queue）：只能在一端插入数据，另一端删除数据。

②、双向队列（Deque）：每一端都可以进行插入数据和删除数据操作。

有了对概念分类有了了解，下面我们就是用java代码来实现这些队列

2、顺序队列的实现

顺序队列是基于数组实现的，针对于队列的操作主要有以下几个

（1）插入（2）删除（3）查找元素（4）队列长度（5）是否为空、

我们先给出最基本的操作图解

下面就根据这几个常用的操作使用java代码来实现队列

首先，我们定义一个操作队列的接口

public interface Queue<T> {
	  //增加元素
	 void add(T t);
	  //删除元素
	  T remove();
	  //队列长度
	  int size();
	  //返回对头元素，并未删掉
	  T front();  
	  //是否为空
	  boolean isEmpty();
      //是否已满
      boolean isFull()
}

然后我们就开始去实现。

插入操作，我们首先要先判断当前队列是否已满，如果满了直接返回。接下来得到当前元素的位置。最后插入元素，再移动位置。

删除操作与插入操作类似，首先要先判断当前队列是否为空，如不为空再移动指针（这里不是指针，指的是指向当前元素位置的标志），删除元素。

判断当前元素是否为空和是否已满类似，只需要判断当前队列的元素数量。

下面给出代码实现。

public class ArrayQueue<T> implements Queue<T>{
	private T[] data;
	private int size;//元素个数
    private int front;//队列中第一个对象的位置
    private int rear;//队列中当前对象的位置
    //初始化方法
    public ArrayQueue() {
		data = (T[]) new Object[10];
	    size = 0;
	    front =0;
	    rear = 0;
	}
    //增加元素
	@Override
	public void add(T t) {
		if(isFull()){
			resize();
			front = 0;
		}
		rear = (front+size)%data.length;
		System.out.println(rear);
		data[rear] = t;
		size++;
	}
    //删除元素
	@Override
	public T remove() {
		 if (isEmpty()) {  
	            throw new RuntimeException("队列为空!");  
	        }  
	        T tempData = data[front];  
	        data[front] = null;  
	        front = (front + 1) % (data.length);
	        size--;  
	        return tempData;  
	}
    //取得队列大小
	@Override
	public int size() {
		return size;
	}
	@Override
	public boolean isEmpty() {
		return size == 0;
    }
    //判断当前队列是否已满
    @Override
	public boolean isFull(){
		return size == data.length;
	}
    //取得当前队头元素
	@Override
	public T front() {
		 if (isEmpty()) {  
	            throw new RuntimeException("队列为空!");  
	        }  
	        return data[front];
	}
	
	//扩容
	public void resize(){
		/*注意重新扩容的时候并不需要去设置size
		 * 队列的大小并不能通过数组的大小直观的显示出来。
		 * 但是栈就可以直观的通过数组的大小显示出来*/
		T[] tmp = (T[]) new Object[data.length*2];
		System.arraycopy(data, 0, tmp, 0, data.length);  
        data = tmp;  
        tmp = null;//引用置为空，便于gc处理  
	}
}

3、链式队列的实现

链式队列与顺序队列不同，每个节点不仅保存当前元素的值，还有指向下一个元素的指针。所以我们先看一下每个节点的图解形式

使用代码来表示就是

public class QueueNode<Item>{
    Item item;
    QueueNode next;
}

然后我们看链式队列入队和出队的操作

​ （a）空队列 （b）X入队 （c）y入队 （d）x出队

从上面的操作我们可以看到，实现上面的操作我们需要实现下面的代码

（1）一个指向FIFO头节点的指针

（2）一个指向FIFO尾节点的指针

（3）一个记录节点数的Int变量

private QueueNode first;//指向FIFO头节点的指针
private QueueNode last; //指向FIFO尾节点的指针
private int nodeNum;    //记录节点数的Int变量

（4）判断当前队列是否为空

 public boolean isEmpty(){
    return first == null;
 }

（5）队列的大小

public int size(){
    return nodeNum;
}

（6）入队和出队操作

//入队
public void enqueue(Item item) {
    QueueNode oldLast = last;
    last = new QueueNode();
    last.item = item;
    last.next = null;
    if (isEmpty()){
       first = last;
    } else{
        oldLast.next = last;
    }
    nodeNum++;    
}
//出队
public Item dequeue(){
    Item item = (Item) first.item;
    first = first.next;
    if (isEmpty()){
       last = null;
    }
    nodeNum--;
    return item;
}

（7）遍历

    private class LinkListIterator implements Iterator<Item>{
        QueueNode node = first;
        @Override
        public boolean hasNext(){
            return node.next != null;
        }
        @Override
        public Item next(){ 
            Item item = (Item) node.item;
            node = node.next;
            return item;
        }
    }

OK。有了上面的这些操作之后，下面给出一个完整的代码

public class Queue<Item> implements Iterable<Item>{
    private QueueNode first;
    private QueueNode last;
    private int nodeNum;
    public boolean isEmpty(){
        return first == null;
    }
    public int size(){
        return nodeNum;
    }
    public void enqueue(Item item){
        QueueNode oldLast = last;
        last = new QueueNode();
        last.item = item;
        last.next = null;
        if (isEmpty()){
            first = last;
        } else{
            oldLast.next = last;
        }
        nodeNum++;
    }
    public Item dequeue(){
        Item item = (Item) first.item;
        first = first.next;
        if (isEmpty()){
            last = null;
        }
        nodeNum--;
        return item;
    }
    @Override
    public Iterator<Item> iterator(){
        return new LinkListIterator();
    }
    private class LinkListIterator implements Iterator<Item>{
        QueueNode node = first;
        @Override
        public boolean hasNext(){
            return node.next != null;
        }
        @Override
        public Item next(){
            Item item = (Item) node.item;
            node = node.next;
            return item;
        }
    }
}

OK，上面就是顺序队列和链式队列的基本实现。下面我们将介绍一种新的队列循环队列，为什么要有这个队列，我们先要考虑一个问题，也就是我们的队列弹出一个元素，那么这个空间将不能使用。这就是假溢出问题：

为了解决这个问题所以才出现了一个新的队列-循环队列

二、循环队列

我们先给出队列的图解形式

有了循环队列的基本实现，我们思考一个问题，在之前我们可以根据rear直接得到当前队列是否为空和是否已满。那么在循环队列里面还可以这样嘛？当然不可以，我们需要考虑font和rear的位置关系来判断。我们看下面两种情况：

一种是队列为空的时候，front和rear都指向同一个位置。一种是队列已满的时候，front和rear指向的元素紧邻。

我们可以使用下面的公式来判断

我们代码实现一下循环队列

public interface IQueue {
	public void clear();
	public boolean isEmpty();
	public int length();
	public Object peek();// 取队首元素
	public void offer(Object x) throws Exception;// 入队
	public Object poll();// 出队
	public void display();
}

然后是接口的实现

public class CircleSqQueue implements IQueue {
	private Object[] queueElem;//队列存储空间
	private int front;//队首引用，若队列不为空，指向队首元素
	private int rear;//队尾引用，若队列不为空，指向队尾的下一个元素
	public CircleSqQueue(int maxsize) {
		front=rear=0;
		queueElem=new Object[maxsize];//分配maxsize个单元
	}
	@Override
	public void clear() {
		front=rear=0;
	}
	@Override
	public boolean isEmpty() {
		return rear==front;
	}
	@Override
	public int length() {
		return (rear-front+queueElem.length)%queueElem.length;
	}
	@Override
	public Object peek() {
		if(front==rear){
			return null;
		}
		else{
			return queueElem[front];
		}
	}
	@Override
	public void offer(Object x) throws Exception {
		if((rear+1)%queueElem.length==front){//队满
			throw new Exception("队列已满");
		}
		else{
			queueElem[rear]=x;
			rear=(rear+1)%queueElem.length;//修改队尾指针
		}
	}
	@Override
	public Object poll() {
		if(front==rear){
			return null;//队列为空
		}
		else{
			Object t=queueElem[front];
			front=(front+1)%queueElem.length;
			return t;
		}
	}
	@Override
	public void display() {
		if(!isEmpty()){
			for(int i=front;i!=rear;i=(i+1)%queueElem.length){
				System.out.println(queueElem[i].toString()+" ");
			}
		}
		else{
			System.out.println("此队列为空");
		}
	}
}

三、总结

对于队列主要在于面试中常见的算法题，因为概念非常容易理解，我们只要根据当前实现的代码进行一些变化就好。谢谢大家的关注。