java数据结构系列，第四篇：双端队列

最新推荐文章于 2024-06-17 10:44:54 发布
最新推荐文章于 2024-06-17 10:44:54 发布
阅读量493 收藏 3
点赞数
文章标签： java 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63117721/article/details/132438669
版权

双端队列（Double-ended queue，简称Deque）是一种数据结构，允许在队列的两端进行插入和删除操作。它可以被看作是一个允许元素插入和删除的线性表，但与普通队列不同，双端队列支持在队列的头部和尾部进行插入和删除操作，因此具有更加灵活的使用方式。

双端队列的特点包括：

  1. 前端插入和删除： 可以在双端队列的前端执行插入和删除操作。这使得双端队列可以像栈一样用于一些问题，比如实现逆序计算或其他需要后进先出（LIFO）操作的场景。

  2. 后端插入和删除： 同样可以在双端队列的后端执行插入和删除操作。这使得双端队列保持了队列的性质，即先进先出（FIFO）。

双端队列常见的操作包括：

  • 在前端插入元素（push_front）：将一个新元素插入到双端队列的头部。
  • 在前端删除元素（pop_front）：删除并返回双端队列的头部元素。
  • 在后端插入元素（push_back）：将一个新元素插入到双端队列的尾部。
  • 在后端删除元素（pop_back）：删除并返回双端队列的尾部元素。
  • 获取前端元素（front）：返回双端队列的头部元素，但不进行删除。
  • 获取后端元素（back）：返回双端队列的尾部元素，但不进行删除。

双端队列在很多算法和数据结构问题中都有广泛的应用，因为它的灵活性使得它可以同时满足栈和队列的需求。在编程中，许多编程语言提供了标准库中的双端队列实现，以方便开发者使用。

下面分别是用链表和数组实现双端队列：

先定义一个接口：
 

public interface Deque<E>
{
    /**
     * 从头部插入
     * @param e 要插入的元素
     * @return 是否插入成功
     */
    boolean offerFirst(E e);
    /**
     * 从尾部插入
     * @param e 要插入的元素
     * @return 是否插入成功
     */
    boolean offerLast(E e);
    /**
     * 从头部删除
     * @return 被删除的元素
     */
    E pollFirst();
    /**
     * 从尾部删除
     * @return 被删除的元素
     */
    E pollLast();
    /**
     * 从头部查看
     * @return 被查看的元素
     */
    E peekFirst();
    /**
     * 从尾部查看
     * @return 被查看的元素
     */
    E peekLast();
    /**
     * 队列是否为空
     * @return 是否为空
     */
    boolean isEmpty();
    /**
     * 队列是否已满
     * @return 是否已满
     */
    boolean isFull();
}

链表实现：



public class LinkedListDeque<E>  implements Deque<E>, Iterable<E>
{
    /**
     * 双向链表节点类
     * @param <E> 节点存储的元素类型
     */
    static class Node<E>
    {
        Node<E> prev;//前驱，表示当前节点的前一个节点
        E value;//值
        Node<E> next;//后继，当前节点的后一个节点
        Node(final Node<E> prev,final E value,final Node<E> next)
        {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }
    }
    int capacity = Integer.MAX_VALUE;//容量
    int size;//当前元素个数
    Node<E> sentinel = new Node<>(null,null,null);//哨兵节点

        /**
         * 构造函数
         * @param capacity 容量
         */
    public LinkedListDeque(final int capacity)
    {
        this.capacity = capacity;
        sentinel.prev = sentinel;
        sentinel.next = sentinel;
    }
    /**
     * 构造函数
     */
    public LinkedListDeque()
    {
        sentinel.prev = sentinel;
        sentinel.next = sentinel;
    }

    /**
     * 迭代器
     * @return 迭代器
     */
    @Override
    public Iterator<E> iterator()
    {
        return new Iterator<E>() {
            Node<E> p = sentinel.next;//当前节点
            /**
             * 是否有下一个元素
             * @return 是否有下一个元素，p不等于哨兵节点时有下一个元素
             */
            @Override
            public boolean hasNext()
            {
                return p != sentinel;
            }
            
            /**
             * 获取当前元素的值，并将p指向下一个元素
             * @return 当前元素的值
             */

            @Override
            public E next()
            {
                E value = p.value;
                p = p.next;
                return value;
            }
        };
    }

    /**
     * 从头部插入
     * @param e 要插入的元素
     * @return 是否插入成功
     */
    @Override
    public boolean offerFirst(final E e)
    {
        if (isFull())
        {
            return false;
        }
        Node<E> a = sentinel;
        Node<E> b = sentinel.next;
        Node<E> added = new Node<>(a,e,b);
        a.next = added;
        b.prev = added;
        size ++;
        return true;
    }

    /**
     * 从尾部插入
     * @param e 要插入的元素
     * @return 是否插入成功
     */
    @Override
    public boolean offerLast(final E e)
    {
        if (isFull())
        {
            return false;
        }
        Node<E> a = sentinel.prev;
        Node<E> b = sentinel;
        Node<E> added = new Node<>(a,e,b);
        a.next = added;
        b.prev = added;
        size ++;
        return true;
    }

    /**
     * 从头部删除
     * @return 被删除的元素
     */
    @Override
    public E pollFirst()
    {
        if (isEmpty())
        {
            return null;
        }
        Node<E> a = sentinel;
        Node<E> removed = sentinel.next;
        Node<E> b = removed.next;
        a.next = b;
        b.prev = a;
        size --;
        return removed.value;
    }

    /**
     * 从尾部删除
     * @return 被删除的元素
     */
    @Override
    public E pollLast()
    {
        if (isEmpty())
        {
            return null;
        }
        Node<E> removed = sentinel.prev;
        Node<E> a = removed.prev;
        Node<E> b = sentinel;
        a.next = b;
        b.prev = a;
        size --;
        return removed.value;
    }

    /**
     * 从头部查看
     * @return 被查看的元素
     */
    @Override
    public E peekFirst()
    {
        if (isEmpty())
        {
            return null;
        }
        return sentinel.next.value;
    }

    /**
     * 从尾部查看
     * @return 被查看的元素
     */
    @Override
    public E peekLast()
    {
        if (isEmpty())
        {
            return null;
        }
        return sentinel.prev.value;
    }

    /**
     * 队列是否为空
     * @return 是否为空
     */
    @Override
    public boolean isEmpty()
    {
        return size == 0;
    }

    /**
     * 队列是否已满
     * @return 是否已满
     */
    @Override
    public boolean isFull()
    {
        return size == capacity;
    }
    
    
    /**
     * 重写toString方法
     */

    @Override
    public String toString()
    {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        int i = 0;
        for (E e : this)
        {
            i ++;
            if (i == size)
            {
                sb.append(e);
            }
            else
            {
                sb.append(e);
                sb.append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

数组实现：
 



public class ArrayDeque1<E> implements Iterable<E>, Deque<E>
{
    /**
     * 用于给数组下标加1，如果到达数组末尾则返回0
     * @param i 当前下标
     * @param length 数组长度
     * return i+1    下标加1
     */
    static int inc(int i,int length)
    {
        if (i + 1 >= length)
        {
            return 0;
        }
        return i + 1;
    }
    
    /**
     * 用于给数组下标减1，如果到达数组头部则返回数组末尾下标
     * @param i 当前下标
     * @param length 数组长度
     * return i-1    下标减1
     */
    static int dec(int i,int length)
    {
        if (i - 1 < 0)
        {
            return length - 1;
        }
        return i - 1;
    }

    E[] array;//数组
    int head;//头指针，代表该队列的第一个元素
    int tail;//尾指针，始终置空，不存储元素，只是用来标记下一次尾部插入时，元素插入的位置

    /**
     * 构造函数
     * @param capacity 容量
     */
    public ArrayDeque1(int capacity)
    {
        array = (E[]) new Object[capacity + 1];
    }
    
    /**
     * 实现迭代器
     */
    @Override
    public Iterator<E> iterator()
    {
        return new Iterator<E>() {
            int p = head;//当前指针
            /**
             * 是否有下一个元素
             * @return 是否有下一个元素，p不等于尾指针时有下一个元素
             */
            @Override
            public boolean hasNext() {
                return p != tail;
            }

            /**
             * 获取当前元素的值，并将p指向下一个元素
             * @return 当前元素的值
             */
            @Override
            public E next() {
                E value = array[p];
                p = inc(p,array.length);
                return value;
            }
        };
    }

    /**
     * 从头部插入
     * @param e 要插入的元素
     * @return 是否插入成功
     */
    @Override
    public boolean offerFirst(E e)
    {
        if (isFull())
        {
            return false;
        }
        head = dec(head,array.length);//头指针向前一步
        array[head] = e;//在当前头指针处插入元素
        return true;
    }

    /**
     * 从尾部插入
     * @param e 要插入的元素
     * @return 是否插入成功
     */
    @Override
    public boolean offerLast(E e)
    {
        if (isFull())
        {
            return false;
        }
        array[tail] = e;//在当前尾指针处插入元素
        tail = inc(tail,array.length);//尾指针向后一步
        return true;
    }

    /**
     * 从头部删除
     * @return 被删除的元素
     */
    @Override
    public E pollFirst()
    {
        if (isEmpty())
        {
            return null;
        }
        E e = array[head];
        array[head] = null;//清理内存，help GC
        head = inc(head,array.length);
        return e;
    }

    @Override
    public E pollLast()
    {
        if (isEmpty())
        {
            return null;
        }
        tail = dec(tail,array.length);
        E e = array[tail];
        array[tail] = null;//help GC
        return e;
    }

    /**
     * 从头部查看
     * @return 被查看的元素
     */
    @Override
    public E peekFirst()
    {
        if (isEmpty())
        {
            return null;
        }
        return array[head];
    }

    /**
     * 从尾部查看
     * @return 被查看的元素
     */
    @Override
    public E peekLast()
    {
        if (isEmpty())
        {
            return null;
        }
        return array[dec(tail,array.length)];
    }

    /**
     * 队列是否为空
     * @return 是否为空
     */
    @Override
    public boolean isEmpty()
    {
        return head == tail;
    }

    /**
     * 队列是否已满，两种情况：
     * 1.如果尾指针在头指针后面，则当尾指针减头指针等于数组长度减1时，队列已满
     * 2.如果尾指针在头指针前面，则当头指针减尾指针等于1时，也就是头指针紧挨着尾指针，队列已满
     * @return 是否已满
     */
    @Override
    public boolean isFull()
    {
        if (tail > head)
        {
            return tail - head == array.length - 1;
        }
        else if (tail < head)
        {
            return head - tail == 1;
        }
        else
        {
            return  false;
        }
    }
}

Growing Hacker
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java deque 双向队列
Yuanxuan的博客
05-15 628
操作 插入元素 addFirst():向队头插入元素，如果元素为空，则发生NPE addLast():向队尾插入元素，如果为空，则发生NPE offerFirst():向队头插入元素，如果插入成功返回true，否则返回false offerLast():向队尾插入元素，如果插入成功返回true，否则返回false 移除元素 removeFirst():返回并移除队头元素，如果该元素是null，则发生NoSuchElementException ...
java-leetcode题解之第641题设计循环双端队列.zip
06-12
本资源“java-leetcode题解之第641题设计循环双端队列.zip”是一个关于Java实现LeetCode第641题的解题代码包，主要涉及的数据结构是循环双端队列（Circular Doubly Linked List）。现在，我们将深入探讨这个题目及其...
数据结构：用Java实现双端队列（超详细）
qq_51066068的博客
04-09 3567
Java双端队列 典型的双端队列收集如下所示： 双端队列(Deque:double ended queue)就是一个两端都是结尾的队列。队列的每一端都可以插入数据项和移除数据项。相对于普通队列，双端队列的入队和出队操作在两端都可进行。 left：左端 right：右端 这里我们使用最常用的顺序结构来存储双端队列，为了节省空间，把它首尾相连，构成循环队列。并且规定left指向左端的第一个元素，right指向右端的下一个位置。那么队空的判断则是left==right，队满是(le...
Java数据结构--双端队列
m0_74808313的博客
05-14 1917
思路:首先获取尾部节点的前一个节点( sentinel. pre.pre)以及哨兵节点( sentinel),最后更新相应指针即可思路:直接返回队尾元素( sentinel.pre.val)思路:向左移动tail指针，将tail位置的空间置空思路:直接返回tail位置元素。
第五章 栈与队列part01
最新发布
a781333978的博客
06-17 489
使用栈实现队列的下列操作：push(x) – 将一个元素放入队列的尾部。pop() – 从队列首部移除元素。peek() – 返回队列首部的元素。empty() – 返回队列是否为空。
java数据结构之双端队列ArrayDeque
冰血ANG的博客
09-05 3077
java 自带双端队列ArrayDeque的源码解析
数据结构--队列2--双端队列--java双端队列
余的日常学习
06-09 1309
数据结构--队列2--双端队列--java双端队列
java数据结构--双端队列
可爱的鸡仔的博客
11-08 379
*** 双端队列*///队头添加元素//队尾添加元素//队头取元素并删除该元素//队尾取元素并删除该元素//队头取元素//队尾取元素//是否为空//是否为满。
数据结构与算法 全 数据结构与算法全 Java
03-04
### 数据结构与算法详解 #### 一、初识算法 **1.1 什么是算法？** 算法是指解决问题的一系列步骤或指令集。它是一种清晰、有限的指导过程，用于完成特定任务或解决特定类型的问题。一个好的算法应当具备明确性、...
java数据结构.rar
04-27
本资源"java数据结构.rar"包含了一系列关于Java数据结构的视频教程，涵盖了从基础到高级的主题，对于学习和提升Java编程能力非常有帮助。 首先，我们从"1-第一讲数组.avi"开始。数组是最基础的数据结构，它是一组...
Java语言编写的数据结构-队列实现
07-23
- **java.util.ArrayDeque类**：提供了双端队列功能，可以作为高效的顺序队列实现。 6. **队列的应用场景** - **任务调度**：操作系统中，进程调度器使用队列来存储待执行的任务。 - **缓冲区管理**：在网络传输...
Java Stack，Queue，循环队列和双端队列的原理/性质 + 代码模拟实现
The_emperoor_man的博客
02-18 916
本文介绍了十分有趣的两种结构栈和队列，有时这两种结构对解决问题有奇效，所以废话不多说，直接上干货。
队列文档之双端队列
二木成林
05-09 1万+
双端队列是普通队列的扩展，是指允许两端都可以进行入队和出队操作的队列（即可以在队头进行入队和出队操作，也可以在队尾进行入队和出队操作的队列）。
双端队列(Deque)
热门推荐
Hacket_Xu的博客
11-05 1万+
deque，即双端队列(double ended queue)，是一种可以在两端扩展或收缩的序列化容器。deque是C++ 标准模板库的一部分，想要使用deque，需要在程序中包含头文件deque。规定了deque中可以存放哪种类型的元素。为deque名。
双端队列
weixin_43716329的博客
07-11 4839
文章目录一、什么是双端队列二、双端队列举例三、双端队列的应用总结 一、什么是双端队列 双端队列（Deque）是指允许两端都可以进行入和出队操作的队列，deque 是 “double ended queue” 的简称。那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。 双端队列（Deque）既可说是Queue的子接口，也可说Stack(JDK并未提供这个接口)的子接口。因此。Deque即可当成队列使用，也可当成栈使用。 由此可见，Deque其实就是Queue和Stack混合而成的一种特殊的线性表，
7、双端队列
qq_36697948的博客
01-19 2186
双端队列（Double-ended Queue，简称deque）是一种线性数据结构，它允许在两端进行插入和删除操作。这意味着与普通队列（FIFO，先进先出）或栈（LIFO，后进先出）不同，双端队列的使用者不仅可以从队列的一端（通常称为“尾”端）添加元素（enqueue），也可以从这一端删除元素（dequeue）。同时，双端队列还支持在另一端（通常称为“头”端）执行相同的操作，即在队列头部添加（enqueue at head）和删除（dequeue at head）元素。
数据结构--双端队列
m0_60593173的博客
07-01 6503
双端队列（Double-ended Queue，简称Deque）是一种具有队列和栈特性的数据结构，可以在队列的两端进行插入和删除操作。双端队列允许从前端和后端同时进行插入和删除操作，因此可以称为“两端都可以进出的队列”。双端队列的实现方式有多种，包括使用数组、链表等数据结构。具体的实现方式可以根据不同的需求和场景选择合适的方式。
数据结构与算法（八）——双端队列
shsbsns的博客
09-05 2377
双端队列（Double-ended Queue，简称Deque）是一种具有队列和栈特性的数据结构，可以在队列的两端进行插入和删除操作。双端队列允许从前端和后端同时进行插入和删除操作，因此可以称为“两端都可以进出的队列”。双端队列有以下几个特点：1、可以在队列的头部和尾部进行插入和删除的操作。2、元素的插入和删除操作可以分别称作入队和出队操作。3、可以进行先进先出（FIFO）和先进后出（LIFO）两种操作方式。4、可以实现栈和队列以及其他需要在两端进行插入和删除操作的场景。
【数据结构】72变的双端队列
蒙奇D索大的博客
01-25 2194
【数据结构】第三章——栈、队列和数组（8） 详细介绍双端队列及其使用，文中附赠博主个人对双端队列的做题经验……
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值