数据结构 队列（JAVA语言描述）

最新推荐文章于 2024-07-24 12:42:40 发布
最新推荐文章于 2024-07-24 12:42:40 发布
阅读量202 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 java 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51510806/article/details/122498925
版权

数据结构 队列（JAVA语言描述）

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
队列是一种先进先出（First In First Out）的线性表。允许插入的一端称为队尾，允许删除的一端称为队头。
队头（Front）：允许删除的一端，又称队首。
队尾（Rear）：允许插入的一端。
空队列：不包含任何元素的空表。

  • 队列的常见方法
public interface Queue<E> extends Iterable<E> {
    public void offer(E element);//入队
    public E poll();//出队
    public E element();
    public boolean isEmpty();
    public void clear();
    public int size();
}
  • 队列方法的实现
public class ArrayQueue<E> implements Queue<E> {
    private ArrayList<E> list;
    public ArrayQueue(){
        list = new ArrayList<>();
    }

    @Override
    public void offer(E element) {
        list.add(list.size(),element);
    }

    @Override
    public E poll() {
        return list.remove(0);
    }

    @Override
    public E element() {
        return list.get(0);
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

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

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

    @Override
    public Iterator<E> iterator() {
        return list.iterator();
    }

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

    @Override
    public boolean equals(Object o) {
        if (null == o) return true;
        if (this==o){
            return true;
        }
        if (o instanceof  ArrayQueue){
            ArrayQueue other = (ArrayQueue) o;
            return list.equals(other.list);
        }
        return false;
    }

关于线性表的方法具体实现

  • 用队列去实现栈
class StackImplByQueue<E> implements Stack<E>{
    private ArrayQueue<E> queue1;
    private ArrayQueue<E> queue2;
    public StackImplByQueue(){
        queue1 = new ArrayQueue<>();
        queue2= new ArrayQueue<>();
    }

    @Override
    public int size() {
        if (queue1.isEmpty()&&queue2.isEmpty()){
            return 0;
        }else if (!queue1.isEmpty()){
            return queue1.size();
        }else {
            return queue2.size();
        }
    }

    @Override
    public boolean isEmpty() {
        return queue1.isEmpty() && queue2.isEmpty();
    }

    @Override
    public void push(E element) {
            if(queue1.isEmpty() && queue2.isEmpty()){
                queue1.offer(element);
            }else if (!queue1.isEmpty()){
                queue1.offer(element);
            }else {
                queue2.offer(element);
            }
   }

    @Override
    public E pop() {
           if (isEmpty()){
               return null;
           }
           E ret = null;
           if (!queue1.isEmpty()){
                while (queue1.size()!=1){
                    queue2.offer(queue1.poll());
                }
                ret = queue1.poll();
           }else {
               while (queue2.size()!=1){
                   queue1.offer(queue2.poll());
               }
               ret = queue2.poll();
           }
           return ret;
    }

    @Override
    public E peek() {
        if (isEmpty()){
            return null;
        }
        E ret = null;
        if (!queue1.isEmpty()){
            while (queue1.size()!=1){
                queue2.offer(queue1.poll());
            }
            ret = queue1.poll();
            queue2.offer(ret);
        }else {
            while (queue2.size()!=1){
                queue1.offer(queue2.poll());
            }
            ret = queue2.poll();
            queue1.offer(ret);
        }
        return ret;
    }

    @Override
    public void clear() {
            queue1.clear();
            queue2.clear();
    }

    @Override
    public Iterator<E> iterator() {
        if (isEmpty()){
            return queue1.iterator();
        }else if (!queue1.isEmpty()){
            return queue1.iterator();
        }else {
            return queue2.iterator();
        }
    }

    @Override
    public String toString() {
        if (isEmpty()){
            return "[]";
        }else if (!queue1.isEmpty()){
            return queue1.toString();
        }else {
            return queue2.toString();
        }
    }
  • 循环队列

将队列臆造成一个环状的空间，即把存储队列元素的表从按逻辑上视为一个环，称为循环队列。当队首指针 Q.front == MAXSIZE - 1,再前景一个位置就自动到0，这可以利用除法取余运算（%） 来实现。

队首指针进1：Q.front = （Q.front + 1) % MAXSIZE；
队尾指针进1：Q.rear = （Q.rear + 1）% MAXSIZE；
队列长度：（Q.front + MAXSIZE - Q.rear) % MAXSIZE；

//循环队列
public class ArrayLoopQueue<E> implements Queue<E> {
    private E[] data;
    //队首
    private int front;
    //队尾
    private  int rear;
    //元素个数
    private int size;
    //默认容量
    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("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 null;
    }

    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("null");
        }
        return data[front];
    }

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

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

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

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if (isEmpty()){
            sb.append(']');
            return sb.toString();
        }else {
            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(',');
                }
            }
        }
        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;
        }
    }
}
  • 双端队列

双端队列(Deque:double ended queue)就是一个两端都是结尾的队列。
队列的每一端都能够插入数据项和移除数据项。
相对于普通队列，双端队列的入队和出队操作在两端都可进行。

public class ArrayDeque<E> implements Dequeue<E>, Stack<E> {
    private E[] data;
    private int front;
    private int rear;
    private int size;
    private static int DEFAULT_CAPACITY=10;
    public ArrayDeque(){
        data = (E[]) new Object[DEFAULT_CAPACITY+1];
        front =0;
        rear =0;
        size =0;
    }
    @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("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("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("null");
        }
        return data[front];
    }

    @Override
    public E getLast() {
        if (isEmpty()){
            throw new IllegalArgumentException("null");
        }
        return data[(rear-1+ data.length)% data.length];
    }

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

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

    @Override
    public E element() {
        return getFirst();
    }

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

    @Override
    public void push(E element) {
        addLast(element);
    }

    @Override
    public E pop() {
        return removeLast();
    }

    @Override
    public E peek() {
        return getLast();
    }

    @Override
    public void clear() {
        data = (E[]) new Object[DEFAULT_CAPACITY];
        front =0;
        rear =0;
        size =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 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;
        }
    }
}
可乐33
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之链式队列（Java实现）
qq_46089556的博客
07-20 195
数据结构之链式队列（Java实现） LinkNode public class LinkNode { int data; LinkNode next; LinkNode (int data){ this.data=data; } } LinkQueue public class LinkQueue { LinkNode front; LinkNode rear; //初始化 LinkQueue(){ this.
数据结构 JAVA描述（二） 栈
此生尽兴
12-23 561
栈的抽象数据类型描述
数据结构学习——队列的java实现
qq_53662879的博客
01-27 703
数据结构学习——队列的java实现 队列：只能一端进另一端出的数据结构类型。 一、直接使用数据链的方式。 1.最开始实现 队列，发现仅仅形成一个数据链，在出队列时会导致第一个且唯一一个有名字的结点（此时是第一个元素）消失，后面结点成为空指针。代码如下： public class 队列1 { public static void main(String[] args) { Queue head=new Queue(10); head.next=new Queue(9);
java循环队列入队出队算法,实现循环队列的入队,出队等基本操作
weixin_32145807的博客
03-22 4424
循环队列的基本操作一、实验目的1. 理解并掌握队列的逻辑结构和顺序存储结构，了解循环队列的特点；2. 掌握循环队列中基本操作的相关算法；3. 编程实现相关算法；4. 学会利用循环队列解决实际问题。二、实验条件Visual C++。三、实验原理及相关知识1. 循环队列存储结构描述#define MAXSIZE 100 //最大队列长度typedef struct{QElemType *base; /...
【数据结构】队列及其Java代码实现
泡^泡
05-04 425
队列及其Java代码实现
【数据结构】队列（顺序队列、链队列）的JAVA代码实现
Yngz_Miao的博客
03-28 9546
队列（queue）是一种特殊的线性表，只允许在表的一端进行插入操作而在另一端进行删除的线性表。进行插入操作的端称为队尾，进行删除操作的一端称为队头。队列中没有数据元素时称为空队列。 队列的操作是按照先进先出（first in first out）或后进后出（last in last out）的原则进行的。因此，队列又被称为FIFO表。它的实现方式主要有顺序队列、链队列两种。   队列的抽象数...
数据结构 JAVA描述（一） 线性表
此生尽兴
12-22 8045
线性表的抽象数据类型描述
数据结构与算法Java语言描述（源代码）
06-01
本资源提供了"数据结构与算法Java语言描述（源代码）"，帮助学习者通过实际代码深入理解这些概念。 1. **数组**：数组是最基本的数据结构，它允许存储固定数量的相同类型元素。在Java中，数组可以是一维、二维或...
数据结构与算法，Java语言描述
11-30
数据结构与算法，Java语言描述。有对数据结构与算法的基本概念、线性表、栈与队列、串、数组与矩阵、树与二叉树、图的一些逻辑结构的介绍，以及如何用Java语言实现其各种各样的存储结构的代码，同时也会有一些相关的...
数据结构（Java语言描述）.zip
06-26
本资源"数据结构（Java语言描述）.zip"涵盖了这门课程的多个方面，包括教学材料、实验实践、源代码示例以及习题解答，对于学习者来说是一份全面的学习资料。 首先，教案PPT部分将深入讲解数据结构的基本概念，如...
数据结构教程（java语言描述）-源码和课件-李春葆
02-09
本教程由著名计算机教育家李春葆教授提供，主要使用Java语言来描述各种数据结构，结合源码和课件，为学习者提供了一套完整的自学资源。 首先，Java是一种面向对象的编程语言，它具有丰富的类库和强大的功能，适合...
常见数据结构及算法（Java语言描述）.zip
06-16
在“常见数据结构及算法（Java语言描述）.zip”这个压缩包中，我们可以期待找到一系列关于Java实现的数据结构和算法的学习资源。下面，我们将深入探讨这些关键主题。 首先，数据结构是组织、存储和管理数据的方式，...
插入和选择排序
c23856的博客
07-20 538
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
【数据结构】搜索二叉树
最新发布
dab112的博客
07-24 625
介绍了二叉搜索树的实现与模拟
数据结构（二叉树-1）
2401_83968713的博客
07-20 1084
树是⼀种⾮线性的数据结构，它是由nn>=0） 个有限结点组成⼀个具有层次关系的集合。把它叫做 树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的。有⼀个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M>0)个互不相交的集合T1T2……Tm，其中每⼀个集合⼜是⼀棵结构与树类似的⼦树。每棵⼦树的根结点有且只有⼀个前驱，可以有0个或多个后继。因此，树是递归定义的。树形结构中，⼦树之间不能有交集，否则就不是树形结构。
【手撕数据结构】把玩顺序表
apple_61439616的博客
07-19 963
顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组线性结构又是什么意思，这就不得不提到线性表了线性表（linear list）是n个具有相同特性的数据元素的有限序列线性表是⼀种在实际中⼴泛使 ⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串注意的是，他在逻辑结构上一定是连续的，但在物理结构上不一定是连续的.线性表在物理上存储时，通常以数组和链式结构的形式存储那么我们知道，数组在内存中存储也是连续的，并且也是类型一致，那么他与顺序表的区别是什么呢.
《数据结构：栈和队列》
2401_83305953的博客
07-19 676
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行插入和删除操作的一端称为栈顶，另一端称为栈底。概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)队列也可以由数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。：栈的插入操作叫做进栈/压栈/入栈/，入数据在栈顶。
数据结构——二叉树定义
鲸落博客
07-23 377
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
数据结构：栈
sparrowfart的博客
07-19 1182
满足栈的特性，只有先进后出的特性，不能遍历，也就不能遍历打印，也不能随机访问。
Java语言描述的数据结构基础与算法分析
"数据结构Java语言描述-数据结构绪论（Java）" 本文将深入探讨数据结构的基础知识，特别是从Java语言的角度出发。数据结构是一门研究如何在计算机中高效地组织和管理数据的学科。它涉及到数据的逻辑结构、物理存储...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值