数据结构之队列

队列

有序列表

先进先出(FIFO)

单向队列

基于数组实现
  • 数组大小
  • 数组
  • 队头指针(front):指向队首元素的前一个位置
  • 队尾指针(rear):指向队尾元素位置
    判空条件:front == rear (单向队列有可能此情况也是满, 因为前面元素没有办法重复利用)
    判满条件:rear == size - 1
代码实现
java 复制代码
package org.example.data.structure.queue;

/**
 * 基于数组实现队列
 *
 * @author xzy
 * @since 2024/8/25 14:53
 */
public class ArrayQueue {

    /**
     * 队列头: 头部元素的前一个索引位置
     */
    private Integer front;

    /**
     * 队列尾: 与尾部元素的索引位置在同一个
     */
    private Integer rear;

    /**
     * 数组容量
     */
    private Integer size;

    /**
     * 数组内容
     */
    private Integer[] content;

    /**
     * 构造器创建数组
     */
    public ArrayQueue(Integer size) {
        this.size = size;
        this.content = new Integer[size];
        front = -1;
        rear = -1;
    }

    /**
     * 队列是否为空
     */
    public Boolean isEmpty() {
        return front == rear;
    }

    /**
     * 队列是否已满
     */
    public Boolean isFull() {
        return rear == (size - 1);
    }

    /**
     * 添加元素-入队
     */
    public Boolean add(Integer data) {
        if (isFull()) {
            System.out.println("队列已满, 无法添加元素");
            return false;
        }
        // 队尾索引+1
        rear++;
        content[rear] = data;
        return true;
    }

    /**
     * 移除元素-出队
     */
    public Integer getData() {
        if (isEmpty()) {
            System.out.println("队列为空, 无数据需要出队");
            return null;
        }
        front++;
        Integer result = content[front];
        // 原有位置赋空, 可以不赋值, 因为单向队列也不会再取值
        content[front] = null;
        return result;
    }

    /**
     * 展示头部元素
     */
    public Integer showHead() {
        if (isEmpty()) {
            return null;
        }
        return content[front + 1];
    }

    /**
     * 展示尾部元素
     */
    public Integer showRear() {
        if (isEmpty()) {
            return null;
        }
        return content[rear];
    }


    /**
     * 展示队列中所有的元素
     */
    public String toString() {
        if (isEmpty()) {
            return "";
        }
        StringBuilder str = new StringBuilder();
        for (int i = front + 1; i <= rear; i++) {
            str.append(content[i]).append("\t");
        }
        return str.toString();
    }

}

循环队列


作用

为了弥补单向队列中只能一次利用的场景而出现。其中,实现循环队列有多种方式:

  • 类型中增设表示元素个数的数据成员
  • 牺牲一个单元来区分队空和队满,入队时少用一个队列单元

本次以第二种方式进行实现:

  • 数组大小
  • 数组
  • 队首指针(front):指向队首元素,初始化为0
  • 队尾指针(rear):指向队尾元素的后一个元素,初始化为0

判空条件:front == rear

判满条件:(rear + 1) % size == front

有效数据个数:(rear - front + size) % size

代码实现
java 复制代码
package org.example.data.structure.queue;

/**
 * 循环队列: 基于数组实现
 *
 * @author xzy
 * @since 2024/8/25 17:12
 */
public class CircleArrayQueue {

    /**
     * 队首位置, 处于队列中第一个元素
     */
    private int front;

    /**
     * 队尾位置, 处于队列中最后元素的后一位
     */
    private int rear;

    /**
     * 循环数组
     */
    private Integer[] content;

    /**
     * 循环数组大小, 该size会是content的大小, 其中size的大小会是content中真实元素个数 + 1, 即会存在一个空元素
     */
    private int size;

    public CircleArrayQueue(int size) {
        // 初始化循环队列, 队首和队尾元素位置均从0位置开始
        front = 0;
        rear = 0;
        this.size = size;
        content = new Integer[size];
    }

    /**
     * 判断队列是否为空
     */
    public boolean isEmpty() {
        return front == rear;
    }

    /**
     * 判断队列是否已满
     */
    public boolean isFull() {
        return (rear + 1) % size == front;
    }

    /**
     * 入队元素
     */
    public boolean add(int data) {
        if (isFull()) {
            System.out.println("队列已满, 无法添加元素");
            return false;
        }
        content[rear] = data;
        // rear后移
        rear = (rear + 1) % size;
        return true;
    }

    /**
     * 出队
     */
    public Integer getData() {
        if (isEmpty()) {
            System.out.println("队列为空, 返回空数据");
            return null;
        }
        int result = content[front];
        content[front] = null;
        front = (front + 1) % size;
        return result;
    }

    /**
     * 队列中的有效个数
     */
    public int count() {
        if (isEmpty()) {
            return 0;
        }
        if (isFull()) {
            return size - 1;
        }
        // 可以分两种情况, 其实可以化简为 (rear - front + size) % size
        if (rear > front) {
            return rear - front;
        }
        return rear - front + size;
    }

    /**
     * 显示头元素
     */
    public Integer showHead() {
        if (isEmpty()) {
            System.out.println("队列为空, 返回Null");
            return null;
        }
        return content[front];
    }

    /**
     * 显示尾元素
     */
    public Integer showRear() {
        if (isEmpty()) {
            System.out.println("队列为空, 返回Null");
            return null;
        }
        return content[(rear - 1 + size) % size];
    }

    /**
     * 打印
     */
    public String toString() {
        if (isEmpty()) {
            return "";
        }
        StringBuilder str = new StringBuilder();
        if (rear < front) {
            for (int i = front; i < size; i++) {
                str.append(content[i]).append("\t");
            }
            for (int i = 0; i < rear; i++) {
                str.append(content[i]).append("\t");
            }
        } else {
            for (int i = front; i < rear; i++) {
                str.append(content[i]).append("\t");
            }
        }
        return str.toString();
    }

}

源码与测试案例

gitee地址

相关推荐
李元豪3 小时前
【智鹿空间】c++实现了一个简单的链表数据结构 MyList,其中包含基本的 Get 和 Modify 操作,
数据结构·c++·链表
我不是星海3 小时前
1.集合体系补充(1)
java·数据结构
Darkwanderor7 小时前
用数组实现小根堆
c语言·数据结构·二叉树·
鬣主任7 小时前
LinkedList和单双链表。
数据结构·链表
titan TV man8 小时前
上海市计算机学会竞赛平台2024年11月月赛丙组线段数
数据结构·算法
敲上瘾8 小时前
C++11新特性(二)
java·c语言·开发语言·数据结构·c++·python·aigc
知星小度S9 小时前
数据结构——排序
c语言·数据结构·算法
labuladuo5209 小时前
洛谷 P1725 琪露诺(线段树优化dp)
数据结构·算法·动态规划
曙曙学编程10 小时前
初级数据结构——顺序表
数据结构
Bucai_不才11 小时前
【数据结构】线性表——链表
数据结构·链表