经典数据结构和算法 双端队列 java

最新推荐文章于 2024-07-03 15:26:54 发布
最新推荐文章于 2024-07-03 15:26:54 发布
阅读量1.9k 收藏
点赞数
分类专栏： 数据结构与算法
原文链接：https://blog.csdn.net/xiangxizhishi/article/details/79119501
版权
本文探讨了双端队列这一数据结构，它是栈和队列的结合体，允许在两端进行插入和删除操作。文章通过Java代码详细解释了如何定义结构体、队尾入队、队尾出队、队首入队和队首出队的过程，并指出当仅使用特定方法时，双端队列可以模拟栈或队列的行为。
摘要由CSDN通过智能技术生成

选一个简单的数据结构聊一聊，话说有很多数据结构都在玩组合拳，比如说：块状链表，块状数组，当然还有本篇的双端队列，是的，它就是

栈和队列的组合体。

一：概念

     我们知道普通队列是限制级的一端进，另一端出的FIFO形式，栈是一端进出的LIFO形式，而双端队列就没有这样的限制级，也就是我们可以在

队列两端进行插入或者删除操作。

二：编码

1：定义结构体

    通常情况下，队列的内部都是采用数组来实现，而且带有两个指针head和tail来指向数组的区间段，为了充分利用数组空间，我们也会用%来实

现逻辑上的循环数组，如下图。

 

public class MyQueue
{
    public int head;

    public int tail;

    public int maxSize;

    public int size;

    public T[] list;

    public MyQueue()
    {
        head = tail = size = 0;
        maxSize = 3;
        list = new T[maxSize];
    }
}

 

这里有一个注意的细节就是“size字段“，它是为了方便统计队列是否为满或者队列是否为空。

2：队尾入队

    刚才也说了，双端队列是可以在队列的两端进行插入和删除的，要注意的是我们用head和tail指针的时候，tail指针是指向元素的下一个位置，

而head指针是指向当前元素，所以我们可以从tail端push数据的时候只要”顺时针“下移一个位置即可。

/// <summary>
/// 队尾入队
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public bool Push_Tail(T t)
{
    //判断队列是否已满
    if (myQueue.size == myQueue.list.Length)
        return false;

    myQueue.list[myQueue.tail] = t;

    //顺时针旋转
    myQueue.tail = (myQueue.tail + 1) % myQueue.maxSize;

    myQueue.size++;

    return true;
}

 


3：队尾出队

    和队尾入队一样，我们只要将tail指针”逆时针“下移一个位置，当然有一个细节需要注意，就是tail指针有存在负值的情况，毕竟我们是做”--操作“的，

所以需要tail+maxSize，即：myQueue.tail = (--myQueue.tail + myQueue.maxSize) % myQueue.maxSize;

/// <summary>
/// 队尾出队
/// </summary>
/// <param name="edges"></param>
/// <param name="t"></param>
public T Pop_Tail()
{
    //判断队列是否已空
    if (myQueue.size == 0)
        return default(T);

    //逆时针旋转(防止负数)
    myQueue.tail = (--myQueue.tail + myQueue.maxSize) % myQueue.maxSize;

    var temp = myQueue.list[myQueue.tail];

    //赋予空值
    myQueue.list[myQueue.tail] = default(T);

    myQueue.size--;

    return temp;
}

 

4：队首入队

    从head端来说，我们push数据的时候是head指针“逆时针”旋转，要注意的是同样要防止负数的产生，并且head指针是指向当前元素。

/// <summary>
/// 队首入队
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public bool Push_Head(T t)
{
    //判断队列是否已满
    if (myQueue.size == myQueue.list.Length)
        return false;

    //逆时针旋转(防止负数产生)
    myQueue.head = (--myQueue.head + myQueue.maxSize) % myQueue.maxSize;

     //赋予元素
     myQueue.list[myQueue.head] = t;

     myQueue.size++;

     return true;
 }

 

 

5：队首出队

    说到这个方法，我想大家应该都懂了双端队列的大概流程了，这个方法我也不用赘叙了。

/// <summary>
/// 队首出队
/// </summary>
/// <param name="edges"></param>
/// <param name="t"></param>
public T Pop_Head()
{
    //判断队列是否已空
    if (myQueue.size == 0)
        return default(T);

    //获取队首元素
    var temp = myQueue.list[myQueue.head];

    //原来单位的值赋默认值
    myQueue.list[myQueue.head] = default(T);

    //顺时针旋转
    myQueue.head = (myQueue.head + 1) % myQueue.maxSize;

    myQueue.size--;

    return temp;
}

 

从上面的四个方法可以看出：

 

当我们只使用Push_Tail和Pop_Tail的话，那它就是栈。

当我们只使用Push_Tail和Pop_Head的话，那它就是队列。

最后是全部代码：

 

using System.Net;
using System;
using System.IO;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;

class Program
{
    static void Main(string[] args)
    {
        DoubleQueue<int> queue = new DoubleQueue<int>();

        queue.Push_Tail(10);
        queue.Push_Tail(20);
        queue.Push_Tail(30);

        queue.Pop_Tail();
        queue.Pop_Tail();
        queue.Pop_Tail();

        queue.Push_Tail(10);
        queue.Push_Head(20);
        queue.Push_Head(30);
        queue.Push_Head(30);

        queue.Pop_Tail();
        queue.Pop_Tail();
        queue.Pop_Head();

        queue.Push_Head(40);
        queue.Push_Tail(50);
        queue.Push_Tail(60);
    }
}

/// <summary>
/// 双端队列
/// </summary>
public class DoubleQueue<T>
{
    public class MyQueue
    {
        public int head;

        public int tail;

        public int maxSize;

        public int size;

        public T[] list;

        public MyQueue()
        {
            head = tail = size = 0;
            maxSize = 3;
            list = new T[maxSize];
        }
    }

    MyQueue myQueue = new MyQueue();

    /// <summary>
    /// 队尾入队
    /// </summary>
    /// <param name="t"></param>
    /// <returns></returns>
    public bool Push_Tail(T t)
    {
        //判断队列是否已满
        if (myQueue.size == myQueue.list.Length)
            return false;

        myQueue.list[myQueue.tail] = t;

        //顺时针旋转
        myQueue.tail = (myQueue.tail + 1) % myQueue.maxSize;

        myQueue.size++;

        return true;
    }

    /// <summary>
    /// 队尾出队
    /// </summary>
    /// <param name="edges"></param>
    /// <param name="t"></param>
    public T Pop_Tail()
    {
        //判断队列是否已空
        if (myQueue.size == 0)
            return default(T);

        //逆时针旋转(防止负数)
        myQueue.tail = (--myQueue.tail + myQueue.maxSize) % myQueue.maxSize;

        var temp = myQueue.list[myQueue.tail];

        //赋予空值
        myQueue.list[myQueue.tail] = default(T);

        myQueue.size--;

        return temp;
    }

    /// <summary>
    /// 队首入队
    /// </summary>
    /// <param name="t"></param>
    /// <returns></returns>
    public bool Push_Head(T t)
    {
        //判断队列是否已满
        if (myQueue.size == myQueue.list.Length)
            return false;

        //逆时针旋转(防止负数产生)
        myQueue.head = (--myQueue.head + myQueue.maxSize) % myQueue.maxSize;

        //赋予元素
        myQueue.list[myQueue.head] = t;

        myQueue.size++;

        return true;
    }

    /// <summary>
    /// 队首出队
    /// </summary>
    /// <param name="edges"></param>
    /// <param name="t"></param>
    public T Pop_Head()
    {
        //判断队列是否已空
        if (myQueue.size == 0)
            return default(T);

        //获取队首元素
        var temp = myQueue.list[myQueue.head];

        //原来单位的值赋默认值
        myQueue.list[myQueue.head] = default(T);

        //顺时针旋转
        myQueue.head = (myQueue.head + 1) % myQueue.maxSize;

        myQueue.size--;

        return temp;
    }
}

 

AI算法网奇
关注
专栏目录
订阅专栏
数据结构之循环双端队列
weixin_48492905的博客
11-04 1579
循环双端队列和循环队列在实现上几乎是一样的，需要注意的有以下几点： 1、定义循环变量 front 和 rear 。一直保持这个定义，到底是先赋值还是先移动指针就很容易想清楚了。 ① front：指向队列头部第 1 个有效数据的位置； ② rear：指向队列尾部（即最后 1 个有效数据）的下一个位置，即下一个从队尾入队元素的位置。 2、为了避免“队列为空”和“队列为满”的判别条件冲突，我们有意浪费了一个位置。浪费一个位置是指：循环数组中任何时刻一定至少有一个位置不存放有效元素。 上图所示情况，我们就可以判定
双端队列
MAX__YF的博客
04-01 299
deque 即双端队列 （deque，全名double-ended queue）是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。 结构体定义及初始化 typedef int T; typedef struct DoubleQuene { T data[MAXSIZE]; int front;//头位置 int rear;//尾位置 }*...
数据结构(3.7)——双端队列
最新发布
m0_65240792的博客
07-03 455
只允许两端插入、两端删除的线性表。双端队列（Double Ended Queue, 简称 DEQUEUE 或 deque）是一种允许从两端插入和删除的线性数据结构。它是一种特殊的队列，可以在两端进行操作，这意味着它既可以从队尾入队和出队，也可以从队头入队和出队。双端队列在功能上相当于队列和栈的混合体，因为它可以用来实现队列和栈的某些操作。双端队列的重要特性包括：双端队列的主要操作包括：双端队列可以用数组或链表来实现。数组实现的双端队列可以在常数时间内在两端进行操作，但是如果数组满了需要扩容，这可能需要O(n
数据结构与算法（双端队列）
weixin_62173637的博客
01-14 139
1.接口 ​ package p1.接口; public interface Queue<E> extends Iterable<E> { public void offer(E element); //入队 public E poll(); //出队 public E peek(); //查看队首元素 public boolean isEmpty(); public void clear(); public in
数据结构与算法笔记（五）——队列(FIFO队列、双端队列)
别呀的博客
09-15 8263
一、FIFO队列 1.1、概念 队列(queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出的(First In First Out)的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q= (a1，a2，…，an)，那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然排在队伍最后。 1.2、队
数据结构与算法 全 数据结构与算法全 Java
03-04
### 数据结构与算法详解 #### 一、初识算法 **1.1 什么是算法？** 算法是指解决问题的一系列步骤或...以上内容涵盖了从算法基础到高级数据结构和算法的各个方面，旨在帮助读者深入理解和掌握这些核心概念和技术。
【数据结构】12.双端队列的实现
weixin_46955173的博客
01-14 714
一、双端队列的定义 双端队列（double ended queue ，deque） 是限定插入和删除操作在表的两端进行的线性表 是一种具有队列和栈的性质的数据结构 总的来说就是在循环队列的基础上让其无论在头部还是尾部都可以进行增删 从而可以同时实现队列合栈的全部功能 二、Deque双端队列接口的定义 双端队列大致思想与循环队列一样 无非在队首可添加，在队尾可删除 public interface Dequeue<E> extends Queue<E> {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值