java-数据结构-队列

最新推荐文章于 2024-06-05 13:42:01 发布
最新推荐文章于 2024-06-05 13:42:01 发布
阅读量198 收藏
点赞数
分类专栏： java 文章标签： java 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leaarning/article/details/122478160
版权

1.定义

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

我们把允许删除的一端称为队首（front），插入的一端称为队尾，不含任何数据元素的队列称为空队列。队列的插入操作，叫作入队，队列的删除操作，叫作出队。

2.Queue接口的定义

  public void offer(E element);  //入队
    public E poll();             //出队
    public E peek();            //队首元素
    public boolean isEmpty();  //判断是否为空
    public void clear();      //清除
    public  int size();      //大小

用栈实现队列

 public static void main(String[] args) {
        QueueImplByStack<Integer> queue = new QueueImplByStack<Integer>();
        for (int i = 0; i <= 5; i++) {
            queue.offer(i);
        }
        System.out.println(queue);
        System.out.println(queue.poll());
        System.out.println(queue);
    }
}

class QueueImplByStack<E> implements Queue<E> {
    private ArrayStack<E> stackA;
    private ArrayStack<E> stackB;

    public QueueImplByStack() {
        stackA = new ArrayStack<E>();
        stackB = new ArrayStack<E>();
    }

    @Override
    public void offer(E element) {
        stackA.push(element);
    }

    @Override
    public E poll() {
        if (isEmpty()) {
            throw new IllegalArgumentException("Queue is null");
        }
        while (stackA.size() != 1) {
            stackB.push(stackA.pop());
        }
        E ret = stackA.pop();
        while (!stackB.isEmpty()) {
            stackA.push(stackB.pop());
        }
        return ret;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            throw new IllegalArgumentException("Queue is null");
        }
        while (stackA.size() != 1) {
            stackB.push(stackA.pop());
        }
        E ret = stackA.pop();
        while (!stackB.isEmpty()) {
            stackA.push(stackB.pop());
        }
        return ret;
    }

    @Override
    public boolean isEmpty() {

        return stackA.isEmpty();
    }

    @Override
    public void clear() {
        stackA.clear();
    }

    @Override
    public int size() {
        return stackA.size();
    }

    @Override
    public String toString() {
        return stackA.toString();
    }

    @Override
    public Iterator iterator() {
        return stackA.iterator();
    }

循环队列

该循环队列的实现思想也是动态数组，但是由于操作元素的特殊性，并不能直接由ArrayList或ArrayQueue实现，所以从头开始定义ArrayLoopQueue。

代码实现

//循环队列
public class ArrayLoopQueue<E> implements Queue<E> {
    private E[] data;   //存储数据的容器
    private int front;  //队首指针(实际上就是数组中的索引角标)
    private int rear;   //队尾指针
    private int size;   //元素的个数 (f < r  r-f ; r < f  r+L-f)
    private static int DEFAULT_CAPACITY = 10;   //默认容量
    public ArrayLoopQueue() {
        data = (E[]) new Object[DEFAULT_CAPACITY + 1];
        front = 0;
        rear = 0;
        size = 0;
    }
    @Override
    public void offer(E element) {
        //满了没
        if ((rear + 1) % data.length == front) {
            resize(data.length * 2 - 1);
        }
        data[rear] = element;
        rear = (rear + 1) % data.length;
        size++;
    }
    @Override
    public E poll() {
        //空不空
        if (isEmpty()) {
            throw new IllegalArgumentException("queue is null");
        }
        E ret = data[front];
        front = (front + 1) % data.length;
        size--;
        if (size <= (data.length - 1) / 4 && data.length - 1 > DEFAULT_CAPACITY) {
            resize(data.length / 2 + 1);
        }
        return ret;
    }

    private void resize(int newLen) {
        E[] newData = (E[]) new Object[newLen];
        int index = 0;
        for (int i = front; i != rear; i = (i + 1) % data.length) {
            newData[index++] = data[i];
        }
        data = newData;
        front = 0;
        rear = index;
    }

    @Override
    public E element() {
        if (isEmpty()) {
            throw new IllegalArgumentException("queue is null");
        }
        return data[front];
    }

    @Override
    public boolean isEmpty() {
        return front == rear;
    }

    @Override
    public void clear() {
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
        front = 0;
        rear = 0;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if (isEmpty()) {
            sb.append(']');
            return sb.toString();
        }
        for (int i = front; i != rear; i = (i + 1) % data.length) {
            sb.append(data[i]);
            if ((i + 1) % data.length == rear) {
                sb.append(']');
            } else {
                sb.append(',');
                sb.append(' ');
            }
        }
        return sb.toString();
    }

    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        if (this == o) {
            return true;
        }
        if (o instanceof ArrayLoopQueue) {
            ArrayLoopQueue<E> other = (ArrayLoopQueue<E>) o;
            if (size != other.size) {
                return false;
            }
            int i = front;
            int j = other.front;
            while (i != rear) {
                if (!data[i].equals(other.data[j])) {
                    return false;
                }
                i = (i + 1) % data.length;
                j = (j + 1) % other.data.length;
            }
            return true;
        }
        return false;
    }

    @Override
    public Iterator<E> iterator() {
        return new ArrayLoopQueueIterator();
    }

    class ArrayLoopQueueIterator implements Iterator<E> {
        private int cur = front;

        @Override
        public boolean hasNext() {
            return cur != rear;
        }

        @Override
        public E next() {
            E ret = data[cur];
            cur = (cur + 1) % data.length;
            return ret;
        }
    }

缩容扩容问题（双端和循环解决是一样的）：

 

双端队列

双端队列（double ended queue ，deque）是限定插入和删除操作在表的两端进行的线性表，是一种具有队列和栈的性质的数据结构。

解释front==rear：

双端队列接口：

 //在队首添加
    public void addFirst(E element);
    //在队尾添加
    public void addLast(E element);
    //在队首删除
    public E removeFirst();
    //在队尾删除
    public E removeLast();
    //获得队首元素
    public E getFirst();
    //或得队尾元素
    public E getLast();

双端队列实现：

 private E[] data;
    //队首指针
    private int front;
    //队尾指针
    private int rear;
    //有效元素个数
    private int size;
    //最大容量
    private static int DEFAULT_CAPACITY = 10;

    public ArrayDeQueue() {
        data = (E[]) new Object[DEFAULT_CAPACITY+1];
        front = 0;
        rear = 0;
        size = 0;
    }

    //入队
    @Override
    public void offer(E element) {
        addLast(element);
    }

    //出队
    @Override
    public E poll() {
        return removeFirst();
    }

    //查看队尾元素
    @Override
    public E peek() {
        return getLast();
    }

    //判断是否为空
    @Override
    public boolean isEmpty() {
        return size == 0 && front == rear;
    }

    //清空队列
    @Override
    public void clear() {
        E[] data = (E[]) new Object[DEFAULT_CAPACITY];
        front = 0;
        rear = 0;
        size = 0;
    }

    @Override
    public int size() {
        return size;
    }

    //在队首添加元素
    @Override
    public void addFirst(E element) {
        //判断队列是否为满，若满，则要扩容
        if ((rear + 1) % data.length == front) {
            resize(data.length * 2 - 1);
        }
        front = (front - 1 + data.length) % data.length;
        data[front] = element;
        size++;
    }
//扩容或缩容
    private void resize(int newLen) {
        E[] newData = (E[]) new Object[newLen];
        int index = 0;
        for (int i = front; i != rear; i = (i + 1) % data.length) {
            newData[index++] = data[i];
        }
        data = newData;
        front = 0;
        rear = index;
    }
//在队尾添加元素
    @Override
    public void addLast(E element) {
        //判断是否需要扩容
        if ((rear + 1) % data.length == front) {
            resize(data.length * 2 - 1);
        }
        data[rear] = element;
        rear = (rear + 1) % data.length;
        size++;
    }

    //在队首删除元素，并返回删除的元素
    @Override
    public E removeFirst() {
        if (isEmpty()) {
            throw new IllegalArgumentException("queue is null");
        }
        E ret = data[front];
        front = (front + 1) % data.length;
        size--;
        //判断是否需要缩容
        if (size <= (data.length - 1) / 4 && data.length - 1 > DEFAULT_CAPACITY) {
            resize(data.length / 2 + 1);
        }
        return ret;
    }

    // 在队尾删除元素
    @Override
    public E removeLast() {
        if (isEmpty()) {
            throw new IllegalArgumentException("queue is null");
        }
        rear = (rear - 1 + data.length) % data.length;
        E ret = data[rear];
        size--;
        //判断是否需要缩容
        if (size <= (data.length - 1) / 4 && data.length - 1 > DEFAULT_CAPACITY) {
            resize(data.length / 2 + 1);
        }
        return ret;
    }

    //获得队首元素
    @Override
    public E getFirst() {
        if (isEmpty()) {
            throw new IllegalArgumentException("queue is null");
        }
        return data[front];
    }

    //获得队尾元素
    @Override
    public E getLast() {
        if (isEmpty()) {
            throw new IllegalArgumentException("queue is null ");
        }
        return data[rear-1];
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if (isEmpty()) {
            sb.append(']');
            return sb.toString();
        }
        for (int i = front; i != rear; i = (i + 1) % data.length) {
            sb.append(data[i]);
            if ((i + 1) % data.length == rear) {
                sb.append(']');
            } else {
                sb.append(',');
                sb.append(' ');
            }
        }
        return sb.toString();
    }

    @Override
    public Iterator<E> iterator() {
        return new ArrayDequeIterator();
    }

    class ArrayDequeIterator implements Iterator<E> {
        private int cur = front;

        @Override
        public boolean hasNext() {
            return cur != rear;
        }

        @Override
        public E next() {
            E ret = data[cur];
            cur = (cur + 1) % data.length;
            return ret;
        }
    }

秃头泥猴
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数据结构之队列
weixin_44270248的博客
05-15 1130
基本概念 队列是一种特殊的线性表，其插入操作只能在表的尾部进行，叫入队，这一端被称为队尾，删除操作只能在表的头部进行，叫出队，这一端被称为队首。没有数据元素的队列称为空队列。队列具有FIFO（先进先出）的特点，队列的底层数据结构可以用数组来实现。 队列的抽象数据类型 package ch03; public interface IQueue { public void clear(); pu...
Java数据结构—队列
Green_756的博客
08-30 665
数据结构、java、队列
Java 数据结构之队列(Queue)详解
最新发布
chuyouyinghe的专栏
06-05 1165
通过enqueue()方法将元素入队，dequeue()方法将元素出队，peek()方法返回队列头部元素，size()方法返回队列当前元素个数，isEmpty()方法和isFull()方法检查队列是否为空或已满。但需要注意的是，由于数组的容量是固定的，当队列已满时，无法再添加新的元素，除非进行元素的出队操作。Queue接口是Java集合框架中定义的一个接口，它代表了一个先进先出（FIFO）的队列。它是Queue接口的扩展，可以方便地实现队列、栈和双向队列的功能，并提供了丰富的方法来操作和访问队列中的元素。
java数据结构 队列_java数据结构之队列
weixin_29014237的博客
02-16 159
队列概述队列是一种特殊的线性表，它只允许在表的前端(front)进行删除操作，而在表的后端(rear)进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。–队尾(rear)——允许插入的一端–队头(front)——允许删除的一端队列特点：先进先出(FIFO)线性表的操作主要包括：(1)清空队列(2)判断是否为空(3)元素的个数(4)入队列(5)出队列(6...
java数据结构队列
qq_57636636的博客
04-05 1148
java 数据结构 队列
java数据结构之队列
sxapple666的博客
03-17 397
//如果成功实现链表之后，那么对队列和栈的实现都很简单了 //可以自己在从底层实现一个栈或队列，也可以以原有的线性表作为底层数据结构 //来进行实现 public class LinkedListQueue&lt;E&gt; { private MyLinkedList&lt;E&gt; list ; public LinkedListQueue() { ...
Java-Java数据结构二十讲
10-25
本文将深入探讨Java数据结构的二十个核心主题，包括数组、简单排序算法、栈与队列、链表、递归、树以及图。这些概念不仅在日常编程中常见，也是面试和技术评估的重要内容。 首先，我们从基础的数组开始。数组是存储...
java-数据结构代码实现
11-15
本资料包“java-数据结构代码实现”提供了使用Java语言实现数据结构的实例，旨在帮助开发者加深对数据结构的理解并提升编程技能。 1. **链表**：链表是一种动态数据结构，其元素在内存中不是顺序排列的。Java中的...
数据结构之队列的java实现
12-22
队列也是一种数据结构，类似于栈，只是与栈相反，在队列中先插入的数据也先被移除，即先进先出(FIFO，First In First Out)。队列可以理解成排队，比如，食堂窗口排的队，越在前面的，越早得到服务而先离开。在银行...
JAVA---算法与数据结构
04-08
在"JAVA---算法与数据结构"这个主题中，我们将深入探讨Java中常用的数据结构，如数组、链表、栈、队列、集合、映射、树（二叉树、红黑树）和图等。每种数据结构都有其独特的优势和适用场景，例如，数组适合随机访问...
数据结构-队列(Queue)介绍和Java示例代码
07-01
队列是一种重要的线性数据结构，它遵循先进先出（FIFO）的规则，即最先插入的元素将最先被移除。在计算机科学中，队列广泛应用于各种算法和程序设计中，尤其在处理需要顺序处理任务的场景下。在Java中，队列可以借助...
Java数据结构——队列
rain67的博客
10-26 1909
文章目录前言一、队列1.概念2.Java当中的队列3.实例化对象4.双端队列 (Deque)5.队列的常用方法二、Java实现简单队列三、循环队列设计循环队列循环队列的具体实现 前言   最近博主在学习JavaWeb的过程中，讲到了具体线程的知识，在写生产与消费者模型的具体代码时，发现涉及到了循环队列的知识，于是打算再次复习一下循环队列的具体编写 我们先复习一下队列的相关知识 一、队列 1.概念   只允许在一端进行插入数据操作，在另一端进行删除操作的特殊线性表，队列具有先进先出的特点 进行
java 数据结构 队列
qq_46859110的博客
10-11 95
队列是一种基于先进先出(FIFO)的数据结构，是一种只能在一端进行插入,在另一端进行删除操作的特殊线性表，它 按照先进先出的原则存储数据，先进入的数据，在读取数据时先读被读出来。 public class Queue<T> implements Iterable<T> { //记录首结点 private Node head; //记录最后一个结点 private Node last; //记录队列中元素的个数 private int
数据结构 -- 队列(Java)
weixin_45000199的博客
07-12 316
队列 * 可用 数组 和 链表 实现 * 队列本身是有序列表，先入先出 * 队列的输出、输入：变量front与rear分别记录队列前后端下标。 * front随着数据的输出而改变，rear随着数据的输入而改变 一、[x]数组模拟队列 1. 思路分析 * 将尾指针往后移: rear+1,当front==rear 【空】· * 若尾指针rear小于队列的最大下标maxSize-1,则将数据存入rear所指的数组元素中,否则无法存入数据。rear == maxSize-1[队列满] 2.判断队列空与满的条件
Java 数据结构之队列
weixin_51215207的博客
08-19 738
JAVA 队列 自定义循环队列
【Java---数据结构】队列
.很冷的博客
04-10 1640
一、概念 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。 队列具有先进先出FIFO(FirstIn First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear） 出队列：进行删除操作的一端称为队头 特点：先进先出 ...
数据结构(Java)---队列
I_am_fine_的博客
02-27 1257
简述队列的使用以及一些概念
Java版数据结构与算法电子书-PDF格式
本书涵盖了诸如数组、链表、栈、队列、散列表、树（包括二叉树和平衡树如AVL树和红黑树）、图等经典数据结构。对于每个数据结构，作者都会详细解释其工作原理、优缺点，并提供实际的Java代码示例来演示它们的实现。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值