精华内容
下载资源
问答
  • deque双向队列

    2017-06-20 12:46:07
    deque双向队列 对于双向队列,与队列queue以及vector容器的区别就在于,名字不同,...头文件: #include 函数: 构造/析构  dequeq 构造一个空的双向队列  dequeq(q1) 构造q,并复制q1  dequeq(n) 

    deque双向队列

    对于双向队列,与队列queue以及vector容器的区别就在于,名字不同,也就是它是双向的,可以从头开始操作,也可以从末尾开始操作。

    双向队列的常用方法跟队列queue差不多:

     

    头文件: #include<deque>

    函数:

    构造/析构

      deque<int>q  构造一个空的双向队列

      deque<int>q(q1)  构造q,并复制q1

      deque<int>q(n)  创建deque,含有n个数据,数据均由缺省构造函数产生

      deque<int>q(beg,end)  创建一个以[beg,end)区间的deque

      q.~deque<int>()  销毁所有的数据,释放内存

    赋值

      q.assign(beg,end)  将[beg,end)区间中的数据赋值给q

      q.assign(n,int)  将n个int 的拷贝值给q

    数据访问

      q.at(idx)  返回索引 idx 所指的数据,如果 idx 越界,抛出 out_of_range

      q.fron()  返回第一个数据

      q.back()  返回最后一个数据

      q.begin() 返回指向第一个数据的迭代器

      q.end()  返回指向最后一个数据的下一个位置的迭代器

      q.rbegin() 返回逆向队列的第一个数据

      q.rend() 返回指向逆向队列的最后一个数据的下一个位置的迭代器

    加入数据

      q.push_back()  在尾部加入一个数据

      q.push_front()  在头部插入一个数据

      q.insert(pos,int) 在pos 位置插入一个 int 数据的拷贝 ,返回新数据位置

      q.insert(pos,n,int) 在pos 位置插入n 个 int 数据 ,无返回值

      q.insert(pos,beg,end) 在pos位置插入在 [beg,end)区间的数据,无返回值

    删除数据

      q.pop_back() 删除最后一个数据

      q.pop_front()  删除头部数据

      q.erase(pos) 删除pos位置的数据 ,返回下一个数据的位置

      q.erase(beg,end) 删除[begin,end) 区间的数据,返回下一个数据的位置

    其他操作

      q.empty()  判断容器是否为空

      q.max_size()   返回容器中最大数据的数量

      q.resize(num)  重新制定队列的长度

      q.size()  返回容器中实际数据的个数

      q.swap(q1)  将q和q1的元素互换

      swap(q,q1)  同上

        

      出处:http://www.cnblogs.com/jaydenouyang/p/6818251.html

    展开全文
  • 栈,队列,双向队列

    2021-03-23 10:25:51
    栈,队列,双向队列 栈:对于栈,有着较为简单的描述,即只可以从栈的最后面来进行进栈和出栈的操作,先进后出,后进先出。 头文件#include < stack > 定义方法:stack<栈中元素类型>栈的名字(这里为了...

    栈,队列,双向队列

    栈:对于栈,有着较为简单的描述,即只可以从栈的最后面来进行进栈和出栈的操作,先进后出,后进先出。

    头文件#include < stack >
    定义方法:stack<栈中元素类型>栈的名字(这里为了之后方便,将名字定义为sta)
    进栈操作:sta.push(元素) 放在栈的最后
    出栈操作:sta.pop() 将栈的最后一个元素弹出
    返回栈的最后一个元素:sta.top()
    判断栈是否为空:sta.empty()==true(为空)sta.empty()=false(不为空)
    返回栈元素个数:sta.size()

    队列:队列也是一种比较简单的方法,分为双向和单向队列,这里主要描述单向,队列是一种先进先出,后进后出的操作。

    头文件#include < queue >
    定义方法:queue<对列中元素类型>队列的名字(这里为了之后方便,将名字定义为que)
    进队列操作:que.push(元素) 放在队列的最后
    出队列操作:que.pop() 将对列的第一个元素弹出
    返回队列的最后一个元素:que.back()
    返回队列的第一个元素:que.front()
    判断队列是否为空:que.empty()==true(为空)que.empty()=false(不为空)
    返回队列元素个数:que.size()

    双向队列:双向对列是一种非常方便的方法,基本包含了栈与队列所需要的所有操作,可以任意进队列和弹出

    头文件#include < deque >
    定义方法deque<对列中元素类型>队列的名字(这里为了之后方便,将名字定义为deq)
    在队列最前面压入元素deq.push_front()
    在队列最后面压入元素deq.push_back()
    将对列最后面的元素弹出deq.pop_back()
    将对列最前面的元素弹出deq.pop_front()
    返回队列最前面的元素deq.front()
    返回对列最后面的元素deq.back()
    判断队列是否为空:deq.empty()==true(为空)deq.empty()=false(不为空)
    返回队列元素个数:deq.size()

    展开全文
  • STL 中队列的使用(queue) 基本操作: push(x) 将x压入队列的末端 pop() 弹出队列的第一个元素(队顶元素),注意此函数并不返回任何值 front() 返回第一个元素(队顶元素) ...头文件:#include &lt;queu...

    STL 中队列的使用(queue)

    基本操作:

    push(x) 将x压入队列的末端

    pop() 弹出队列的第一个元素(队顶元素),注意此函数并不返回任何值

    front() 返回第一个元素(队顶元素)

    back() 返回最后被压入的元素(队尾元素)

    empty() 当队列为空时,返回true

    size() 返回队列的长度

     

    使用方法:

    头文件:#include <queue>

    声明方法:

    1、普通声明:

    queue<int> q;

    2、结构体

    struct node
    {    
       int x, y;
    };
    queue<node>q;

    使用示例:

    #include <queue>
    #include <iostream>
    using namespace std;
    int main()
    {
        queue <int> q;//定义队列
        q.push(1);//入队,即插入元素
        q.push(2);
        q.push(3);
        q.push(9);//返回队例元素数量
        cout<<q.size()<<endl;
        cout<<q.empty()<<endl;//判断队列是否为空
        cout<<q.front()<<endl;//读取队首元素
        cout<<q.back()<<endl;//读取队尾元素
        while(q.empty()!=true)//所有元素出列,即删除所有元素
        {
            cout<<q.front()<<"  ";
            q.pop();//删除队首元素
        }
        cout<<endl;
        return 0;
    }

    STL 中优先队列的使用方法(priority_queu)

    优先队列容器与队列一样,只能从队尾插入元素,从队首删除元素。但是它有一个特性,就是队列中最大的元素总是位于队首,所以出队时,并非按照先进先出的原则进行,而是将当前队列中最大的元素出队。这点类似于给队列里的元素进行了由大互小的顺序排序。元素的比较规则默认按元素值由大到小排序,可以重载“<”操作符来重新定义比较规则。  

    基本操作:

    empty() 如果队列为空返回真

    pop() 删除对顶元素

    push() 加入一个元素

    size() 返回优先队列中拥有的元素个数

    top() 返回优先队列对顶元素

    在默认的优先队列中,优先级高的先出队。在默认的int型中先出队的为较大的数。

    使用方法:

    头文件:

      #include <queue>

    声明方式:

    1、普通方法:

    priority_queue<int>q;   //通过操作,按照元素从大到小的顺序出队
    
    priority_queue<int,vector<int>, greater<int> >q;  //通过操作,按照元素从小到大的顺序出队

    2、自定义优先级:

    struct cmp {     
      operator bool ()(int x, int y)     
      {        
         return x > y; // x小的优先级高       //也可以写成其他方式,如: return p[x] > p[y];表示p[i]小的优先级高
      }
    
    };
    priority_queue<int, vector<int>, cmp>q;    //定义方法
    //其中,第二个参数为容器类型。第三个参数为比较函数。

    3、结构体声明方式:

    struct node {     
      int x, y;     
      friend bool operator < (node a, node b)     
      {         
        return a.x > b.x;    //结构体中,x小的优先级高     
      }
    };

    priority_queue<node>q;   //定义方法

    //在该结构中,y为值, x为优先级。

    //通过自定义operator<操作符来比较元素中的优先级。

    //在重载”<”时,最好不要重载”>”,可能会发生编译错误、

    #include <iostream>
    #include <queue>
    using namespace std;
    int main()
    {
        priority_queue<float> q;
        q.push(66.6);
        q.push(22.2);
        q.push(44.4);
        cout << q.top() << ' ';
        q.pop();
        cout << q.top() << endl;
        q.pop();
        q.push(11.1);
        q.push(55.5);
        q.push(33.3);
        q.pop();
        while (!q.empty()) {
            cout << q.top() << ' ';
            q.pop();
        }    cout << endl;
    
    }

    如果优先队列的元素类型是结构体,可以通过在结构体中重载“<“操作符的方法来修改优先队列的优先性。

    #include <queue>
    #include <string>
    #include <iostream>
    using namespace std;
    struct info
    {
        string name;
        float score;
        bool operator < (const info &a) const
        {//按照score由小到大进行排列,如果要使用由大到小,使用“>”即可
            return a.score<score;
        }
    };
    int main()
    {
        priority_queue <info> pq;
        info in;
        in.name="Jack";
        in.score=68.5;
        pq.push(in);
        in.name="Bomi";
        in.score=18.5;
        pq.push(in);
        in.name="Peti";
        in.score=90;
        pq.push(in);
        while(!pq.empty())
        {
            cout<<pq.top().name<<": "<<pq.top().score<<endl;
            pq.pop();
        }
        return 0;
    }

    STL栈

    基本操作:

    s.empty()//如果栈为空返回true,否则返回false  
    s.size()//返回栈中元素的个数  
    s.pop()//删除栈顶元素但不返回其值  
    s.top()//返回栈顶的元素,但不删除该元素  
    s.push(X)//在栈顶压入新元素 ,参数X为要压入的元素

    使用方法:

    头文件:

    #include<stack>//栈

     声明方法:

    1、普通声明

    stack<int>  s;//参数也是数据类型,这是栈的定义方式

    2、结构体

    struct node
    {    
       int x, y;
    };
    stack<node>  s;

     

    双向队列

    展开全文
  • C++ 双向队列

    2020-03-17 19:02:26
    要使用 deque,需要包含头文件 deque。所有适用于 vector 的操作都适用于 deque。 deque 和 vector 有很多类似的地方。在 deque 中,随机存取任何元素都能在常数时间内完成。它相比于 vector 的优点是,vector 在...

    deque 也是顺序容器的一种,同时也是一个可变长数组。要使用 deque,需要包含头文件 deque。所有适用于 vector 的操作都适用于 deque。

    deque 和 vector 有很多类似的地方。在 deque 中,随机存取任何元素都能在常数时间内完成。它相比于 vector 的优点是,vector 在头部删除或添加元素的速度很慢,在尾部添加元素的性能较好,而 deque 在头尾增删元素都具有较好的性能(大多数情况下都能在常数时间内完成)。它有两种 vector 没有的成员函数:

    void push_front (const T & val);  //将 val 插入容器的头部
    void pop_front();  //删除容器头部的元素
    
    展开全文
  • STL之双向队列

    2020-01-15 15:41:50
    双端队列(dequeue) 采用线性表顺序存储结构,且支持随机访问,即可以直接用下标来访问元素,顾名思义其是双向开口,可以快速在首尾插入、删除数据。 其头文件是<deque>,主要包含函数: push_back():在队尾压...
  • STL中的双向队列deque

    2019-04-15 08:40:46
    1.STL中的双向队列deque deque也是顺序容器的一种,同时也是一个可变长数组。要使用deque,需要包含头文件deque。所有适用于vector的操作都适用于deque。 deque和vector有很多类似的地方。在deque中,随机存取任何...
  • 线性表和栈分别是顺序存储结构和链式存储结构的代表,而队列和栈可以用以上两种数据结构进行表达,不过是把它们的成员函数加一改动,主要是限制为先进先出和后进先出的功能,本文主要介绍队列的顺序存储结构,这里...
  • 要使用 deque,需要包含头文件 deque。所有适用于 vector 的操作都适用于 deque。 deque 和vector有很多类似的地方。在 deque 中,随机存取任何元素都能在常数时间内完成(但慢于vector)。它相比于 vector 的优点...
  • 头文件:#include&lt;deque&gt; (动态一维数组)定义:deque&lt;变量类型&gt; 变量名; 例:deque&lt;变量类型&gt; dq;特点:支持随机访问(数组访问下表从0开始;at方法访问,会抛出异常...
  • 双向循环队列

    千次阅读 2016-09-18 14:37:12
    相信有了前面的基础我们可以很容易的实现单向循环队列需要引入我的链表的list.c和list.h头文件// // double_queue.h // double_queue // // Created by bikang on 16/9/12. // Copyright (c) 2016年 bikang. All ...
  • 头文件 #include<deque> 用法 插入 头部插入 push_front 尾部插入 push_back() 插入元素elem到pos位置 iterator insert(pos,elem) 删除 删除头部的元素 pop_front() 删除尾部的元素 pop_back() ...
  • 栈,队列,单链表,双向链表

    千次阅读 2014-07-13 23:37:25
    定义头文件 实现栈方法的定义,注意这里用到了全局的静态数组,可以通过这种方式保护数据。 main.c,实现存储    ...队列 创建头文件queue.h 创建queue.c 实现main函数
  • 以下内容仅作为读书笔记 ...在C++标准中,STL有13个头文件,写C++程序时添加这些头文件就可以让我们方便地使用一些数据结构 1、 #include //栈的头文件 stackT,Type为数据类型,既可以是整形(int),浮点型(floa...
  • 队列

    2021-02-02 13:57:33
    直奔主题利用头文件,即这两行代码引入数据结构即可: #include<stack> #include<queue> #include<deque> // 双向队列 当然啦,如果想自己实现也挺简单的哈,可以参考我在第一篇文章推荐的教材...
  • STL之deque

    2016-06-20 18:04:23
    deque是双向队列 头文件是 #include 1.deque的基础构造函数template, class Allocator = allocator>class deque T是存储数据类型,Allocator指定分配器(默认是标准分配器)。deque的构造函数:explicit deque...
  • 1、定义头文件 实现栈方法的定义,注意这里用到了全局的静态...队列,创建头文件queue.h 创建queue.c 实现main函数 单链表 在定义头文件的时候,最好使用: #ifndef 变量A #define变量...
  • 使用deque之前需包含头文件: #include <deque> deque的内部结构 deque是一种优化了的对序列两端元素进行添加和删除操作的基本序列容器。通常由一些独立的区块组成,第一区块朝某方向扩展,最后一个区块朝...
  • C++队列

    2019-10-06 07:18:25
    C++队列 默认已熟悉std::vector。vector是一个极其重要的模板,其中的每一个函数都应该了解其作用与用法,这里不再赘述。 双向队列 双向队列(std::deque...使用时需加入头文件<deque> deque虽名为队列,但是...
  • 栈和队列

    2020-03-16 12:11:48
    1、头文件: #include//栈 #include//队列 #include双向队列 using namespace std; 2、定义: stack x; queue y; deque z; 3、操作: 栈: x.empty()//如果栈为空返回true,否则返回false x.size()//返回栈中元素的...
  • 单调队列入门

    2020-11-23 10:18:04
    文章目录单调队列单调队列是指:解题基本思想:实现方式:[\[模板题 滑动窗口问题 (洛谷 P1886)\]](https://www.luogu.com.cn/problem/P1886) ...deque 双向队列 (c++容器) 头文件#include < queue &
  • 实现了两种方式的队列,一种是顺序存储队列的实现,一种是链式存储的队列实现,代码中有针对两种实现方法的...两种实现方法函数在一个头文件中,顺序存储方式的函数名使用小写q开头,链式存储方式的函数使用大写Q开头
  • 链表实现的堆栈和队列

    千次阅读 2010-11-22 21:43:00
    头文件:#ifndef STACK_H_ #define STACK_H_ #include "d_list.h" byte StackInit(List *plist,word length); // 堆栈初始化 byte StackPush(List *plist,Item item); // 压栈 byte StackPop(List *plist,Item...
  • c++优先队列讲解

    2019-11-20 00:20:29
    优先队列容器与队列一样,只能从队尾插入元素,从队首...优先队列本质是个heap,在STL中实现代码,在头文件中,归属于命名空间std 优先级队列可以用向量(vector)或双向队列(deque)来实现(注意list container不能用来...
  • 队列知识小了解 队列是一种特殊的线性表,只能头尾两端进行操作。 队尾:只能从队尾添加元素,一般叫做enQueue,入队。 队头:只能从队头删除元素,一般叫做deQueue,出队。...自定义一个头文件,如下: @inter
  • STL deque双端队列容器

    2016-04-29 08:31:27
    deque的头文件:#include 【deque的选择】  deque双向队列是一种双向开口的连续线性空间,可以高效的在头尾两端插入和删除元素,  deque在接口上和vector非常相似。如果只在容易的首部和尾部插入数据元素,...
  • 顺序队列 链式队列 定长顺序表 Seqlist Seqlist.h #pragma once // 防止头文件重复包含,适用于VS编译器下 /* 防止头文件重复包含 #ifndef __SEQLIST_H #define __SEQLIST_H …… …… #endif */ typedef i....
  • 指针问题 和 测试案例 异或问题 查找数值 和 测试案例 大整数乘法、根据身高重建队列、顺时针打印螺旋矩阵、前缀和/差分数组、盛水问题、矩阵相乘、找出重复数组中不重复的个数、杨辉三角 和 测试案例 哈希...
  • 文章目录C++ deque双端队列deque与vector、list头文件定义构造函数属性大小size()返回元素个数resize()改变双向队列大小empty() 判断是否为空clear() 清空操作1.增push_front() 头部增加push_back() 尾部增加...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 147
精华内容 58
关键字:

双队列头文件