【数据结构】队列（一）

队列   ——数组队列

 

目录

## 概念简述

## 特点

## 原理实现

## 时间复杂度分析

---

## 概念简述：

        队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作（出队），而在表的
        后端（rear）进行插入操作（入队），进行插入操作的端称为队尾，进行删除操作的端称为队首。队列中
        没有元素时，称为空队列。和栈一样，队列是一种操作受限制的线性表，相比数组，队列对应的操作是数
        组的子集。

 

## 特点：

        1. 只能从一端（队尾）添加元素，只能从另一端（队首）取出元素
        2. 存储元素先进先出（FIFO：first in first out）

 

## 原理实现：数组队列 (Java

      1. 准备接口

  // 准备接口
  public interface Queue<E>{
    int getSize();            
    boolean isEmpty();
    void enqueue(E e);        //入队
    E dequeue();              //出队
    E getFront();             //查看队首
  }

      2. 准备实现类

  // 准备实现类：基于动态数组实现
  public class ArrayQueue<E> implements Queue<E>{
      private Array<E> array;         // 自定义动态数组
      // 构造方法
      public ArrayQueue(){
          array = new Array<>()
      }
      public ArrayQueue(int capacity){        // 容积
          array = new Array<>(capacity);
      }

      @Override
      public int getSize(){
          return array.getSize();
      }
      @Override
      public boolean isEmpty(){
          return array.isEmpty();
      }
      @Override
      public void enqueue(E e){
          array.addLast(e);
      }
      @Override
      public E dequeue(){
          return array.removeFirst();
      }
      @Override
      public E getFront(){
          return array.getFirst();
      }

      @Override
      public String toString(){
          StringBuilder res = new StringBuilder();
          res.append("Queue:");
          res.append("front [");
          for(int i = 0, i < array.getSize(); i++){
              res.append(array.get(i));
              if (i != array.getSize() -1) {
                  res.append(", ");
              }
          }
          res.append("] tail");
          return res.toString();
      }

      public int getCapacity(){
          return array.getCapacity();
      }
  }

      3. 准备测试类

  // 准备测试类
  public static void main(String args[]){
      ArrayQueue<Integer> queue = new ArrayQueue<>();
      for (int i = 0; i < 10; i++) {
          queue.enqueue(i);
          System.out.println(queue);

          if(i % 3 == 2){
             queue.dequeue();
             System.out.println(queue);
          }
      }
  }

## 时间复杂度分析：(针对于上方自定义队列

    void enqueue(E)          O(1)      //均摊
    E dequeue()                O(n)      
    E front()                       O(1)    
    int getSize()                 O(1)    
    boolean isEmpty         O(1)
    [注意]:
        1. 由于对于队列的基础入队操作时间复杂度为O(1)，当涉及到resize方法即发生扩容时，因为并非每一次
            都要进行扩容操作，经过均摊复杂度分析依然为O(1)
        2. 由于在进行出队操作时，队首元素移除后，整个数组队列中其余元素都要依此向前移动一位，故此操作时
            间复杂度为O(n)

资料来源：慕课网《玩转数据结构》