算法与数据结构_队列

最新推荐文章于 2024-08-18 21:07:18 发布
最新推荐文章于 2024-08-18 21:07:18 发布
阅读量108 收藏
点赞数
分类专栏： 学习C++ 文章标签： 队列 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41943808/article/details/118227936
版权

队列

一、如何理解“队列”？

  1. 队列是一种操作受限的线性表数据结构。
  2. 队列最大的特点就是先进先出 (First In First Out,FIFO)。
  3. 最基本的操作：入队，放一个数据到队列尾部；出队，从队列头部取一个元素。

二、顺序队列和链式队列

  1. 用数组实现的队列叫顺序队列，用链表实现的队列叫链式队列。
  2. 队列需要两个指针：一个是 head 指针，指向队头；一个是 tail 指针，指向队尾。
  3. 随着不停地进行入队、出队操作，head 和 tail 都会持续往后移动。当 tail 移动到最右边，即使数组中还有空闲空间，也无法继续往队列中添加数据了。
    实际上，我们在出队时可以不用搬移数据。如果没有空闲空间了，只需要在入队时，再集中触发一次数据的搬移操作。出队函数 dequeue() 保持不变，我们稍加改造一下入队函数 enqueue() 的实现，当队列的 tail 指针移动到数组的最右边后，如果有新的数据入队，我们可以将 head 到 tail 之间的数据，整体搬移到数组中 0 到 tail-head 的位置。
  4. 基于链表的实现，同样需要两个指针：head 指针和 tail 指针。分别指向链表的第一个结点和最后一个结点。入队时，tail->next= new_node, tail = tail->next；出队时，head = head->next。
//JAVA实现
// 用数组实现的队列
public class ArrayQueue {
  // 数组：items，数组大小：n
  private String[] items;
  private int n = 0;
  // head表示队头下标，tail表示队尾下标
  private int head = 0;
  private int tail = 0;

  // 申请一个大小为capacity的数组
  public ArrayQueue(int capacity) {
    items = new String[capacity];
    n = capacity;
  }

  // 入队
  public boolean enqueue(String item) {
    // 如果tail == n 表示队列已经满了
    if (tail == n) return false;
    items[tail] = item;
    ++tail;
    return true;
  }

  // 出队
  public String dequeue() {
    // 如果head == tail 表示队列为空
    if (head == tail) return null;
    // 为了看的更加明确，把--操作放到单独一行来写了
    String ret = items[head];
    ++head;
    return ret;
  }
}

//随着数字不断入队，head tail不断后移，最终队满，如何搬移数据让队列继续可用呢？
   // 入队操作，将item放入队尾
  public boolean enqueue(String item) {
    // tail == n表示队列末尾没有空间了
    if (tail == n) {
      // tail ==n && head==0，表示整个队列都占满了
      if (head == 0) return false;
      // 数据搬移
      for (int i = head; i < tail; ++i) {
        items[i-head] = items[i];
      }
      // 搬移完之后重新更新head和tail
      tail -= head;
      head = 0;
    }
    
    items[tail] = item;
    ++tail;
    return true;
  }

三、循环队列

  1. 循环队列，原本数组是有头有尾的，是一条直线。把首尾相连，扳成了一个环。

循环队列

  1. 在数组实现队列的时候，会有数据搬移操作，要想解决数据搬移的问题，需要像环一样的循环队列。

  2. 要想写出没有 bug 的循环队列的实现代码，最关键的是，确定好队空和队满的判定条件。

    1. 队列为空的判断条件仍然是 head == tail。
    2. 当队满时，(tail+1)%n=head。 tail 指向的位置实际上是没有存储数据的。所以，循环队列会浪费一个数组的存储空间。
    //JAVA 循环队列
public class CircularQueue {
  // 数组：items，数组大小：n
  private String[] items;
  private int n = 0;
  // head表示队头下标，tail表示队尾下标
  private int head = 0;
  private int tail = 0;

  // 申请一个大小为capacity的数组
  public CircularQueue(int capacity) {
    items = new String[capacity];
    n = capacity;
  }

  // 入队
  public boolean enqueue(String item) {
    // 队列满了
    if ((tail + 1) % n == head) return false;
    items[tail] = item;
    tail = (tail + 1) % n;
    return true;
  }

  // 出队
  public String dequeue() {
    // 如果head == tail 表示队列为空
    if (head == tail) return null;
    String ret = items[head];
    head = (head + 1) % n;
    return ret;
  }
}

四、阻塞队列和并发队列

  1. 阻塞队列

    1. 阻塞队列就是在队列基础上增加了阻塞操作。

    2. 在队列为空的时候，从队头取数据会被阻塞。因为此时还没有数据可取，直到队列中有了数据才能返回；如果队列已经满了，那么插入数据的操作就会被阻塞，直到队列中有空闲位置后再插入数据，然后再返回。

    3. 基于阻塞队列实现的“生产者 - 消费者模型”，可以有效地协调生产和消费的速度。

  2. 并发队列

    1. 线程安全的队列，叫作并发队列。
    2. 最简单直接的实现方式是直接在 enqueue()、dequeue() 方法上加锁，但是锁粒度大并发度会比较低，同一时刻仅允许一个存或者取操作。
    3. 实际上，基于数组的循环队列，利用 CAS 原子操作，可以实现非常高效的并发队列。这也是循环队列比链式队列应用更加广泛的原因。

五、线程池没有空闲线程时，新的任务请求线程资源时，线程池该如何处理？各种处理策略又是如何实现的呢？

一般有两种处理策略。

第一种是非阻塞的处理方式，直接拒绝任务请求；

另一种是阻塞的处理方式，将请求排队，等到有空闲线程时，取出排队的请求继续处理。

  1. 基于链表的实现方式，可以实现一个支持无限排队的无界队列（unbounded queue），但是可能会导致过多的请求排队等待，请求处理的响应时间过长。所以，针对响应时间比较敏感的系统，基于链表实现的无限排队的线程池是不合适的。
  2. 基于数组实现的有界队列（bounded queue），队列的大小有限，所以线程池中排队的请求超过队列大小时，接下来的请求就会被拒绝，这种方式对响应时间敏感的系统来说，就相对更加合理。不过，设置一个合理的队列大小，也是非常有讲究的。队列太大导致等待的请求太多，队列太小会导致无法充分利用系统资源、发挥最大性能。
    （除了前面讲到队列应用在线程池请求排队的场景之外，队列可以应用在任何有限资源池中，用于排队请求，比如数据库连接池等。实际上，对于大部分资源有限的场景，当没有空闲资源时，基本上都可以通过“队列”这种数据结构来实现请求排队。）

六、【思考】

Q: 除了线程池这种池结构会用到队列排队请求，你还知道有哪些类似的池结构或者场景中会用到队列的排队请求呢？

A:

Q: 今天讲到并发队列，关于如何实现无锁并发队列，网上有非常多的讨论。对这个问题，你怎么看呢？

A:

说实话现在我还不太懂，这些名词都还没接触过。。。空着吧

习题

设计循环双端数组(LC:641)

LC:641——设计循环双端数组

//首先想到双端链表，创建一个头几点head 一个尾节点tail；
// he  ->  ta
// ad  <-  il
//初始化：头指向尾，尾指向头 新的节点就在中间操作，靠近头的部分以头为基准。靠近尾的部分以尾为基准
//同时维护一个统计队列元素个数的Dsize();
//维护一个队列内最大元素个数max_Dsize;
//在操作之前首先判断队是否满，是否空，然后在操作。
//我承认非常粗糙。。但是写的时候印象很深刻
class MyCircularDeque {
private:
    struct ListNode{
        int val;
        ListNode* next;
        ListNode* pre;
        ListNode(ListNode* node):val(node->val),next(node->next),pre(node->pre){}
        ListNode():val(-1),next(nullptr),pre(nullptr){}
        ListNode(int x):val(x),next(nullptr),pre(nullptr){}
        ListNode(int x,ListNode* pre, ListNode* next):val(x),pre(pre),next(next){}
    };
    int Dsize = 0;
    int max_Dsize;

public:
    ListNode* tail;
    ListNode* head;
    /** Initialize your data structure here. Set the size of the deque to be k. */
    MyCircularDeque(int k) {
        max_Dsize = k;
        head = new ListNode();
        tail = new ListNode();
        head->next = tail;
        tail->pre = head;
    }
    
    /** Adds an item at the front of Deque. Return true if the operation is successful. */
    bool insertFront(int value) {
        if(Dsize == max_Dsize) return false;
        ListNode* temp = new ListNode(value);
        head->next->pre = temp;
        temp->next = head->next;
        head->next = temp;
        temp->pre = head;
        Dsize++;
        return true;
    }
    
    /** Adds an item at the rear of Deque. Return true if the operation is successful. */
    bool insertLast(int value) {
        if(Dsize == max_Dsize) return false;
        ListNode* temp = new ListNode(value);
        tail->pre->next = temp;
        temp->pre = tail->pre;
        tail->pre = temp;
        temp->next = tail;
        Dsize++;
        return true;
    }
    
    /** Deletes an item from the front of Deque. Return true if the operation is successful. */
    bool deleteFront() {
        if(Dsize == 0) return false;
        auto temp = head->next;
        head->next = temp->next;
        temp->next->pre = head;
        //delete temp;
        Dsize--;
        return true;
    }
    
    /** Deletes an item from the rear of Deque. Return true if the operation is successful. */
    bool deleteLast() {
        if(Dsize == 0) return false;
        ListNode* temp = tail->pre;
        temp->pre->next = tail;
        tail->pre = temp->pre;
        Dsize--;
        return true;
    }
    
    /** Get the front item from the deque. */
    int getFront() {
        return head->next->val;
    }
    
    /** Get the last item from the deque. */
    int getRear() {
        return tail->pre->val;
    }
    
    /** Checks whether the circular deque is empty or not. */
    bool isEmpty() {
        return Dsize == 0;
    }
    
    /** Checks whether the circular deque is full or not. */
    bool isFull() {
        return Dsize == max_Dsize;
    }
};

/**
 * Your MyCircularDeque object will be instantiated and called as such:
 * MyCircularDeque* obj = new MyCircularDeque(k);
 * bool param_1 = obj->insertFront(value);
 * bool param_2 = obj->insertLast(value);
 * bool param_3 = obj->deleteFront();
 * bool param_4 = obj->deleteLast();
 * int param_5 = obj->getFront();
 * int param_6 = obj->getRear();
 * bool param_7 = obj->isEmpty();
 * bool param_8 = obj->isFull();
 */

//循环数组，这个高级，高效
class MyCircularDeque {
public:
    /** Initialize your data structure here. Set the size of the deque to be k. */
    MyCircularDeque(int k):size(k+1) {
        head = 0;
        tail = 0;
        arr = new int[size];
    }
    ~MyCircularDeque(){
        delete[] arr;
    }
    /** Adds an item at the front of Deque. Return true if the operation is successful. */
    bool insertFront(int value) {
        if(!isFull()){
            if(isEmpty()){
                arr[head] = value;
                tail = (tail+1)%size;
                // head = (head-1+size)%size;
            }else{
                head = (head-1+size)%size;
                arr[head] = value;
            }
            return true;
        }else
            return false;
    }
    
    /** Adds an item at the rear of Deque. Return true if the operation is successful. */
    bool insertLast(int value) {
        if(!isFull()){
            arr[tail] = value;
            tail = (tail+1)%size;
            return true;
        }else
            return false;
    }
    
    /** Deletes an item from the front of Deque. Return true if the operation is successful. */
    bool deleteFront() {
        if(!isEmpty()){
            head = (head+1)%size;
            return true;
        }else
            return false;
    }
    
    /** Deletes an item from the rear of Deque. Return true if the operation is successful. */
    bool deleteLast() {
        if(!isEmpty()){
            tail = (tail-1+size)%size;
            return true;
        }else
            return false;
    }
    
    /** Get the front item from the deque. */
    int getFront() {
        if(!isEmpty()){
            return arr[head];
        }else
            return -1;
    }
    
    /** Get the last item from the deque. */
    int getRear() {
        if(!isEmpty()){
            return arr[(tail-1+size)%size];
        }else
            return -1;
    }
    
    /** Checks whether the circular deque is empty or not. */
    bool isEmpty() {
        if(head == tail) 
            return true;
        else
            return false;
    }
    
    /** Checks whether the circular deque is full or not. */
    bool isFull() {
        if((tail+1)%size == head){
            // cout<<tail<<" "<<head<<endl;
            return true;
        }
        else 
            return false;
    }
private:
    int head;
    int tail;
    int size;
    int* arr;
};

/**
 * Your MyCircularDeque object will be instantiated and called as such:
 * MyCircularDeque* obj = new MyCircularDeque(k);
 * bool param_1 = obj->insertFront(value);
 * bool param_2 = obj->insertLast(value);
 * bool param_3 = obj->deleteFront();
 * bool param_4 = obj->deleteLast();
 * int param_5 = obj->getFront();
 * int param_6 = obj->getRear();
 * bool param_7 = obj->isEmpty();
 * bool param_8 = obj->isFull();
 */

困难题，摇了我吧。明天再看

滑动窗口最大值(LC:239)

LC:239——滑动窗口最大值

Krifood
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法 -- 队列
u012967763的专栏
08-21 1663
一点一滴学算法，算法从入门到放弃。
数据结构与算法---队列
qq_33626996的博客
11-24 250
数据结构与算法—队列 1. 队列的定义： 队列（Queue ）简称队，是一种操作受限制 的线性表 ，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队或进队； 删除元素称为出队或离队。操作特性是先进先出（First In First Out，FIFO）。 队头（Front）：允许删除的一端； 队尾（Rear）：允许插入的一端。 空队列：不含任何元素的空表。 2. 队列的顺序存储： 队列的顺序实现是指分配一块连续的存储单元存放队列中的元素，并附设两个指针：队头指针front指向队
算法与数据结构（队列）
lsh199067的博客
08-25 117
队列（queue）： 先进先出。队列的2个基本操作： 1，入队：enqueue，放一个元素到队列尾部。 2，出队：dequeue，从队列头部取一个元素。 实现队列的2种方式： 1，顺序队列：用数组实现 private String[] data;//存数据的数组 private int size;//容量 private int head = 0;//头部位置 private int tail = 0;//尾部诶之 public ArrayQueue(i...
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
【解决】 Visual Studio 2019 调用Python文件
风仁无幻
07-24 5798
【解决】 Visual Studio 2019 调用Python文件 很累了，直入主题。我想在visual Studio中调用一个python文件，完成绘图，数据统计处理等工作 (毕竟Python天天杀死Excel)。 不太懂Python，网上查了很多很多教程，有的有用，有的没用，这两天干了很多无用功，好在是最后成功了。记录一下踩坑过程。 如果您的python已经安装好并且成功进行过python代码调试的话，可以直接跳到vs环境的配置。 Python的安装 首先，建议一定要从官网下载安装包进行安装！！！ 务
算法基础(ACWing)
风仁无幻
09-08 580
算法基础 基础算法 快速排序 快速排序，背一背板子。 一点心得: 快速排序不是稳定算法 快速排序时间复杂度O(nlogn),空间复杂度是O(longn)虽然没有开辟新的空间但是递归占用了栈空间。 主要的优化就是在排序过程中基准数的选择上，单纯固定取左右端点在面对有序数组时时间复杂度将退化为O(n^2)类似冒泡 可以使用取中间值法，或者左右端点中间及中间的数三数中去中位数的方法，或者每次使用区间内的的随机数，但是会增大不稳定性 还有就是，数据量输入比较大的时候用scanf，小的话可以用cin。 #inc
【笔记】C++库函数——bitset
风仁无幻
04-22 421
【笔记】C++库函数——bitset 看到有大佬掏出这个库函数，一愣。这绝对是未曾想象过的道路，长见识。有时候做题总能碰见稀奇古怪的库函数，每个都令我大开眼界。以后看到感兴趣的都会记录一下，感觉是个好东西，算是学习道路上的小小积累吧，抓紧记录一下。 头文件 #include <bitset> using std::bitset; 定义与初始化 bitset<n> b; //b有n位，每位都是0 bitset<n> b(u); //b是unsigned long型
【算法】KMP算法学习
风仁无幻
04-25 261
【算法】KMP算法学习 由三位大佬D.E.Knuth、J.H.Morris、V.R.Pratt同时发现，取三人名字命名KMP 其实就是一种改进的字符串匹配算法，关键是利用匹配后失败的信息，尽量减少模式串(W)与主串(T)的匹配次数以达到快速匹配的目的。 KMP算法利用已经部分匹配这个有效信息，保持 i 指针不回溯，通过修改 j 指针，让模式串尽量地移动到有效的位置。 孤~影 博客 为什么位置 k 是 j 需要回溯的位置？（废话一样的证明） 参考如下例子： 主串： a b c a b c d h i
算法与数据结构_链表
风仁无幻
06-22 258
链表 一、理解指针或引用的含义 含义：将某个变量（对象）赋值给指针（引用），实际上就是就是将这个变量（对象）的地址赋值给指针（引用）。 示例： p—>next = q; 表示p节点的后继指针存储了q节点的内存地址。 p—>next = p—>next—>next; 表示p节点的后继指针存储了p节点的下下个节点的内存地址。 二、警惕指针丢失和内存泄漏（单链表） 插入节点 在节点a和节点b之间插入节点x，b是a的下一节点，，p指针指向节点a，则造成指针丢失和内存泄漏的代码：p—&g
算法与数据结构_栈
风仁无幻
06-24 239
栈 一、什么是栈？ 特点总结为先进后出，后进先出 就是**“First In Last Out (FILO)”**这就是典型的“栈”结构。 从其操作特性来看，栈是一种“操作受限”的线性表，它只允许从一端进行数据的插入与移除。 二、 既然栈不如链表、数组灵活，为什么要用？ 栈是一种操作受限的数据结构，其操作特性用数组和链表均可实现。 正因为栈没有数组、链表那样灵活，他暴露出来的接口越少，就越安全。不会很容易出现操作错误 特性之所以称为特性，就是因为有特殊的应用场景。当一个数据集只涉及在某端进行数据的插
LC516.最长回文子串问题
风仁无幻
08-12 170
LC:516.最长回文子串问题 原题链接 题目： 给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。 子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。 示例1: 输入：s = "bbbab" 输出：4 解释：一个可能的最长回文子序列为 "bbbb" 。 今天看到最醍醐灌顶的一句话 看清dp的本质是带有记事本的暴力循环，只是打表通过状态转移加以剪枝罢了，不是什么很高超的技巧。 共勉。 定义状态dp[i][j] 表示下标i,j之间的字符串的最大回
[笔记]BFS——两天做了三道题。。。
风仁无幻
06-27 113
BFS——两天做了三道题。。。 好像是涉及图论了，太高深的不懂，记录下做题过程。 BFS简单理解,重点如下几步： 从起点状态搜到终点状态(队列实现) 初始化 把起点状态压入列表。 更新过程：当队列不为空时，每次从队首取一个元素作为这次搜索的起点，当前状态下的每次搜索得到的新合法状态压入队尾，用于下次更新。 题目里有死路的情况，死路就是非法状态，直接跳过。那如果遇到以前重复过的状态呢？那也是非法状态，因为已经重复过的路不会再搜到新的合法状态，所以也略过。(略过是用哈希表实现的，每次在哈希表里查一下是否曾经
C语言 | Leetcode C语言题解之第337题打家劫舍III
m0_59237910的博客
08-15 353
C语言 | Leetcode C语言题解之第337题打家劫舍III
C++匿名函数lamba简介
yao_tao11的博客
08-18 541
Lambda 表达式是 C++11 引入的一个功能，允许你在代码中定义匿名函数（即没有名字的函数）。这种表达式可以用于简化函数对象的定义，并使得代码更简洁。Lambda 表达式特别适用于局部的、一次性的函数对象，如用于 STL 算法中。捕获方式含义[ ]空捕获列表，Lambda不能使用所在函数中的变量.[names]names是一个逗号分隔的名字列表，这些名字都是Lambda所在函数的局部变量。默认情况下，这些变量会被拷贝，然后按值传递，名字前面如果使用了&，则按引用传递[&]
c++编程（22）——STL（6）set
2301_77239666的博客
08-16 1063
欢迎来到博主的专栏——c++编程博主ID：代码小豪。
【漫谈C语言和嵌入式011】嵌入式系统中常用的校验方式
最新发布
2403_83044722的博客
08-18 492
在嵌入式系统中，选择合适的校验方式取决于应用场景的需求。简单的数据传输可以使用奇偶校验或校验和，而对于更复杂、更可靠的数据传输，CRC和汉明码则是更好的选择。
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 357
C++ | Leetcode C++题解之第337题打家劫舍III
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值