队列

队列
队列和栈一样都是受限的数据结构，栈是先进后出，而队列就像排队一样，先来的先走，也就是先进先出。
队列的入队方法enqueue()，出队方法dequeue()

基于数组的实现的队列叫做顺序队列，用链表实现的队列叫作链式队列

// 用数组实现的队列
public class ArrayQueue {
  // 数组：items，数组大小：n
  private String[] items;
  private int n = 0;
  // head 表示队头下标，tail 表示队尾下标
  private int head = 0;
  private int tail = 0;
  // 申请一个大小为 capacity 的数组
  public ArrayQueue(int capacity) {
    items = new String[capacity];
    n = capacity;
  }
  // 入队
  public boolean enqueue(String item) {
    // 如果 tail == n 表示队列已经满了
    if (tail == n) return false;
    items[tail] = item;
    ++tail;
    return true;
  }
   // 入队操作，将 item 放入队尾
  public boolean enqueue(String item) {
    // tail == n 表示队列末尾没有空间了
    if (tail == n) {
      // tail ==n && head==0，表示整个队列都占满了
      if (head == 0) return false;
      // 数据搬移
      for (int i = head; i < tail; ++i) {
        items[i-head] = items[i];
      }
      // 搬移完之后重新更新 head 和 tail
      tail -= head;
      head = 0;
    }
    items[tail] = item;
    ++tail;
    return true;
  }
  // 出队
  public String dequeue() {
    // 如果 head == tail 表示队列为空
    if (head == tail) return null;
    // 为了让其他语言的同学看的更加明确，把 -- 操作放到单独一行来写了
    String ret = items[head];
    ++head;
    return ret;
  }
}
//基于链表的实现方法
public class QueueBasedOnLinkedList {
    // 队列的对首和对尾
    private Node head=null;
    private Node tail=null;
    //入队
    public void enqueue(String value){
        if(tail==null){
            Node newNode=new Node(value,null);
            head=newNode;
            tail=newNode;
        }else{
            tail.next=new Node(value,null);
            tail=tail.next;
        }
    }
    //出队
    public String dequeue(){
        if(head==null) return null;
         String value=head.data;
         head=head.next;
        if(head==null){
            tail=null;
         }
        return value;
    }

    private static class Node{
        private String data;
        private Node next;

        public Node(String data,Node next){
            this.data=data;
            this.next=next;
        }

        public String getData(){
            return data;
         }
    }

    public static void main(String[] args) {
        QueueBasedOnLinkedList queue=new QueueBasedOnLinkedList();
        queue.enqueue("1");
        queue.enqueue("2");
        queue.enqueue("3");
        System.out.println(queue.dequeue());
        System.out.println(queue.dequeue());
        System.out.println(queue.dequeue());
    }
}

循环队列 ：关键确定好队空和队满的判定条件，当tailhead时，队列是空的，当(tail+1)%nhead,这时候队列以满。唯一的缺陷就是会浪费一个存储单元。

循环队列代码
public class CircularQueue {
  // 数组：items，数组大小：n
  private String[] items;
  private int n = 0;
  // head 表示队头下标，tail 表示队尾下标
  private int head = 0;
  private int tail = 0;

  // 申请一个大小为 capacity 的数组
  public CircularQueue(int capacity) {
    items = new String[capacity];
    n = capacity;
  }

  // 入队
  public boolean enqueue(String item) {
    // 队列满了
    if ((tail + 1) % n == head) return false;
    items[tail] = item;
    tail = (tail + 1) % n;
    return true;
  }

  // 出队
  public String dequeue() {
    // 如果 head == tail 表示队列为空
    if (head == tail) return null;
    String ret = items[head];
    head = (head + 1) % n;
    return ret;
  }
}