玩转数据结构之使用数组实现队列

前言

队列最大的特点就是先进先出（FIFO），接下来我们使用前面自定义的动态数组来实现队列的基本功能

相关代码

• 首先我们定义一个接口，主要涵盖队列的相对应的方法

package com.sjgd.stack;

/**
 * 自定义队列所实现的接口
 * on 2022/7/19
 */
public interface Queue<E> {

    /**
     * 获取队列中元素的个数
     *
     * @return
     */
    int getSize();

    /**
     * 判断当前队列是否为空
     *
     * @return
     */
    boolean isEmpty();

    /**
     * 元素入队
     *
     * @param e
     */
    void enqueue(E e);

    /**
     * 元素出队
     *
     * @return
     */
    E dequeue();

    /**
     * 获取对首元素
     *
     * @return
     */
    E getFront();

}

• 具体队列代码实现

package com.sjgd.stack;

/**
* 使用动态数组实现自定义队列
* on 2022/7/19
*/
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.get(0);
   }

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

• 测试代码块

public class QueueTest {

   public static void main(String[] args) {
       ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
       for (int i = 0; i < 10; i++) {
           arrayQueue.enqueue(i);

       }
       arrayQueue.dequeue();
       System.out.println(arrayQueue);


   }
}

队列时间复杂度分析

• 入队操作O(1)，入队操作只需要在队列尾部插入数据即可；
• 出队操作O(n)，出队操作因为队首移除元素后，后面元素均需要前移，因此时间复杂度为O(n)