JAVA实现队列，双端队列，循环队列，双端循环队列

最新推荐文章于 2024-09-14 11:04:18 发布

————大风起兮云飞扬

最新推荐文章于 2024-09-14 11:04:18 发布

阅读量217

点赞数

分类专栏：数据结构文章标签：队列数据结构

本文链接：https://blog.csdn.net/qq_41601512/article/details/115595549

版权

数据结构专栏收录该内容

5 篇文章 0 订阅

订阅专栏

队列:

package cn.queue;

import java.util.LinkedList;

import java.util.List;

/** Queue 队列
 *  先进先出，后进后出
 *  只能在头尾连段进行操作
 * @author admin
 */
public class Queue<E> {
    /**
     * 使用双向链表存储
     */
    private List<E> list;

    public Queue() {
        this.list =new LinkedList<E>();
    }

    int size(){
        return list.size();
    }

    /**
     * 判空
     * @return
     */
    boolean isEmpty(){
        return size()==0;
    }

    /**
     * 清除元素
     */
    void clear(){

    }

    /**
     * 入队
     * @param element
     */
    void enQueue(E element){
        list.add(element);
    }

    /**
     * 出队
     * @return
     */
    E deQueue(){
        return list.remove(0);
    }

    /**
     * 获取队头元素
     * @return
     */
    E front(){
        return list.get(0);
    }


    public static void main(String[] args) {
        Queue<Integer> queue=new Queue<>();
        queue.enQueue(10);
        queue.enQueue(20);
        queue.enQueue(30);
        queue.enQueue(40);

        while (!queue.isEmpty()){
            System.out.println(queue.deQueue());
        }

    }
}

双端队列

package cn.queue;

import java.util.LinkedList;
import java.util.List;

/**
 * 双端队列
 * 能在头尾两端进行添加删除操作
 * double ended queue
 * @author admin
 */
public class Deque<E> {
    /**
     * 使用双向链表
     */
    private List<E> list;

    public Deque() {
        this.list = new LinkedList<E>();
    }

    /**
     * 返回元素数量
     * @return
     */
    int size(){
        return list.size();
    }

    /**
     * 判空
     * @return
     */
    boolean isEmpty(){
        return this.size()==0;
    }

    void clear(){

    }

    /**
     * 从队尾插入
     * @param element
     */
    void enQueueRear(E element){
        list.add(element);
    }

    /**
     * 从队头插入
     * @param element
     */
    void enQueueFront(E element){
        list.add(0,element);
    }

    /**
     * 从队尾出队
     * @return
     */
    E deQueueRear(){
        return list.remove(list.size()-1);
    }

    /**
     * 从队头出队
     * @return
     */
    E deQueueFront(){
        return list.remove(0);
    }

    /**
     * 获取队头
     * @return
     */
    E front(){
        return list.get(0);
    }

    /**
     * 获取队尾
     * @return
     */
    E rear(){
        return list.get(list.size()-1);
    }

    public static void main(String[] args) {
        Deque<Integer> deque=new Deque<>();
        deque.enQueueFront(10);
        deque.enQueueFront(20);
        deque.enQueueRear(30);
        deque.enQueueRear(40);

        while (!deque.isEmpty()){
            System.out.println(deque.deQueueRear());
        }
    }
}

循环队列

package cn.queue;

/**
 * 循环队列
 * 队列底层使用动态数组实现
 *
 * @author admin
 */
public class ClicleQueue<E> {
    private int size;
    private E[] elements;
    /**
     * 队头索引
     */
    private int front;
    private static final int DEFAULE_CAPACITY = 10;

    ClicleQueue() {
        this.elements = (E[]) new Object[DEFAULE_CAPACITY];
    }

    /**
     * 判空
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 获取元素数量
     * @return
     */
    public int size() {
        return this.size;
    }

    /**
     * 获取队头
     * @return
     */
    public E front() {
        return this.elements[this.front];
    }

    /**
     * 入队
     * @param element
     */
    public void enQueue(E element) {
        eusureCapacity(this.size + 1);
        this.elements[index(this.size)] = element;
        this.size++;
    }

    /**
     * 获取映射地址
     * @param index
     * @return
     */
    public int index(int index) {
        return (this.front + index) % this.elements.length;
    }

    /**
     * 出队
     * @return
     */
    public E deQueue() {
        E old = this.elements[this.front];
        this.elements[this.front] = null;
        this.front = index(1);
        return old;
    }

    /**
     * 扩容
     * @param capacity
     */
    private void eusureCapacity(int capacity) {
        int oldCapacity = elements.length;
        if (capacity >= oldCapacity) {
            return;
        }
        int newCapacity=oldCapacity+(oldCapacity>>1);
        E[] newElementData= (E[]) new Object[newCapacity];
        for(int i=0;i<size;i++){
            newElementData[i]=elements[index(i)];
        }
        elements=newElementData;
        this.front=0;
    }


}

双端循环队列

package cn.queue;

/**
 * 双端循环队列
 * @author admin
 */
public class ClicleDeque<E> {
    private int size;
    private E[] elements;
    private int front;
    private static final int DEFAULE_CAPACITY=10;


    public ClicleDeque() {
        this.elements= (E[]) new Object[DEFAULE_CAPACITY];
    }

    /**
     * 获取元素数量
     * @return
     */
    public int size() {
        return this.size;
    }

    /**
     * 判空
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 获取队头
     * @return
     */
    public E front() {
        return this.elements[this.front];
    }

    /**
     * 获取队尾
     * @return
     */
    public E rear(){
        return this.elements[index(size-1)];
    }

    /**
     * 从队头入队
     * @param element
     */
    public void enQueueFront(E element) {
        ensureCapacity(size + 1);
        front = index(-1);
        elements[front] = element;
        size++;
    }

    /**
     * 从队尾入队
     * @param element
     */
    public void enQueueRear(E element){
        ensureCapacity(size + 1);
        elements[index(size)] = element;
        size++;
    }

    /**
     * 从头部出队
     * @return
     */
    public E deQueueFront() {
        E frontElement = elements[front];
        elements[front] = null;
        front = index(1);
        size--;
        return frontElement;
    }

    /**
     * 从尾部出队
     * @return 
     */
    public E deQueueRear() {
        int rearIndex = index(size - 1);
        E rear = elements[rearIndex];
        elements[rearIndex] = null;
        size--;
        return rear;
    }
    /**
     * 获取映射地址
     * @param index
     * @return
     */
    public int index(int index) {
        return (this.front + index) % this.elements.length;
    }

    /**
     * 出队
     * @return
     */
    public E deQueue() {
        E old = this.elements[this.front];
        this.elements[this.front] = null;
        this.front = index(1);
        return old;
    }

    /**
     * 扩容
     * @param capacity
     */
    private void ensureCapacity(int capacity) {
        int oldCapacity = elements.length;
        if (capacity >= oldCapacity) {
            return;
        }
        int newCapacity=oldCapacity+(oldCapacity>>1);
        E[] newElementData= (E[]) new Object[newCapacity];
        for(int i=0;i<size;i++){
            newElementData[i]=elements[index(i)];
        }
        elements=newElementData;
        this.front=0;
    }
}