java数据结构系列，第一篇：队列

已于 2023-08-19 18:02:06 修改
阅读量117 收藏
点赞数 1
文章标签： 数据结构 java
于 2023-08-19 17:51:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63117721/article/details/132380366
版权

队列（Queue）是一种常见的数据结构，用于存储和管理元素，其中元素按照先进先出（First-In-First-Out，FIFO）的原则进行操作。简单来说，队列就像是排队等候服务的人群，最先到达的人将首先接受服务，而后到达的人则需要等待前面的人完成服务后才能接受服务。

队列的主要特性包括：

  1. 入队（Enqueue）：将一个元素添加到队列的末尾。
  2. 出队（Dequeue）：从队列的头部移除并返回第一个元素。
  3. 头部（Front）：队列的第一个元素。
  4. 尾部（Rear/Back）：队列的最后一个元素。
  5. 队列大小（Size）：队列中元素的数量。

队列可以用于许多场景，例如任务调度、广度优先搜索算法（BFS）、多线程编程、打印任务管理等。在编程中，队列常常通过数组或链表来实现。数组实现的队列称为顺序队列，链表实现的队列称为链式队列。

由于队列可以有多种实现方法，所以面向接口，便于规范。

先创建一个 Queue 接口：


public interface Queue<E>
{
    /**
     * 向尾部插入值
     * @param value  待插入的值
     * @return  插入成功返回true，否则返回false
     */
    boolean offer(E value);

    /**
     * 从头部删除值
     * @return  如果队列为空，返回null，否则返回队头的值
     */
    E poll();

    /**
     * 获取队头的值
     * @return  如果队列为空，返回null，否则返回队头的值
     */
    E peek();

    /**
     * 检查队列是否为空
     * @return  如果队列为空，返回true，否则返回false
     */
    boolean isEmpty();

    /**
     * 判断队列是否已满
     * @return 满返回 true ;否则 false
     */
    boolean isFall();
}

 我们先用数组来实现，其实光数组实现就有很多种实现方式，我这里挑了一个比较好方式：

public class ArrayQueue3<E> implements Queue<E>,Iterable<E>
{
    private final E[] array;
    private int head;
    private int tail;

    /**
     * 有参构造创建队列
     * @param capacity  队列容量
     */
    public ArrayQueue3(int capacity)
    {
        array = (E[])new Object[capacity];
        head = 0;
        tail = 0;
    }
    
    /**
     * 重写迭代器
     */
    @Override
    public Iterator<E> iterator()
    {
        return new Iterator<E>()
        {
            private int p = head;//从队头开始
            /**
             * 判断是否有下一个元素
             * @return  如果有返回true，否则返回false，next()方法终止
             */
            @Override
            public boolean hasNext()
            {
               return p != tail; //如果p == tail，说明已经到队尾了，没有下一个元素了
            }

            /**
             * 获取下一个元素
             * @return  下一个元素
             * p % array.length 为了防止p超出数组长度，因为p会一直增加。
             */
            @Override
            public E next()
            {
                E value = array[p % array.length];
                p++;//p自增，为下次调用next()做准备
                return value;
            }
        };
    }


     /**
     * 实现isEmpty方法
     * @return  如果队头指针等于队尾指针，说明队列为空，返回true，否则返回false
     */
    @Override
    public boolean isEmpty()
    {
        return head == tail;
    }

    /**
     * 实现isFall方法
     * @return  如果队尾指针减去队头指针等于数组长度，说明队列已满，返回true，否则返回false
     */
    @Override
    public boolean isFall()
    {
        return tail - head == array.length;
    }




    /**
     * 实现offer方法
     * @return  如果队列已满，返回false，添加成功返回true
     */
    @Override
    public boolean offer(E value)
    {
        if(isFall())
        {
            return false;
        }
        array[tail % array.length] = value;//向队尾添加元素
        tail++;//队尾指针后移
        return true;
    }

    /**
     * 实现poll方法
     * @return  如果队列为空，返回null，否则返回队头元素，并将队头指针后移，相当于删除队头元素
     */
    @Override
    public E poll()
    {
        if (isEmpty())
        {
            return null;
        }
        E value = array[head % array.length];
        head++;
        return value;
    }

    /**
     * 实现peek方法
     * @return  如果队列为空，返回null，否则返回队头元素
     */
    @Override
    public E peek()
    {
        if (isEmpty())
        {
            return null;
        }
        return array[head % array.length];
    }

   
}

完了吗？有没有发现上面有什么问题？

int 是不是有个长度限制，最大支持到2147483647，超出会变成负数，而head,tail 会一直自增，但是数组索引只支持int 类型，且必须为正数，所以我们要处理一下，不然超出范围就不行了。

第一种：

在C家族的语言中都支持声明无符号整数，就连最像java的C#都支持 uint 类型，但Java就没有。嘿，气人不。

所以只能曲线救国：用 Integer.toUnsignedLong() 方法来转成无符号长整型，再强转成int

每个数组变量都要变成这样：

array[(int)Integer.toUnsignedLong(n)]

但是这种方法虽然可以解决问题但效率不高，所以还有第二种；

第二种：

采用二进制运算 ‘按位与’：‘&’

这种运算简而言之是将两个二进制数进行比较，如果相同位置上的两个数都为 1 就保留 1 否则全换成 0

比如：

int a = 5; // 二进制：0101
int b = 3; // 二进制：0011

int result = a & b; // 结果：0001 (1的二进制表示)

而一个2的n次方 - 1 的数作为除数，那它的余数在二进制上，就等于 被除数 & 除数

所以在保证数组的长度为一个2的n次方的前提下，就可以改成：

array[head & (array.length - 1)]

这种形式

所以现在的问题是要保证数组的长度为2的n次方

可以采用·：

方式一：

构造函数里面抛异常，只接受容量为2的n次方

 public ArrayQueue3(int capacity)
    {
        if ((capacity & capacity - 1) != 0)
        {
           throw new IllegalArgumentException("capacity 必须是2的幂");
        }

        array = (E[])new Object[capacity];
        head = 0;
        tail = 0;
    }

方式二：扩容成2的n次方

先用 (int)(Math.log10(capacity ) / Math.log10(2))得到以2为底capacity的对数的整数部分，

然后加一，就是扩容后的容量的那个2的次方，保证了其始终为2的n次方

        int n = (int)(Math.log10(capacity) / Math.log10(2)) + 1;
        capacity = 1 << n;//2的n次方的二进制运算方法，1左移一位就是2的一次方，左移两位就是2的二次方......

但是还有一个问题，如果这个数刚好是2的n次方，那么就没有必要去加那一个一，所以先让capacity去减一，以满足所有情况：

        int n = (int)(Math.log10(capacity - 1) / Math.log10(2)) + 1;
        capacity = 1 << n;

当然，这一步还有一种更花哨的写法，全部基于二进制运算：

        capacity -= 1;
        capacity |= capacity >> 1;
        capacity |= capacity >> 2;
        capacity |= capacity >> 4;
        capacity |= capacity >> 8;
        capacity |= capacity >> 16;
        capacity += 1;

这个就是纯数学了，有兴趣的可以研究一下。嘿嘿。

下面是改好后的全部代码：

public class ArrayQueue3<E> implements Queue<E>,Iterable<E>
{
    private final E[] array;
    private int head;
    private int tail;

    /**
     * 有参构造创建队列
     * @param capacity  队列容量
     */
    public ArrayQueue3(int capacity)
    {
//        if ((capacity & capacity - 1) != 0)
//        {
//            throw new IllegalArgumentException("capacity 必须是2的幂");
//        }
//
//        int n = (int)(Math.log10(capacity - 1) / Math.log10(2)) + 1;
//        capacity = 2 << n;

        capacity -= 1;
        capacity |= capacity >> 1;
        capacity |= capacity >> 2;
        capacity |= capacity >> 4;
        capacity |= capacity >> 8;
        capacity |= capacity >> 16;
        capacity += 1;
        array = (E[])new Object[capacity];
        head = 0;
        tail = 0;
    }

    /**
     * 重写迭代器
     */
    @Override
    public Iterator<E> iterator()
    {
        return new Iterator<E>()
        {
            private int p = head;//从队头开始
            /**
             * 判断是否有下一个元素
             * @return  如果有返回true，否则返回false，next()方法终止
             */
            @Override
            public boolean hasNext()
            {
               return p != tail; //如果p == tail，说明已经到队尾了，没有下一个元素了
            }

            /**
             * 获取下一个元素
             * @return  下一个元素
             * p % array.length 为了防止p超出数组长度，因为p会一直增加。
             */
            @Override
            public E next()
            {
                E value = array[p & (array.length - 1)];
                //E value = array[(int)Integer.toUnsignedLong(p % array.length)];
                p++;//p自增，为下次调用next()做准备
                return value;
            }
        };
    }

    /**
     * 实现offer方法
     * @return  如果队列已满，返回false，添加成功返回true
     */
    @Override
    public boolean offer(E value)
    {
        if(isFall())
        {
            return false;
        }
        array[tail & (array.length - 1)] = value;//向队尾添加元素
        tail++;//队尾指针后移
        return true;
    }

    /**
     * 实现poll方法
     * @return  如果队列为空，返回null，否则返回队头元素，并将队头指针后移，相当于删除队头元素
     */
    @Override
    public E poll()
    {
        if (isEmpty())
        {
            return null;
        }
        E value = array[head & (array.length - 1)];
        head++;
        return value;
    }

    /**
     * 实现peek方法
     * @return  如果队列为空，返回null，否则返回队头元素
     */
    @Override
    public E peek()
    {
        if (isEmpty())
        {
            return null;
        }
        return array[head & (array.length - 1)];
    }

    /**
     * 实现isEmpty方法
     * @return  如果队头指针等于队尾指针，说明队列为空，返回true，否则返回false
     */
    @Override
    public boolean isEmpty()
    {
        return head == tail;
    }

    /**
     * 实现isFall方法
     * @return  如果队尾指针减去队头指针等于数组长度，说明队列已满，返回true，否则返回false
     */
    @Override
    public boolean isFall()
    {
        return tail - head == array.length;
    }
}

然后是链表实现：

public class LinkedListQueue<E>  implements Queue<E>,Iterable<E>
{
    /**
     * 链表节点类
     * @param <E>  节点值的类型
     *           value  节点值
     *           next   下一个节点
     */
    private static class Node<E>
    {
        E value;
        Node next;
        public Node(E value,Node<E> next)
        {
            this.value=value;
            this.next=next;
        }
    }
    private Node<E> head = new Node<>(null,null);//头节点
    private Node<E> tail = head;//尾节点
    private int size;//队列长度
    private int capacity = Integer.MAX_VALUE;//队列容量，默认为Integer.MAX_VALUE
    

    /**
     * 初始化队列，使得队尾指向队头
     */
    {
        tail.next = head;
    }

    public LinkedListQueue()
    {

    }

    /**
     * 有参构造创建队列
     * @param capacity  队列容量
     */
    public LinkedListQueue(int capacity)
    {
        this.capacity = capacity;
    }
    
    /**
     * 实现offer方法
     * @param value  待插入的值
     * @return       如果队列已满，返回false
     *               否则，将值插入队尾，返回true
     */
    @Override
    public boolean offer(E value)
    {
        if (size >= capacity)
        {
            return false;
        }
        Node<E> added = new Node<>(value,head);
        tail.next = added;
        tail = added;
        size ++;
        return true;
    }

    /**
     * 实现poll方法
     * @return  如果队列为空，返回null
     *          否则，返回队头的值，并将队头指针后移，相当于删除队头元素
     */
    @Override
    public E poll()
    {
        if (isEmpty())
        {
           return null;
        }
        else
        {
            Node<E> first = head.next;
            head.next = first.next;
            if (first == tail)//如果队列只有一个元素，删除后队列为空，需要重新让tail=head，且将tail重新指向head
            {
                tail = head;
                tail.next = head;
            }
            size --;
            return first.value;
        }
    }

    /**
     * 实现peek方法
     * @return  如果队列为空，返回null
     *          否则，返回队头的值
     */
    @Override
    public E peek()
    {
        if (isEmpty())
        {
            return  null;
        }
        else
        {
            return (E) head.next.value;
        }
    }

    /**
     * 实现isEmpty方法
     * @return  如果队头指针等于队尾指针，说明队列为空，返回true，否则返回false
     */
    @Override
    public boolean isEmpty()
    {
        return head == tail;
    }

    /**
     * 实现isFall方法
     * @return  如果队列已满，返回true，否则返回false
     */
    @Override
    public boolean isFall() {
        return false;
    }

    /**
     * 实现iterator方法
     * @return  返回一个迭代器
     */
    @Override
    public Iterator<E> iterator() {
        //匿名内部类实现迭代器
        return new Iterator<E>() {
            Node<E> p = head.next;
            /**
             * 实现hasNext方法
             * @return  如果p不等于head，说明还有元素，返回true，否则返回false
             */
            @Override
            public boolean hasNext() {
                return p != head;
            }

            /**
             * 实现next方法
             * @return  返回p的值，并将p后移
             */
            @Override
            public E next() {
                E value = p.value;
                p = p.next;
                return value;
            }
        };
    }
}

链表实现起来比较简单

Growing Hacker
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java数据结构之栈、队列
m0_52846268的博客
11-28 832
实现基于数组的栈 栈介绍： 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 代码实现： import java.util.NoSuchElementException; public class MyStack<T> {
Java数据结构之栈、队列
m0_56158576的博客
09-23 163
java 线性数据结构 java 数据结构之 stack public class Stack { private int[] elements; public Stack(){ elements=new int[0]; } //实现入栈与出栈 public void add(int value){ //栈中添加元素 int[] newArr=new int[elements.length+1]; for (i
Java 数据结构之队列(Queue)详解
swadian2008的博客
09-11 2万+
但需要注意的是，由于数组的容量是固定的，当队列已满时，无法再添加新的元素，除非进行元素的出队操作。通过enqueue()方法将元素入队，dequeue()方法将元素出队，peek()方法返回队列头部元素，size()方法返回队列当前元素个数，isEmpty()方法和isFull()方法检查队列是否为空或已满。Deque接口还提供了一些其他方法，如size()用于返回双端队列中的元素个数，isEmpty()用于判断双端队列是否为空，clear()用于清空双端队列中的所有元素等。
java中常用的队列
一名小码农的博客
12-22 2万+
一、java中的队列 Queue： 基本上，一个队列就是一个先入先出（FIFO）的数据结构 Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Deque接口 二、非阻塞队列 非阻塞队列不能阻塞，多线程时，当队列满或者队列空时，只能使用队列wait()，notify()进行队列消息传送。 1. PriorityQueue PriorityQue...
Java中的常用队列
林在闪闪发光的博客
12-27 4545
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear） 出队列：进行删除操作的一端称为队头（Head/Front）
JAVA队列（ Queue ) 详解
热门推荐
叶新东老师的博客
04-24 8万+
什么是队列？ 队列是一种特殊的线性表，遵循先入先出、后入后出的基本原则，一般来说，它只允许在表的前端进行删除操作，而在表的后端进行插入操作，但是java的某些队列运行在任何地方插入删除；比如我们常用的 LinkedList 集合，它实现了Queue 接口，因此，我们可以理解为LinkedList 就是一个队列； java队列特性 队列主要分为阻塞和非阻塞，有界和无界、单向链表和双向链表之分； 阻塞和非阻塞 阻塞队列 入列(删除元素)时，如果元素数量超过队列总数......
JAVA队列（Queue）用法附实例讲解
机智大头
04-23 1万+
队列用于模拟队列这种数据结构，队列通常是指“先进先出”的容器。新元素插入（offer）到队列的尾部，访问元素（poll）操作会返回队列头部的元素。通常，队列不允许随机访问队列中的元素。
java实现队列数据结构代码详解
08-28
"java实现队列数据结构代码详解" 本文主要介绍了 Java 实现队列数据结构的代码详解，包括队列结构的介绍、队列实现的代码和队列的应用场景。 队列结构是一种线性结构，具有特殊的运算法则：只能在一端（队头）删除...
java 数据结构中栈和队列的实例详解
08-29
java 数据结构中栈和队列的实例详解 java 数据结构中栈和队列是两种重要的线性数据结构，都是在一个特定的范围的存储单元中的存储数据。与线性表相比，它们的插入和删除操作收到更多的约束和限定，又被称为限定性的...
java编程队列数据结构代码示例
08-28
Java 编程队列数据结构代码示例 Java 编程队列数据结构代码示例主要介绍了 Java 编程队列数据结构代码示例，简单介绍了队列的相关基础知识，然后通过实例向大家展示其实现方法，具有一定参考价值，需要的朋友可以...
数据结构 Java实验4 栈和队列.doc
06-20
在本实验报告中，主要涉及了数据结构中的两种基本结构——栈和队列，并通过Java编程语言实现了它们的实例应用。栈是一种具有“后进先出”（LIFO）特性的数据结构，而队列则遵循“先进先出”（FIFO）的原则。 在第一...
Java数组模拟优先级队列数据结构的实例
09-02
在Java中，实现优先级队列通常会利用内置的数据结构如`TreeSet`或`TreeMap`，因为它们提供了自动排序的功能，可以根据元素的优先级进行调整。 在上述的Java代码示例中，作者通过数组来模拟优先级队列的实现。这个...
深入理解Java中的队列（Queue）
最新发布
2201_75437633的博客
01-24 5830
队列是一种线性数据结构，它的特点是先进先出。在队列中，元素的添加（入队）操作在队尾进行，而元素的移除（出队）操作则在队头进行。因此，队列可以被简单地描述为一个“先进先出”的容器。在Java中，队列接口继承自Collection接口，并提供了丰富的方法来操作队列中的元素。
Java7种常见队列
cstjzr的博客
05-09 2850
是线程池中的一个重要组件，用于存储待执行的任务。当线程池中的线程空闲时，它会从任务队列中获取任务并执行。任务队列通常是一个先进先出(FIFO)的队列，即新加入的任务会排在队列的末尾，等待线程池中的线程执行。
Java中的队列
Binnnnnhern的博客
03-19 667
Java中队列的简介
java详解队列
buhuisuanfa的博客
09-30 5072
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear） 出队列：进行删除操作的一端称为队头（Head/Front）
Java中常用的七种队列你了解多少?
猫头虎：授渔优于赠鱼，兴趣引领智慧，探索之乐尤显珍贵。商务合作：Libin9iOak，共赴知识与乐趣的探索之旅！
02-28 1万+
Java中常用的七种队列你了解多少?Java中常用的七种队列你了解多少?Java中常用的七种队列你了解多少?Java中常用的七种队列你了解多少?Java中常用的七种队列你了解多少?Java中常用的七种队列你了解多少?Java中常用的七种队列你了解多少?Java中常用的七种队列你了解多少?Java中常用的七种队列你了解多少?Java中常用的七种队列你了解多少?Java中常用的七种队列你了解多少?Java中常用的七种队列你了解多少?Java中常用的七种队列你了解多少?Java中常用的七种队列你了解多少?Java
java数据结构面试题.pdf
07-14
"这是一份Java数据结构相关的面试题集，涵盖了栈、队列、链表、线性表、树、二叉树、数据库保护等多个核心概念，旨在测试和提升面试者的理论知识和理解能力。" 在这份Java数据结构面试题中，我们可以看到一些关键...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值