std::deque

最新推荐文章于 2024-05-13 09:58:43 发布
最新推荐文章于 2024-05-13 09:58:43 发布
阅读量456 收藏
点赞数
分类专栏： C++ STL 文章标签： C++ STL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014646358/article/details/50195771
版权
C++ 同时被 2 个专栏收录
12 篇文章 0 订阅
订阅专栏
STL
8 篇文章 0 订阅
订阅专栏

成员函数

//函数签名(构造函数)：
//default (1)
//explicit deque(const allocator_type& alloc = allocator_type());
//fill(2)
//explicit deque(size_type n);
//deque(size_type n, const value_type& val,
//  const allocator_type& alloc = allocator_type());
//range(3)
//template <class InputIterator>
//deque(InputIterator first, InputIterator last,
//  const allocator_type& alloc = allocator_type());
//copy(4)
//deque(const deque& x);
//deque(const deque& x, const allocator_type& alloc);
//move(5)
//deque(deque&& x);
//deque(deque&& x, const allocator_type& alloc);
//initializer list(6)
//deque(initializer_list<value_type> il,
//  const allocator_type& alloc = allocator_type());
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    //使用构造函数
    deque<int> first_deque;  // 空deque
    deque<int> second_deque(4, 100);                            //4个100
    deque<int> third_deque(second_deque.begin(), second_deque.end());       //和second_deque一样
    deque<int> fourth_deque(third_deque);                       //和third_deque一样

                                                                //使用迭代器构造函数复制数组
    int my_ints[] = { 0,8,11 };
    deque<int> fifth_deque(my_ints, my_ints + sizeof(my_ints) / sizeof(int));
    for (auto it = fifth_deque.begin(); it != fifth_deque.end(); it++)
        cout << *it << " ";
    cout << endl;
    return 0;
}

输出：
0 8 11

//函数签名(构造函数)：
//copy(1)
//deque& operator= (const deque& x);
//move(2)
//deque& operator= (deque&& x);
//initializer list(3)
//deque& operator= (initializer_list<value_type> il);
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> first_deque(8);          //8个0
    deque<int> second_deque(11);            //11个0

    second_deque = first_deque;
    first_deque = deque<int>();
    cout << "Size of first_deque  is " << int(first_deque.size())<< endl;
    cout << "Size of second_deque is " << int(second_deque.size())<<endl;

    return 0;
}

输出：
Size of first_deque is 0
Size of first_deque is 8

Iterators

//函数签名
//iterator begin() noexcept;
//const_iterator begin() const noexcept;
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque;
    for (int i = 0; i != 5; i++)
        my_deque.push_back(i + 1);
    auto it=my_deque.begin();
    while (it!=my_deque.end())
    {
        cout << *it++ << " ";
    }
    return 0;
}

输出：
1 2 3 4 5 

//函数签名
//iterator end() noexcept;
//const_iterator end() const noexcept;
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque;
    for (int i = 1; i <= 5; i++)
        my_deque.insert(my_deque.end(), i);             //注意这里是每次都插入末尾

    for (auto it = my_deque.begin(); it != my_deque.end(); it++)
        cout << *it << " ";
    cout << endl;
    return 0;
}

输出：
1 2 3 4 5

//函数签名
//reverse_iterator rbegin() noexcept;
//const_reverse_iterator rbegin() const noexcept;
//reverse_iterator rend() noexcept;
//const_reverse_iterator rend() const noexcept;
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque(5);
    int i = 0;
    //注： it 类型为 deque<int>::reverse_iterator
    for (auto it = my_deque.rbegin(); it != my_deque.rend(); it++)
        *it = ++i;
    for (auto it = my_deque.begin(); it != my_deque.end(); it++)
        cout << *it << " ";
    cout << endl;
    return 0;
}

输出：
5 4 3 2 1

//函数签名
//const_iterator cbegin() const noexcept;
//const_iterator cend() const noexcept;
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque = { 1,2,3,4,5 };
    //注： 常量迭代器设置迭代器指向的内容为常量，但是迭代器可以移动（除非迭代器也为const）
    for (auto it = my_deque.cbegin(); it != my_deque.cend(); it++)
        cout << *it << " ";
    cout << endl;
    return 0;
}

输出：
1 2 3 4 5

//函数签名
//const_reverse_iterator crbegin() const noexcept;
//const_reverse_iterator crend() const noexcept;
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque = { 1,2,3,4,5 };
    int i = 0;
    for (auto it = my_deque.crbegin(); it != my_deque.crend(); it++)
        cout << *it << " ";
    cout << endl;
    return 0;
}

输出：
5 4 3 2 1

Capacity

//函数签名
//size_type size() const noexcept;
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque;
    cout << "Size of my_deque is " << my_deque.size() << endl;

    for (int i = 0; i != 5; i++)
        my_deque.push_back(i);
    cout << "Size of my_deque is " << my_deque.size() << endl;

    my_deque.insert(my_deque.begin(), 5, 100);
    //此时my_deque 里的值为100 100 100 100 100 0 1 2 3 4
    cout << "Size of my_deque is " << my_deque.size() << endl;

    my_deque.pop_back();
    cout << "Size of my_deque is " << my_deque.size() << endl;
    return 0;
}

输出：
Size of my_deque is 0
Size of my_deque is 5
Size of my_deque is 10
Size of my_deque is 9

//函数签名
//size_type max_size() const noexcept;
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    //注：max_size()取决于不同STL的实现
    deque<int> my_deque;
    int i;
    cin >> i;
    if (i < my_deque.max_size())
    {
        my_deque.resize(i);
        cout << "Size of my_deque is " << i << endl;
    }
    else
        cout << "Size exceeds the limit" << endl;
    return 0;
}

输入：
5
输出：
Size of my_deque is 5
输入：
9999999999999
输出：
Size exceeds the limit

//函数签名
//void resize(size_type n);
//void resize(size_type n, const value_type& val);
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque;
    for (int i = 1; i <= 10; i++)
        my_deque.push_back(i);

    //若参数小于当前的size,则使deque的大小减小到参数大小
    //deque多余的内容被移除
    my_deque.resize(5);
    for (auto it = my_deque.begin(); it != my_deque.end(); it++)
        cout << *it << " ";
    cout << endl;
    //若参数大于当前的size,则使deque的大小增加到到第一个参数大小
    //给了第二个参数时，填充的值为第二个参数
    my_deque.resize(8, 10);
    for (auto it = my_deque.begin(); it != my_deque.end(); it++)
        cout << *it << " ";
    cout << endl;
    //若参数大于当前的size,则使deque的大小增加到到第一个参数大小
    //没给第二个参数时，填充的值0
    my_deque.resize(12);
    for (auto it = my_deque.begin(); it != my_deque.end(); it++)
        cout << *it << " ";
    cout << endl;

    return 0;
}

输出：
1 2 3 4 5
1 2 3 4 5 10 10 10
1 2 3 4 5 10 10 10 0 0 0 0

//函数签名
//bool empty() const noexcept;
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque;
    int sum = 0;
    for (int i = 1; i <= 10; i++)
        my_deque.push_back(i);
//注：判空是用empty函数而不是判断size()==0，前者效率大于等于后者，取决于STL的实现
    while (!my_deque.empty())
    {
        sum += my_deque.front();
        my_deque.pop_front();
    }
    cout << sum << endl;
    return 0;
}

输出：
55

//函数签名
//void shrink_to_fit();
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque(10, 10);
    cout << "size of my_deque is " << my_deque.size() << endl;

    my_deque.resize(5);     //注：现在大小为5，但是并未释放内存
    cout << "size of my_deque is " << my_deque.size() << endl;
    my_deque.shrink_to_fit();       //现在释放内存了，此函数有点类似于vector的reserve()
    return 0;
}

输出：
size of my_deque is 10
size of my_deque is 5

Element access

//函数签名
//reference operator[] (size_type n);
//const_reference operator[] (size_type n) const;
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque(10);
    deque<int>::size_type sz = my_deque.size();
    for (unsigned i = 0; i != sz; i++)
        my_deque[i] = i;
    //使用[]逆置deque
    for (unsigned i = 0; i != sz / 2; i++)
    {
        int tmp = my_deque[i];
        my_deque[i] = my_deque[sz - i - 1];
        my_deque[sz - i - 1] = tmp;
    }

    for (auto i = 0; i != sz; i++)
        cout << my_deque[i] << " ";
    cout << endl;
    return 0;
}

输出：
9 8 7 6 5 4 3 2 1 0

//函数签名
//reference at(size_type n);
//const_reference at(size_type n) const;
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque(10);
    for (unsigned i = 0; i !=my_deque.size(); i++)
        my_deque[i] = i;

    for (auto i = 0; i != my_deque.size(); i++)
        cout << my_deque.at(i) << " ";
    cout << endl;
    return 0;
}

输出：
0 1 2 3 4 5 6 7 8 9

//函数签名
//reference front();
//const_reference front() const;
//reference back();
//const_reference back() const;
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque;
    my_deque.push_front(11);
    my_deque.push_back(8);

    my_deque.front() -= my_deque.back();

    cout << my_deque.front() << endl;
    return 0;
}

输出：
3

Modifiers

//函数签名
//range(1)
//template <class InputIterator>
//void assign(InputIterator first, InputIterator last);
//fill(2)
//void assign(size_type n, const value_type& val);
//initializer list(3)
//void assign(initializer_list<value_type> il);
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> first_deque;
    deque<int> second_deque;
    deque<int> third_deque;

    first_deque.assign(7, 100);

    deque<int>::iterator it = first_deque.begin()+1;

    second_deque.assign(it, first_deque.end());

    int my_ints []= { 0, 8, 11 };
    third_deque.assign(my_ints, my_ints + 3);

    for (unsigned i = 0; i != first_deque.size(); i++)
        cout << first_deque[i] << " ";
    cout << endl;

    for (unsigned i = 0; i != second_deque.size(); i++)
        cout << second_deque[i] << " ";
    cout << endl;

    for (unsigned i = 0; i != third_deque.size(); i++)
        cout << third_deque[i] << " ";
    cout << endl;
    return 0;
}

输出：
100 100 100 100 100 100 100
100 100 100 100 100 100
0 8 11

//函数签名
//void push_back(const value_type& val);
//void push_back(value_type&& val);
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque;
    my_deque.push_back(1);
    cout << my_deque.back() << endl;

    my_deque.push_front(2);
    cout << my_deque.front() << endl;

    my_deque.pop_back();
    cout << my_deque.front() << endl;

    my_deque.pop_front();
    cout << my_deque.size() << endl;
    return 0;
}

输出：
1
2
2
0

//函数签名
//single element(1)
//iterator insert(const_iterator position, const value_type& val);
//fill(2)
//iterator insert(const_iterator position, size_type n, const value_type& val);
//range(3)
//template <class InputIterator>
//iterator insert(const_iterator position, InputIterator first, InputIterator last);
//move(4)
//iterator insert(const_iterator position, value_type&& val);
//initializer list(5)
//iterator insert(const_iterator position, initializer_list<value_type> il);
#include<iostream>
#include<deque>
#include<vector>
using namespace std;
int main()
{
    deque<int> my_deque = { 1,2,3,4,5 };

    auto it = my_deque.begin() + 1;

    it=my_deque.insert(it, 10); // 1 10 2 3 4 5 ,把返回的迭代器指回it,否则迭代器失效,现在it指向10

    my_deque.insert(it, 2, 5);  //1 5 5 10 2 3 4 5,注意现在it已经失效，不再指向任何值

    vector<int> vi(2, 3);
    it = my_deque.begin() + 2;
    my_deque.insert(it, vi.begin(), vi.end());  //1 5 3 3 5 10 2 3 4 5

    return 0;
}

输出：
1 5 3 3 5 10 2 3 4 5

//函数签名
//single element(1)
//iterator insert(const_iterator position, const value_type& val);
//fill(2)
//iterator insert(const_iterator position, size_type n, const value_type& val);
//range(3)
//template <class InputIterator>
//iterator insert(const_iterator position, InputIterator first, InputIterator last);
//move(4)
//iterator insert(const_iterator position, value_type&& val);
//initializer list(5)
//iterator insert(const_iterator position, initializer_list<value_type> il);
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque = { 1,2,3,4,5 };

    my_deque.erase(my_deque.begin()+3);     //擦除第4个

    my_deque.erase(my_deque.begin(), my_deque.begin() + 2);     //擦除第1，2个

    for each (auto var in my_deque)
    {
        cout << var << " ";
    }
    cout << endl;
    return 0;
}

输出：
3 5

//函数签名
//void swap(deque& x);
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> first_deque = { 1,2,3,4,5 };
    deque<int> second_deque = { 3,2,1 };

    first_deque.swap(second_deque);

    for each (auto var in first_deque)
    {
        cout << var << " ";
    }
    cout << endl;
    for each (auto var in second_deque)
    {
        cout << var << " ";
    }

    return 0;
}

输出：
3 2 1
1 2 3 4 5

//函数签名
//void clear() noexcept;
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque = { 1,2,3,4,5 };

    my_deque.clear();
    cout << my_deque.size() << endl;

    my_deque.push_back(1);
    my_deque.push_back(3);
    for each (auto var in my_deque)
    {
        cout << var << " ";
    }

    return 0;
}

输出：
0
1 3

//函数签名
//template <class... Args>
//iterator emplace(const_iterator position, Args&&... args);
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque = { 1,2,3 };

    auto it = my_deque.emplace(my_deque.begin() + 1, 10);
    my_deque.emplace(it, 20);
    my_deque.emplace(my_deque.end(), 30);
    for each (auto var in my_deque)
    {
        cout << var << " ";
    }

    return 0;
}

输出：
1 20 10 2 3 30

//函数签名
//template <class... Args>
//void emplace_front(Args&&... args);
//template <class... Args>
//void emplace_back(Args&&... args);
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque = { 1,2,3 };

    my_deque.emplace_front(8);
    my_deque.emplace_back(11);
    for each (auto var in my_deque)
    {
        cout << var << " ";
    }

    return 0;
}

输出：
8 1 2 3 11

Allocator

//函数签名
//allocator_type get_allocator() const noexcept;
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> my_deque;
    int *p;
    unsigned int i;

    p = my_deque.get_allocator().allocate(5);
    for (i = 0; i != 5; i++)
        my_deque.get_allocator().construct(&p[i], i);

    for (i = 0; i != 5; i++)
        cout << p[i] << " ";
    cout << endl;

    for (i = 0; i != 5; i++)
        my_deque.get_allocator().destroy(&p[i]);
    my_deque.get_allocator().deallocate(p,5);

    return 0;
}

输出：
0 1 2 3 4

非成员函数

//函数签名
//(1)
//template <class T, class Alloc>
//bool operator== (const deque<T, Alloc>& lhs, const deque<T, Alloc>& rhs);
//(2)
//template <class T, class Alloc>
//bool operator!= (const deque<T, Alloc>& lhs, const deque<T, Alloc>& rhs);
//(3)
//template <class T, class Alloc>
//bool operator<  (const deque<T, Alloc>& lhs, const deque<T, Alloc>& rhs);
//(4)
//template <class T, class Alloc>
//bool operator<= (const deque<T, Alloc>& lhs, const deque<T, Alloc>& rhs);
//(5)
//template <class T, class Alloc>
//bool operator>  (const deque<T, Alloc>& lhs, const deque<T, Alloc>& rhs);
//(6)
//template <class T, class Alloc>
//bool operator>= (const deque<T, Alloc>& lhs, const deque<T, Alloc>& rhs);
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> first_deque = { 1,2,3 };
    deque<int> second_deque = { 2,2,2 };
    if(first_deque==second_deque)
        cout << "first_deque and second_deque are equal" << endl;
    if (first_deque != second_deque)
        cout << "first_deque and second_deque are not equal" << endl;
    if (first_deque < second_deque)
        cout << "first_deque is less than second_deque" << endl;
    if (first_deque > second_deque)
        cout << "first_deque greater than second_deque" << endl;
    if (first_deque <= second_deque)
        cout << "first_deque is less than or equal to second_deque" << endl;
    if (first_deque >= second_deque)
        cout << "first_deque is greater than or equal to second_deque" << endl;
    return 0;
}

输出：
first_deque and second_deque are not equal
first_deque is less than second_deque
first_deque is less than or equal to second_deque

//函数签名
//allocator_type get_allocator() const noexcept;
#include<iostream>
#include<deque>
using namespace std;
int main()
{
    deque<int> first_deque = { 1,2,3 };
    deque<int> second_deque = { 1,2,3,4,5 };

    //注：虽然非成员函数swap()也能交换两个队列，但是还是建议使用成员函数
    swap(first_deque, second_deque);
    for each (auto var in first_deque)
    {
        cout << var << " ";
    }
    cout << endl;
    for each (auto var in second_deque)
    {
        cout << var << " ";
    }
    return 0;
}

输出：
1 2 3 4 5
1 2 3

不知梦
关注
专栏目录
容器库(3)-std::deque
Lucy_stone的博客
02-04 832
std::deque是有索引的序列容器，它允许在它的首尾两端快速插入及删除元素，和vector不同的是，deque底层的内存不是连续的。
std::deque和std::list的区别是什么
最新发布
2402_85246552的博客
07-07 456
std::deque（双端队列）和std::list（双向链表）是C++标准模板库（STL）中两种不同的序列容器，它们在内部实现、性能特性和使用场景上存在一些关键区别。
std::deque（双端队列）
weixin_67051070的博客
04-02 515
LeetCode239单调队列
C++ std::deque
肥猫王德福的博客
02-02 4573
重点： deque: double-end queue，双端队列 std::deque 不像 vector 把所有的对象保存在一块连续的内存块，而是采用多个连续的存储块，在一个映射结构中对这些内存块及顺序进行跟踪。 优点快速地随机访问，支持[ ]操作符和at()。首尾两端进行快速的push、pop操作O(1)，支持其他位置插入和删除操作O(n) 。 缺点:内存占用较多。 1. deque、构造函数1.1 deque简介   1. deque、构造函数 1.1 deque简介   std::dequ.
双端队列和C++ std::deque详解
jianmo的博客
07-03 586
双端队列实际上是队列的一种变形，队列要求只能在队尾添加元素，在队头删除元素，而双端队列在队头和队尾都可以进行添加和删除元素的操作。双端队列是限定插入和删除操作在表的两端进行的线性表。C++中提供deque容器来实现双端队列的功能。
C++ -- 学习系列 std::deque 的原理与使用
qq_33775774的博客
09-30 1290
std::deque 是 c++ 一种序列式容器，其与 vector 类似，其底层内存都是连续的，不同的地方在于， vector 是一端开口，在一端放入数据与扩充空间，而 deque 是双端均开口，都可以放入数据与扩充空间。
C++(21): C++：std::vector与std::deque比较
tecsai的博客
05-13 914
std::vector和std::deque都是C++标准库中的容器，它们有一些相似之处，但也有很多重要的区别。以下是它们的相同点和不同点，以及各自的优点。
c++11 标准模板（STL）（std::deque）（二）
qq_40788199的博客
12-30 735
从各种数据源构造新容器，可选地使用用户提供的分配器 alloc 。 1) 默认构造函数。构造拥有默认构造的分配器的空容器。 3) 构造拥有 count 个有值 value 的元素的容器。 4) 构造拥有个 count 默认插入的 T 实例的容器。不进行复制。 5) 构造拥有范围 [first, last) 内容的容器。 6) 复制构造函数。构造拥有 other 内容的容器。 7) 移动构造函数。用移动语义构造拥有 other 内容的容器。 9) 构造拥有 initializer_list init 内容的
c++11 标准模板（STL）（std::deque）（三）
qq_40788199的博客
12-31 930
1) 复制赋值运算符。以 other 的副本替换内容。 2) 移动赋值运算符。用移动语义以 other 的内容替换内容。 3) 以 initializer_list ilist 所标识者替换内容。 1) 以 count 份 value 的副本替换内容。 2) 以范围 [first, last) 中元素的副本替换内容。 3) 以来自 initializer_list ilist 的元素替换内容。
深入研究std_deque.doc
10-16
双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列
Projet_deque:Projet INFO0402双端队列
03-13
【标题】"Projet_deque:Projet INFO0402双端队列"是一个针对INFO0402课程的项目，重点在于实现双端队列（Deque）的数据结构。双端队列是一种线性数据结构，允许在两端进行插入和删除操作，具有较高的灵活性。在C++...
C++ STL入门教程(3) deque双向队列使用方法
08-29
C++ STL deque双向队列使用方法 在 C++ STL 中，deque（Double Ended Queues，双向队列）是一种非常有用的容器，它允许在容器头部快速插入和删除（就像在尾部一样）。本文将详细介绍 deque 的使用方法，以便读者更...
Tubes_STD:大数据结构作业第二学期
04-18
在C++中，标准模板库(STL)提供了一些预定义的数据结构，如vector、list、deque、set、map等，这些都是实现各种算法的基础。 2. **C++ STL**：STL是C++的一个重要组成部分，它包含容器（如vector、list、set等）、...
Deque：使用C ++实现数据结构Deque的实现
02-17
在C++标准库中，`std::deque`是双端队列的一种实现，提供了高效且灵活的存储管理。在本文中，我们将探讨如何使用C++自定义实现一个双端队列，并分析其基本操作和时间复杂度。 首先，让我们了解双端队列的基本操作：...
std::list
不知
12-29 1069
STL
C++模板库（包含C++11特性）
不知
11-06 796
学C++也有一段时间了，看完了C++primer，effective C++，effective STL，深度探索C++对象模型。现在写一套关于C++STL的博客，算是对C++ STL的复习吧。
std::array
不知
12-06 644
STL
std::stack
不知
02-14 643
成员函数//函数签名 //initialize(1) //explicit stack(const container_type& ctnr); //move - initialize(2) //explicit stack(container_type&& ctnr = container_type()); //allocator(3) //template <class Alloc> expli
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值