数据结构与算法——Java实现 27.双端队列

于 2024-10-03 20:17:10 发布
阅读量508 收藏 6
点赞数 8
分类专栏： 数据结构与算法 —— Java实现 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73983707/article/details/142628091
版权

很多人觉得做一件事付出了10分的努力，却只得到5分的汇报。

其实剩下的五分，是在填补你过往的懒惰。

只有将过往的懒惰填满，

努力才会有正向结果

                                                                                        —— 24.10.3

一、概述

双端队列、队列、栈对比：

队列

        一端删除（头），一段添加（尾）        先进先出（FIFO）

栈

        一端删除和添加        后进先出（LIFO）

双端队列

        队列的两端都可以添加、删除

二、双端队列——双向环形链表实现

双端队列要求队头队尾都可以添加和删除元素

所以为了使所有节点都方便计算，于是添加两个指针prev和next，一个指向每个节点的前一个元素，另一个指向一个每个节点的后一个元素，这样在队列头尾删除或添加元素时，只需要通过节点前后节点的指向，快捷删除

定义哨兵节点sentinel，根据哨兵节点前后指针的指向，进行添加和删除

接口

public interface Deque<E> {
    /*
        向队列头部添加元素
        Returns:bool类型，添加是否成功
     */
    boolean offerFirst(E e);

    /*
        向队列尾部添加元素
        Returns:bool类型，添加是否成功
    */
    boolean offerLast(E e);

    /*
        从队列的头部删除元素
        Returns:返回删除的元素
    */
    E pollFirst();

    /*
        从队列的尾部删除元素
        Returns:返回删除的元素
    */
    E pollLast();

    /*
        从队列的头部获取元素
        Returns:获取头部的元素
    */
    E peekFirst();

    /*
        从队列的尾部获取元素
        Returns:获取尾部的元素
    */
    E peekLast();

    /*
        判断队列是否为空
        Returns：判断是否为空
    */
    boolean isEmpty();

    /*
        判断队列是否为满
        Returns：判断是否为满
    */
    boolean isFull();
}

环形链表类

import java.util.Iterator;

/*
    基于双向环形链表实现双端队列
    Type parameters <E> —— 队列中元素类型
 */
public class LinkedListDeque<E> implements Deque<E>,Iterable<E>{
    // 容量
    int capacity;

    // 元素个数
    int size;

    // 哨兵
    Node<E> sentinel = new Node<>(null, null, null);

    // 首部添加
    @Override
    public boolean offerFirst(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;
    }

    // 尾部添加
    @Override
    public boolean offerLast(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;
    }

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

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

    // 首部获取
    @Override
    public E peekFirst() {
        if (isEmpty()) {
            return null;
        }
        Node<E> node = sentinel.next;
        return node.value;
    }

    // 尾部获取
    @Override
    public E peekLast() {
        if (isEmpty()) {
            return null;
        }
        Node<E> node = sentinel.prev;
        return node.value;
    }

    // 判空
    @Override
    public boolean isEmpty() {
        return size==0;
    }

    // 判满
    @Override
    public boolean isFull() {
        return size==capacity;
    }

    // 迭代器
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            Node<E> p = sentinel.next;
            @Override
            public boolean hasNext() {
                return p!=sentinel;
            }

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

    // 节点类 prev指针指向上一个节点，next指针指向下一个节点
    static class Node<E> {
        Node<E> prev;
        E value;
        Node<E> next;

        public Node(Node<E> prev, E value, Node<E> next) {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }
    }

    public LinkedListDeque(int capacity) {
        this.capacity = capacity;
        sentinel.next = sentinel;
        sentinel.prev = sentinel;
    }
}

 测试类

import static org.junit.jupiter.api.Assertions.*;
import org.junit.Test;

import java.util.List;

public class TestLinkedListDeque {
    // 添加节点
    @Test
    public void offer(){
        LinkedListDeque<Integer> deque = new LinkedListDeque<>(5);
        deque.offerFirst(3);
        deque.offerLast(4);
        deque.offerFirst(2);
        deque.offerLast(5);
        deque.offerFirst(1);
        assertFalse(deque.offerLast(6));
        assertIterableEquals(List.of(1,2,3,4,5),deque);
    }

    // 移除节点
    @Test
    public void poll(){
        LinkedListDeque<Integer> deque = new LinkedListDeque<>(5);
        deque.offerFirst(3);
        deque.offerLast(4);
        deque.offerFirst(2);
        deque.offerLast(5);
        deque.offerFirst(1);

        assertEquals(1, deque.pollFirst());
        assertEquals(2, deque.pollFirst());
        assertEquals(3, deque.pollFirst());
        assertEquals(4, deque.pollFirst());
        assertEquals(5, deque.pollLast());
        assertNull(deque.pollLast());
        assertTrue(deque.isEmpty());
    }

}

三、双端队列——数组实现

基于循环数组实现

head：头指针        tail：尾指针

特点：tail停下来的位置不存储，会浪费一个位置

Type parameters：<E>——队列中元素类型

 接口

public interface Deque<E> {
    /*
        向队列头部添加元素
        Returns:bool类型，添加是否成功
     */
    boolean offerFirst(E e);

    /*
        向队列尾部添加元素
        Returns:bool类型，添加是否成功
    */
    boolean offerLast(E e);

    /*
        从队列的头部删除元素
        Returns:返回删除的元素
    */
    E pollFirst();

    /*
        从队列的尾部删除元素
        Returns:返回删除的元素
    */
    E pollLast();

    /*
        从队列的头部获取元素
        Returns:获取头部的元素
    */
    E peekFirst();

    /*
        从队列的尾部获取元素
        Returns:获取尾部的元素
    */
    E peekLast();

    /*
        判断队列是否为空
        Returns：判断是否为空
    */
    boolean isEmpty();

    /*
        判断队列是否为满
        Returns：判断是否为满
    */
    boolean isFull();
}

循环数组类

import java.util.Iterator;

public class ArrayDeque<E> implements Deque<E>,Iterable<E> {

    // 两个工具方法 1
    static int inc(int i,int length){
        if (i + 1 >= length){
            return 0;
        }
        return i + 1;
    }

    // 两个工具方法 2
    static int dec(int i,int length){
        if (i - 1 < 0){
            return length - 1;
        }
        return i - 1;
    }

    E[] array;
    int head;
    int tail;

    @SuppressWarnings("all")
    public ArrayDeque(int capacity){
        array = (E[]) new Object[capacity+1];
    }

    @Override
    public boolean offerFirst(E e) {
        if (isFull()){
            return false;
        }
        head = dec(head, array.length);
        array[head] = e;
        return true;
    }

    @Override
    public boolean offerLast(E e) {
        if (isFull()){
            return false;
        }
        array[tail] = e;
        tail = inc(tail, array.length);
        return true;
    }

    @Override
    public E pollFirst() {
        if (isEmpty()){
            return null;
        }
        E e = array[head];
        // 帮助垃圾回收
        array[head] = null;
        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;
        return e;
    }

    @Override
    public E peekFirst() {
        if (isEmpty()){
            return null;
        }
        return array[head];
    }

    @Override
    public E peekLast() {
        if (isEmpty()){
            return null;
        }
        return array[dec(tail, array.length)];
    }

    @Override
    public boolean isEmpty() {
        return head == tail;
    }

    @Override
    public boolean isFull() {
        if (tail > head){
            return tail - head == array.length - 1;
        } else if (tail < head) {
            return head - tail == 1;
        } else {
            return false;
        }
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;
            @Override
            public boolean hasNext() {
                return p != tail;
            }

            @Override
            public E next() {
                E e = array[p];
                p = inc(p,array.length);
                return e;
            }
        };
    }
}

测试类

import org.junit.Test;

import java.util.List;

import static org.junit.jupiter.api.Assertions.*;

public class TestArrayDeque {
    @Test
    public void offer() {
        ArrayDeque<Integer> deque = new ArrayDeque<>(5);
        deque.offerFirst(1);
        deque.offerLast(2);
        deque.offerLast(3);
        deque.offerLast(4);
        deque.offerLast(5);
        assertFalse(deque.offerLast(3));
        assertIterableEquals(List.of(1,2,3,4,5), deque);
    }

    @Test
    public void poll() {
        ArrayDeque<Integer> deque = new ArrayDeque<>(5);
        assertTrue(deque.isEmpty());
        deque.offerFirst(1);
        deque.offerLast(2);
        deque.offerLast(3);
        deque.offerLast(4);
        deque.offerFirst(5);
        assertIterableEquals(List.of(5,1,2,3,4),deque);
        assertTrue(deque.isFull());

        assertEquals(5, deque.pollFirst());
        assertEquals(4, deque.pollLast());
        assertEquals(1 , deque.pollFirst());
        assertEquals(3 , deque.pollLast());
        assertEquals(2 , deque.pollFirst());
        assertNull(deque.pollLast());
        assertTrue(deque.isEmpty());
    }
}

垃圾回收机制

因为用泛型实现，所以都是引用类型，我们需要将索引位置的数组值在处理完后赋值为null

L_cl
关注
专栏目录
【数据结构】12.双端队列的实现
weixin_46955173的博客
01-14 743
一、双端队列的定义 双端队列（double ended queue ，deque） 是限定插入和删除操作在表的两端进行的线性表 是一种具有队列和栈的性质的数据结构 总的来说就是在循环队列的基础上让其无论在头部还是尾部都可以进行增删 从而可以同时实现队列合栈的全部功能 二、Deque双端队列接口的定义 双端队列大致思想与循环队列一样 无非在队首可添加，在队尾可删除 public interface Dequeue<E> extends Queue<E> {
Java双端队列
LronDog的博客
07-10 475
Java中双端队列Deque是一种数据结构，可以在其两端插入或删除元素，是队列与栈的结合，可以用于实现堆栈，列表和列表的操作，继承Queue接口。。 以下实例总结了Deque的实现与常用方法展示 public class DoubleQueue { public static void main(String[] args) { Deque<String> deq =new ArrayDeque<String>(); //添加数据 deq.add("1");.
java数据结构之双端队列
sxapple666的博客
03-18 589
//其实数据结构我们首先要去理解其原理，然后通过实践来验证自己的想法，是一个很不错的选择 //如果你们看到了我前期链表的设计 //再来理解双端队列其实也是很简单的， /* *主要是要注意到，在Node初始化时 就对Node的prev或next进行了指定 *这也是理解双端队列的关键 */ public class DQueue&lt;E&gt; { public DQueue()...
java中双端队列的使用
weixin_44270056的博客
11-09 269
java双端队列
Java数据结构--双端队列
m0_74808313的博客
05-14 2197
思路:首先获取尾部节点的前一个节点( sentinel. pre.pre)以及哨兵节点( sentinel),最后更新相应指针即可思路:直接返回队尾元素( sentinel.pre.val)思路:向左移动tail指针，将tail位置的空间置空思路:直接返回tail位置元素。
数据结构与算法笔记（五）——队列(FIFO队列、双端队列)
别呀的博客
09-15 8470
一、FIFO队列 1.1、概念 队列(queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出的(First In First Out)的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q= (a1，a2，…，an)，那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然排在队伍最后。 1.2、队
剑指offer计划27（栈与队列困难）---java（csdn）————程序.pdf
12-04
在本篇讨论中，我们将深入理解两种不同的编程问题，它们都涉及到栈与队列的数据结构，以及如何在Java中高效地解决这些问题。首先，我们来看第一个题目，"剑指 Offer 59 - I. 滑动窗口的最大值"。 滑动窗口的最大值...
用数组实现的双端队列（类模板）
03-26
自己写得基于数组的双端队列类模板，初步测试没什么问题，接口不太丰富，各位参考一下吧，也希望能得到反馈
java数据结构--双端队列
最新发布
可爱的鸡仔的博客
11-08 506
*** 双端队列*///队头添加元素//队尾添加元素//队头取元素并删除该元素//队尾取元素并删除该元素//队头取元素//队尾取元素//是否为空//是否为满。
java数据结构系列，第四篇：双端队列
m0_63117721的博客
08-22 658
双端队列（Double-ended queue，简称Deque）是一种数据结构，允许在队列的两端进行插入和删除操作。它可以被看作是一个允许元素插入和删除的线性表，但与普通队列不同，双端队列支持在队列的头部和尾部进行插入和删除操作，因此具有更加灵活的使用方式。双端队列在很多算法和数据结构问题中都有广泛的应用，因为它的灵活性使得它可以同时满足栈和队列的需求。这使得双端队列可以像栈一样用于一些问题，比如实现逆序计算或其他需要后进先出（LIFO）操作的场景。这使得双端队列保持了队列的性质，即先进先出（FIFO）。
学习笔记——java双端队列
qq_23858785的博客
07-28 965
java双端队列
【Java 数据结构及算法实战】系列 014：Java队列08——数组实现的双端队列ArrayDeque
老卫的技术站
05-17 732
ArrayDeque是基于数组实现的无界双端队列。ArrayDeque中的数组没有容量限制，它们能根据需要增长以支持使用。需要注意的是ArrayDeque不是线程安全的，因此在没有外部同步的情况下，它们不支持多线程并发访问。 ArrayDeque用作栈时可能比Stack更快，用作队列时可能比LinkedList更快。 ArrayDeque禁止插入空元素。 ArrayDeque及其迭代器实现了Collection和Iterator接口的所有可选方法。 ArrayDeque是Java Collectio
双端队列数组版【Java算法（五）】
qq_56402474的博客
04-01 778
掌握了栈与队列后，如何将二者的优势联系起来。这里简单的写了Java代码了解双端队列
java队列实现(数组，链式，双端)
WDC的博客
03-05 482
package Queue; public class ArrayQueue<E>{ private E []arrayQueue; private int maxSize; private int rear,front; private int size; public ArrayQueue(int maxSize) { arrayQueue = (E[]) ne...
【算法导论】10.1-5单数组实现双端队列
苦咖啡的自留地
01-02 2161
算法导论习题，单数组实现双端队列，欢迎拍砖！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值