C++中STL（标准模板库）整理（容器：vector、deque、stack、queue、list、map、set）

最新推荐文章于 2024-04-26 13:36:07 发布
最新推荐文章于 2024-04-26 13:36:07 发布
阅读量576 收藏 4
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41915323/article/details/94590601
版权

解释及说明在程序中有体现：
什么是容器？
通俗的讲就是将常用的数据结构，如数组、链表、栈、队列、二叉树等封装成一个个模板类，以方便编程。
序列式容器：每个元素都有固定的位置，这取决于插入时机和地点，与元素值无关。
关联式容器：元素位置取决于特定的排序准则，与插入顺序无关。

1.vector容器
vetor是单端数组。是将元素置于一个动态数组中加以管理的容器，可以随机存取元素，支持用[]操作符和at()方法直接存取。vector容器可以在尾部非常快的添加和移除元素，但是在中部或头部插入或移除元素比较费时。

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    int a[10] = {1,2,3,4,5,6,7,8,9,0};
    vector<int> v1;
    vector<int> v2(10,10);
    vector<int> v3(a,a+10);

    for(vector<int>::iterator it = v2.begin(); it != v2.end(); it++)	    //迭代器输出
    {
	cout << *it << " ";
    }
    cout << endl;

    for(int i = 0; i < v2.size(); i++)
    {
	cout << v2[i] << " ";
    }
    cout << endl;

    for(int j=0; j < v3.size(); j++)
    {
	cout << v3[j] << " ";
    }
    cout << endl;


    v1.resize(v2.size());
    for(int i = 0; i < v2.size(); i++)
    {
	v1[i] = v2[i];
    }
    //cout << v1 << endl;		//直接输出是错误的
    for(int i = 0; i < v1.size(); i++)
    {
	cout << v1[i] << " ";
    }
    cout << endl;


    cout << v3.front() << endl;		//返回v3第一个元素，不检查元素是否存在
    cout << v3.back() << endl;		//返回v3最后一个元素，不检查元素是否存在

    v3.front() = 100;			//可初始化
    v3.back() = 200;
    for(vector<int>::iterator it = v3.begin(); it != v3.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    v1.assign(a,a+10);			//赋值
    for(int i=0; i < v1.size(); i++)
    {
	cout << v1[i] << " ";
    }
    cout << endl;

    v1.assign(20,'e');			//赋值  打印出为20个101,不是字符e
    for(int i=0; i < v1.size(); i++)
    {
	cout << v1[i] << " ";
    }
    cout << endl;

    v1.resize(30);			//将元素数量改为30（增加的元素用default构造函数产生，多余的元素被删除）
    for(vector<int>::iterator it= v1.begin(); it!=v1.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    v1.resize(40,'d');			//将元素数量改为40（增加的元素用d(100）填充）
    for(vector<int>::iterator it= v1.begin(); it!=v1.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    v1.resize(5);	    
    for(vector<int>::iterator it= v1.begin(); it!=v1.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    cout <<"正向迭代器、反向迭代器、只读迭代器" << endl;
    for(vector<int>::iterator it= v3.begin(); it!=v3.end(); it++)   //正向迭代器
    {
	cout << *it << " ";
    }
    cout << endl;

    for(vector<int>::reverse_iterator rit= v3.rbegin(); rit!=v3.rend(); ++rit)	//反向迭代器   往常思想（从后往前输出，但it指针指在end后的一个位置，所以要先++）
    {
	cout << *rit << " ";
    }
    cout << endl;

    for(vector<int>::const_iterator cit= v3.begin(); cit!=v3.end(); cit++)	//只读迭代器
    {
	cout << *cit << " ";
    }
    cout << endl;   

    cout << "************插入***************" << endl;
    v3.insert(v3.begin(),500);
    for(vector<int>::iterator it= v3.begin(); it!=v3.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    v3.insert(v3.begin(), 10, 30);	    //v3开头插入10个30
    for(vector<int>::iterator it= v3.begin(); it!=v3.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    v3.insert(v3.end(),a,a+10);		    //v3尾部插入数组
    for(vector<int>::iterator it= v3.begin(); it!=v3.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    cout << "=============删除============" << endl;
    v3.erase(v3.begin());
    for(vector<int>::iterator it= v3.begin(); it!=v3.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    v3.erase(v3.begin(),v3.begin() + 9);
    for(vector<int>::iterator it= v3.begin(); it!=v3.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;


    v3.clear();		    //移除所有元素，清空容器
    for(vector<int>::iterator it= v3.begin(); it!=v3.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    return 0;
}

2.deque容器
deque是双端数组。deque可以随机存取元素，支持索引值直接存取，可用[]操作符或at()方法。在deque头部和尾部添加和移除元素都非常快速。但在中部添加和移除元素比较费时。

#include <iostream>
#include <deque>
using namespace std;
int main()
{
    char ptr[] = "helloworld";

    cout << "****构造、拷贝*****" << endl;
    deque<char> d1;
    deque<char> d2(10,'X');
    deque<char> d3(ptr,ptr + strlen(ptr));

    d1 = d2;
    cout << "d1=";
    for(deque<char>::iterator it = d1.begin(); it != d1.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    for(deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    for(int i=0; i<d3.size(); i++)
    {
	cout << d3[i] << " ";
    }
    cout << endl;


    cout << "********交换*********" << endl;
    d2.swap(d3);
    for(deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;
    for(int i=0; i<d3.size(); i++)
    {
	cout << d3[i] << " ";
    }
    cout << endl;

    cout << "*******存取*******" << endl;
    cout << d3[1] << endl;
    cout << d3.at(2) << endl;

    cout << "********插入******" << endl;
    d2.push_back('y');
    d2.push_front('y');
    for(deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    d2.insert(d2.begin(), 'Y');
    d2.insert(d2.end(), 2, 'Y');
    for(deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    d2.insert(d2.begin(), ptr, ptr + strlen(ptr));
    for(deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    cout << "*************删除***************" << endl;
    d2.erase(d2.begin(),d2.begin() + 10);
    for(deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    d2.erase(d2.end() - 5, d2.end());
    for(deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    d2.resize(20,'Z');		//将元素量改为20 ，增加的元素为Z
    for(deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;


    cout << "*****清空容器*****" << endl;
    d2.clear();
    for(deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;


    return 0;
}

删除元素

#include <iostream>
#include <deque>
using namespace std;

int main()
{
    int a[] = {3,2,5,4,3,6,4,3,3,7,5,7,3,3,8};

    deque<int> d1(a,a+ sizeof(a)/sizeof(a[0]));
    for(deque<int>::iterator it = d1.begin(); it != d1.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    for(deque<int>::iterator it = d1.begin(); it != d1.end();)
    {
	if(*it == 3)
	{
	    it = d1.erase(it);
	}
	else
	{
	    it++;
	}
    }

    for(deque<int>::iterator it = d1.begin(); it != d1.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    return 0;
}

3.stack容器

#include <iostream>
#include <stack>
using namespace std;

int main()
{
    stack<int> s;
    for(int i=0; i < 10; i++)
    {
	s.push(i +1);
    }
    cout << "s.top=" << s.top() << endl;

    while( !s.empty())
    {
	cout << s.top() << " ";
	s.pop();
    }
    cout << endl;

    return 0;
}

4.queue容器

#include <iostream>
#include <queue>
using namespace std;

int main()
{
    queue<int> q;
    for(int i=0; i<10; i++)
    {
	q.push(i+1);
    }

    cout << "q.front=" << q.front() << endl;
    cout << "q.back=" << q.back() << endl;

    while( !q.empty())
    {
	cout << q.front() << " ";
	q.pop();
    }
    cout << endl;

    return 0;
}

5.list容器
list是一个双向链表容器，可高效的进行插入删除元素。list不可以随机存取元素，所以不支持[]操作符和at()函数，也不支持迭代器的随机访问。

#include <iostream>
#include <list>
using namespace std;

void show(list<int> &l)
{
    for(list<int>::iterator it = l.begin(); it != l.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;
}

int main()
{
    list<int> l;
    for(int i=0; i<10; i++)
    {
	l.push_back(i);
    }

    l.push_front(2);
    l.push_front(2);
    l.push_front(2);
    show(l);

    cout << "元素个数：" << l.size() << endl;
    show(l);

    list<int>::iterator it = l.begin();
    it++;
    it++;
    it++;
    l.erase(it);

    int a = 2;
    l.remove(a);
    show(l);

    l.reverse();
    show(l);

    cout << "排序" << endl;
    list<int> l1;
    l.push_back(2);
    l.push_back(1);
    l.push_back(7);
    l.push_back(4);
    l.push_back(5);
    l.sort();
    for(list<int>::iterator it = l.begin(); it != l.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    return 0;
}

list类操作：

#include <iostream>
#include <list>
using namespace std;

class Parent
{
private:
    static int num;
    int id;
    string name;
    string tel;
    int age;
public:
    Parent(string n, string t, int a);
    void show();
};
int Parent::num = 0;

Parent::Parent(string n, string t, int a)
{
    num++;
    id = num;
    name = n;
    tel = t;
    age = a;
}

void Parent::show()
{
    cout << id << " " << name << " " << tel << " " << age << endl;
}

int main()
{
    list<Parent> l;

    Parent p1("aaa","111",20);
    Parent p2("bbb","222",21);
    Parent p3("ccc","333",22);
    Parent p4("ddd","444",23);
    Parent p5("eee","555",24);
    Parent p6("fff","666",25);

    l.push_back(p1);
    l.push_back(p2);
    l.push_back(p3);
    l.push_front(p4);
    l.pop_front();
    l.insert(l.begin(),p5);
    l.insert(++l.begin(),p6);
    
    for(list<Parent>::iterator it = l.begin(); it != l.end(); it++)
    {
	it->show();
    }

    cout << "=====================" << endl;
    l.reverse();
    for(list<Parent>::iterator it = l.begin(); it != l.end(); it++)
    {
	it->show();
    }


    return 0;
}

6.map容器
map是标准的关联式容器，一个map就是一个键值对序列，即（key,value）对，它提供了基于key的快速检索能力。map中的key值是唯一的，集合中的元素按一定的顺序排序。元素插入过程是按排序规则插入，所以不能指定插入位置。map的具体实现是采用红黑树变体的平衡二叉树的数据结构，在插入操作和删除操作上比vector容器快。可以直接存取key所对应的value，支持[]操作符，如map[key] = value.

#include <iostream>
#include <map>
using namespace std;

int main()
{
    cout << "*****插入 自动排序*****" << endl;
    map<int,string> m1;
    m1.insert(pair<int,string>(10,"小明"));
    m1.insert(pair<int,string>(11,"小张"));

    m1.insert(make_pair(2,"小王"));
    m1.insert(make_pair(15,"小李"));

    m1.insert(map<int,string>::value_type(4,"小赵"));
    m1.insert(map<int,string>::value_type(8,"小吴"));

    m1[17] = "小郑";
    m1[16] = "小杨";

    for(map<int,string>::iterator it = m1.begin(); it != m1.end(); it++)
    {
	cout << it->first << '\t' << it->second << endl;
    }

    cout << "**********查找**********" << endl;
    map<int,string>::iterator it = m1.find(4);
    if(it != m1.end())
    {
	cout << "找到id=" << it->first << ",  他的名字是：" << it->second << endl;
	//it++;		    //加不加都可以
    }

    cout << "******返回键值等于key的元素区间*********" << endl;
    pair<map<int,string>::iterator ,map<int,string>::iterator>ret = m1.equal_range(4);
    if(ret.first != m1.end())
    {
	cout << "找到id=" << ret.first->first << ",  他的名字是：" << ret.first->second << endl;
    }
    if(ret.second != m1.end())
    {
	cout << "找到id=" << ret.second->first << ",  他的名字是: " << ret.second->second << endl;
    }

    cout << "*********删除**********" << endl;
    m1.erase(10);
    for(map<int,string>::iterator it = m1.begin(); it != m1.end(); it++)
    {
	cout << it->first << '\t' << it->second << endl;
    }

    return 0;
}

7.set容器

#include <iostream>
#include <set>
using namespace std;

class People
{
    friend class Com;
private:
    int id;
    char name[32];
    int age;
public:
    People(int i, char *n, int a)
    {
	id = i;
	strcpy(name, n);
	age = a;
    }

    void show() const
    {
	cout << "id=" << id << ", name=" << name << ", age=" << age << endl;
    }

    bool operator<(const People &p) const
    {
	return this->id < p.id;
    }

    bool operator>(const People &p) const
    {
	return this->id > p.id;
    }
};

class Com
{
public:
    bool operator()(const People &p1, const People &p2) const	    //重载函数调用运算符
    {
	return p1.id > p2.id;
    }
};
int main()
{
    //set<int> s1;		//默认从小到大排序
    //set<int,less<int> > s1;	//声明从小到大排序
    set<int,greater<int> > s1;	//声明从大到小排序

    s1.insert(4);
    s1.insert(0);
    s1.insert(5);
    s1.insert(8);
    s1.insert(1);

    for(set<int>::iterator it = s1.begin(); it != s1.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;
    cout << "*************************" << endl;

    People p1(1,"aaa",20);
    People p2(7,"bbb",21);
    People p3(4,"ccc",22);
    People p4(9,"ddd",23);
    People p5(6,"eee",24);

    //set<People, less<People> > s2;	    //需要重载<  因为类People是自定义类型   从小到大排序
    //set<People, greater<People> > s2;	    //需要重载>  因为类People是自定义类型   从大到小排序
    multiset<People, Com> s2;		    //需要重载>  因为类People,Com是自定义类型   从大到小排序

    s2.insert(p1);
    s2.insert(p2);
    s2.insert(p3);
    s2.insert(p4);
    s2.insert(p5);
    //for(set<People, less<People> >::iterator it = s2.begin(); it != s2.end(); it++)
    //for(set<People, greater<People> >::iterator it = s2.begin(); it != s2.end(); it++)
    for(multiset<People, Com>::iterator it = s2.begin(); it != s2.end(); it++)
    {
	it->show();
    }

    cout << "********删除*******" << endl;
    s1.erase(s1.begin());
    for(set<int>::iterator it = s1.begin(); it != s1.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    s1.erase(s1.begin(), ++s1.begin());
    for(set<int>::iterator it = s1.begin(); it != s1.end(); it++)
    {
	cout << *it << " ";
    }
    cout << endl;

    cout << "++++++++++++++++++++++" << endl;
    s2.erase(p2);				    //按照id删除
    for(set<People, less<People> >::iterator it = s2.begin(); it != s2.end(); it++)
    {
	it->show();
    }

    cout << "======================" << endl;
    set<People,Com>::iterator it = s2.find(p5);
    if(it == s2.end())
    {
	cout << "元素找不到" << endl;
    }
    else
    {
	it->show();
    }

    int num = s2.count(p4);
    cout << "num=" << num << endl;;

    cout << "***************" << endl;
    it = s2.lower_bound(p3);	//从大到小排序   返回第一个小于或等于p1的值(反之，若从小到大排序，则返回大于等于的值)
    it->show();

    cout << "***************" << endl;
    it = s2.upper_bound(p3);	//从大到小排序  返回第一个小于p1的值（反之，同上）
    it->show();

    cout << "*******组队*****" << endl;
    pair< set<People,Com>::iterator, set<People,Com>::iterator > p; //从大到小排序  
    p = s2.equal_range(p3);	    //组队命令
    p.first->show();		    //输出p3
    p.second->show();		    //输出p3下一位


    return 0;
}
阿辉吖
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++中常用的std标准容器（全部容器功能介绍）
流楚丶格念的博客
04-29 9486
文章目录C++中常用的std标准容器顺序容器：有序关联容器：无序关联容器：顺序容器1. vector容器a. vector的定义与初始化b. vecotr常使用的操作c. 小结：2. string容器a. string的初始化b. string中包含的专有的操作（相对于vector来说）c字符串的转换函数d 对字符的操作（在cctype头文件中，并不属于string头文件的范围，但是关系很紧密的）...
c++STL容器(map,set,vector,stack,queue)
u010112268的博客
07-19 366
STL 目录 STL 组成部分 容器 序列式容器 迭代器 算法 STL是Standard Template Library的简称，中文名标准模板库，惠普实验室开发的一系列软件的统称。它是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室工作时所开发出来的。从根本上说，STL是一些"容器"的集合，这些"容器"有li...
C++常用的容器：vector、string、deque、stack、queue、list、set、map、hash_set、hash_map等的介绍
m0_57190374的博客
09-25 4085
本文详细介绍了vector、string、deque、stack、queue、list、set、map以及pair对组的基本语法。
C++ STL标准库之容器（常用）篇
最新发布
山月藏匿浪漫、
04-26 783
简单来说就是set在底层也是以键值对存放的，只不过键值对中不是<key,value>，而是<value,value>。关联式容器在底层的结构上采用比序列式容器更为复杂的结构，所以关联式容器在查找数据时效率较序列式容器更高，采用hash算法加快查找过程，但需要更多内存存放hash桶元素，是一种采用空间换取时间的策略。multimap与map的区别在于：前者允许key值冗余，即不会对数据起到去重的作用。multiset与set的区别在于：multiset允许存储重复的值，set则不允许。
c++标准容器的简介
懒人的技术笔记
12-17 1578
http://ewangplay.appspot.com/?p=5002容器类可以分为两大类：（1）序列容器(Sequence containers)这种容器中的元素是有序的，每一个元素在容器中都有一个确切的位置，这个位置不依赖于元素的值，而是跟放入容器的时机有关。标准的序列容器有三个：vector, deque, list。另外你也可以把字符串(string)和数组(array)看成序列容器。Vectors一个vector用动态数组来管理它的元素。像普通数组一样，通过对应的索引支持随机访问。从一个vect
c++/STL标准库中常用容器
2301_80045850的博客
01-25 1720
STL(Standard Template Library,标准模板库)，是惠普实验室开发的一系列软件的统称。现在主要出现在 c++中，但是在引入 c++之前该技术已经存在很长时间了。C++ STL（Standard Template Library，标准模板库）是一套强大的C++模板类集合，它提供了许多高效的数据结构和算法。（Containers）：用于存储数据的对象，例如vector、list、deque和map。
stl_test:STL中deque、list、vector、stack、map、set、hashmap的基本应用
05-21
在这个名为“stl_test”的项目中，我们主要关注STL中的几种容器：deque（双端队列）、list（链表）、vector（动态数组）、stack（栈）、map（关联数组）、set（集合）以及hashmap（哈希表）。这些容器在不同的场景下...
C++ STL容器stack和queue详解
09-01
C++ STL（Standard Template Library，标准模板库）提供了两种特殊的线性容器：stack（栈）和queue（队列），它们都是基于顺序容器（如vector或deque）实现的抽象数据类型，用于实现特定的数据操作逻辑。 **1. ...
C++标准模板库(STL) -容器
11-05
STL的代码从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎所有的代码都采用了模板类和模版函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。在C++标准中，STL被组织为下面的13个头文件：<algorithm>、<deque>、<functional>、<iterator>、<vector>、<list>、<map>、 <memory>、<numeric>、<queue>、<set>、<stack>和<utility>。
C++_标准模板库(STL) pdf 高清版
04-27
C++标准模板库（STL）是C++编程语言中不可或缺的一部分，它为开发者提供了大量高效、可重用的容器、算法和迭代器。STL的主要目标是提高代码的效率和可读性，通过使用泛型编程（也称为模板编程）来实现。以下是关于...
c++ 标准库的各种容器(vector,deque,map,set,unordered_map,unordered_set,list)的性能考虑
热门推荐
ssz的技术博客
12-13 1万+
c++ 标准库的各种容器(vector,deque,map,set,unordered_map,unordered_set,list)的性能考虑   一、vector vector采用一段连续的内存来存储其元素，向vector添加元素的时候，如果容量不足，vector便会重新malloc一段更大的内存，然后把原内存中的数据memcpy到新的内存中，并free原内存块，然后将新元素加入。vec
C++标准库STL容器详解
weixin_40355471的博客
08-29 857
C++标准模板库STL容器，reserve和resize，插入/删除/查找时间复杂度，容器接口，红黑树/哈希表数据结构图解，容器都是类模板，实例化后是容器类。顺序容器vector、deque、list，关联容器set、multiset、map、multimap、unordered_set、unordered_multiset、unordered_map、std::unordered_multimap，容器适配器stack、queue、priority_queue。
STL之顺序容器
jiaomubai的博客
09-21 916
容器（container）是容纳、包含一组元素的对象。容器类库中包括7种基本容器：向量（vector）、双端队列（deque）、列表（list）、集合（set）、多重集合（multiset）、映射（map）和多重映射（multimap）。这7种容器可以划分为两种基本类型：顺序容器（sequence container）和关联容器（associative container）。顺序容...
C++隙笔--标准库:常用容器
H'Senseiの工坊
01-30 223
何为C++标准库？ C++标准库是一个十分重要的角色，里面有很多容器以及算法的功能实现，十分值得学习。 标准库里有什么常用的容器？ Sequence containers array：数组 vector：向量 deque：双向队列 forward_list：单链表的形式存储元素 list：双向链表的形式存储元素 Container adaptors stack：栈 queue：队列 priority_queue：优先队列（堆） Associative containers set：树集合 mul
[C++]标准库类型容器
LeeShinton的博客
11-05 1099
update：2016/11/161.标准库类型vectorvector能够容纳绝大多数类型的对象作为其元素，但是由于引用并不是对象，因此不存在包含引用的vector。除此之外，其他大多数（非引用）内置类型和类类型都可以作为vector的元素，这也包含vector。1.定义和初始化vectorvector作为一个类模板，本身不会指定类型，而必须要为其指定类型。例如：vector<int> ivec;
02 C++STL之容器
carson的博客
07-04 901
array（数组容器）：定义在< array >头文件中， 表示可以存储N个T类型的元素，是C++本身提供的一种容器。此容器一旦建立，其长度就是固定不变的，也就是说无法增加或者删除元素，只能改变某个元素的值； vector（向量容器）：定义在< vector>头文件中，用来存储T类型的元素，是一个长度可变的序列容器，即在存储空间不足时，会自动申请更多的内存。使用此容器，在尾部增加或者删除元素效率最高（时间复杂度为O（1）常数阶），在其他位置插入或删除元素效率较差（时间复杂度O（n）线性阶，其中n为.....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值