容器主要分为:顺序容器和关联容器
顺序容器和关联容器，顺序容器主要有：vector、list、deque等。其中vector表示一段连续的内存地址，基于数组的实现，list表示非连续的内存，基于链表实现。deque双向队列与vector类似，但是对于首元素提供删除和插入的双向支持。关联容器主要有map和set。map是key-value形式的，set是单值。map和set只能存放唯一的key值，multimap和multiset可以存放多个相同的key值, 还有unorder_multimap等。
顺序容器
vector
/*
* 什么是vector, vector的特点
* vector类似一个动态数组,是一段地址连续的空间
* vector和array的区别:vector支持动态空间调整,随着元素的增加,大小会改变
*/
// 初始化: vector<int> v; vector<int> v2(10); // 可以容纳10个int vector<int> v3(10, 2); // 10个2 vector<int> v4(v2); int arr[4] = {1,2,3,4}; vector<int> v5(arr, arr+4); // 其他操作, 是vector容器自带的函数,不包含全局的算法(find查找,remove_if删除等) // 添加元素 vec.push_back(3); // 在最后添加元素 insert(); /* iterator insert( iterator loc, const TYPE &val ); void insert( iterator loc, size_type num, const TYPE &val ); void insert( iterator loc, input_iterator start, input_iterator end ); insert() 函数有以下三种用法: 在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器, 在指定位置loc前插入num个值为val的元素 在指定位置loc前插入区间[start, end)的所有元素 . */ // 删: // erase iterator erase( iterator loc ); iterator erase( iterator start, iterator end ); // erase函数要么删作指定位置loc的元素,要么删除区间[start, end)的所有元素. // 返回值是指向删除的最后一个元素的下一位置的迭代器.例如: vec.clear(); // 清空容器 vec.pop_back(); // 移除尾部元素,无返回值 // 查 vec.back(); // 返回最有一个元素的引用 vec.begin(); // 返回当前容器首元素的迭代器 vec.end(); // 尾后迭代器 vec.rbegin(); // rbegin函数返回指向当前vector末尾的逆迭代器 vec.rend(); // rend()函数返回指向当前vector起始位置的逆迭代器. 类似与begin和end 其他 vec.empty(); // 判断是否为空 vec.capacity(); // 返回当前vector在重新进行内存分配以前所能容纳的元素数量. // reserve()函数为当前vector预留至少共容纳size个元素的空间 // void resize( size_type size, TYPE val ); vec.resize(); // resize() 函数改变当前vector的大小为size,且对新创建的元素赋值val vec.size(); // 返回当前所容纳的元素个数 // vec.swap(vec2) // vec和vec2交换 // 遍历: void print(vector<int>& vec) { for (int i = 0; i < vec.size(); i++) cout << vec[i] << " "; for (vector<int>::iterator it = vec.begin(); it != vec.end(); it++) { cout << *it << " "; } for (auto item : vec) { cout << item << " "; } cout << endl; }
deque
支持随机访问和快速插入和删除
// 双向队列和向量很相似，但是它允许在容器头部快速插入和删除（就像在尾部一样）。
// 就是比vector多了两个方法:
push_front()
pop_back()
// 具体使用方法参考vector
#include <iostream> #include <algorithm> #include <deque> using namespace std; void printDeq(deque<int> &d1) { cout << "deque迭代器遍历:"; for (deque<int>::iterator it = d1.begin(); it != d1.end(); it++) { cout << *it << " "; } cout << endl << endl; } void test41() { deque<int> d1; d1.push_back(1); d1.push_back(3); d1.push_back(5); d1.push_front(-11); d1.push_front(-33); d1.push_front(-55); printDeq(d1); cout <<"头部元素:" << d1.front() << endl; cout <<"尾部元素:" << d1.back() <<endl; d1.pop_front(); // 弹出头部元素 d1.pop_back(); // 弹出尾部元素 cout << "弹出头部，和尾部之后: "; printDeq(d1); // 查找-33在数组下标的值 deque<int>::iterator it = find(d1.begin(),d1.end(), -33); if (it != d1.end()) { // 计算下标 cout <<"-33的数组下标是" << distance(d1.begin(), it) << endl; } else { cout <<"未找到"<<endl; } } int main40() { test41(); return 0; }
list
list,list是stl实现的双向链表，
与向量vector想比，它允许快速的插入和删除，但是随机访问却是比较慢
结构图:
优点:随意插入和删除,替换元素效率极高
缺点:查找慢(不能随机访问:就是只能从头开始遍历)
不建议想里面插入数据,效率太低
/ 其他操作 // 初始化,创建 list<int> lst1; //创建空list list<int> lst2(3); //创建含有三个元素的list list<int> lst3(3,2); //创建含有三个元素为2的list list<int> lst4(lst2); //使用lst2初始化lst4 list<int> lst5(lst2.begin(),lst2.end()); //同lst4 // 增 lst1.assign(lst2.begin(),lst2.end()); //分配值,3个值为0的元素 lst1.push_front(1); // 1加到list的首部 lst1.push_back(10); //末尾添加值 lst1.insert(); //返回值是一个迭代器，指向被插入的元素。 iterator insert( iterator pos, const TYPE &val ); // 插入元素val到位置pos void insert( iterator pos, size_type num, const TYPE &val ); // 插入num个元素val到pos之前 void insert( iterator pos, input_iterator start, input_iterator end ); // 插入start到end之间的元素到pos的位置 // 删 lst1.pop_back(); // 删除链表的最后一个元素。 lst1.pop_front(); // 删除连链表第一个元素 lst1.remove(1); // 删除链表中所有的1 void lst1.remove_if( UnPred pr)// 以一元谓词pr为判断元素的依据，遍历整个链表。如果pr返回true则删除该元素。 lst1.erase() iterator erase( iterator pos ); iterator erase( iterator start, iterator end ); erase()函数删除以pos指示位置的元素, 或者删除start和end之间的元素。 返回值是一个迭代器，指向最后一个被删除元素的下一个元素。 lst1.clear() // 清除所有元素 // 改 lst1.reverse(); // 将所有的list倒转 lst1.swap(list2); // 1和2交换 lst1.unique(); // 删除重复的元素 void unique(); void unique( BinPred pr ); unique()函数删除链表中所有重复的元素。如果指定pr，则使用pr来判定是否删除。 // 查 lst1.begin(); // 返回list的首元素的迭代器 lst1.end(); // 返回list尾后迭代器 lst1.front(); // 返回一个指向首元素的引用 lst.back() // 返回一个引用，指向list的最后一个元素。 lst1.rbegin(); // 返回一个逆向迭代器，指向链表的末尾。 rend和begin和end用法类似 // 其他 lst1.empty(); // 判断是否为空 true为空 lst1.max_size(); //max_size()函数返回链表能够储存的元素数目。 lst1.merge() void merge( list &lst ); void merge( list &lst, Comp compfunction ); merge()函数把自己和lst链表连接在一起，产生一个整齐排列的组合链表。如果指定compfunction，则将指定函数作为比较的依据。 lst1.resize(); void resize( size_type num, TYPE val )// resize()函数把list的大小改变到num。被加入的多余的元素都被赋值为val lst1.size(); // 返回链表的元素数量 lst1.sort(); // 排序 void sort(); void sort( Comp compfunction ); sort()函数为链表排序，默认是升序。如果指定compfunction的话，就采用指定函数来判定两个元素的大小。 // 遍历: // list不能随机访问 就是 it++正确，但是不能it+2 it = l.begin(); it++; it++; it++; // 此时it指向第4个元素，元素为3 l.insert(it, 100); // 在3前面插入100 for (auto it = lst1.begin(); it != lst1.end(); it++) cout << *it << " "; for (auto it : lst1) cout << it << " "; // 加上&可以修改值 for (auto& it : lst1) cout << it << " ";
stack
不允许遍历
C++ Stack（堆栈） 是一个容器类的改编，为程序员提供了堆栈的全部功能，——也就是说实现了一个先进后出（FILO）的数据结构。
stack<int> s; s.push(1); // 在栈顶添加元素 s.push(2); s.top(); // 返回栈顶元素 s.pop(); //删除栈顶元素 s.empty(); // 判断栈空 s.size(); // 判断栈中元素数量
// // Created by lk on 18-6-3. // #include <iostream> #include <stack> #include <cstring> #include <algorithm> using namespace std; // 出栈 void printStack(stack<int> &sta) { while(!sta.empty()) { cout << sta.top() << " "; // 获取栈顶元素 sta.pop(); // 出栈 } } void test51() { stack<int> s; // 入栈 for(int i = 0; i != 10; i++) { s.push(i+1); } printStack(s); } // 栈模型 // 栈的算法 和数据类型的分离 // teacher节点 class Teacher { private: int age; char name[32]; public: Teacher() { age = 0; strcpy(name, ""); } Teacher(char *name, int age) { this->age = age; strcpy(this->name, name); } void print() { cout << "name: " << name << "age: " << age << endl; } friend ostream& operator<<(ostream &out, Teacher &obj) { out << " name: " << obj.name << " age: " << obj.age << endl; return out; } }; // 存放类 类型 void test52() { Teacher t1("t1", 31), t2("t2", 32), t3("t3", 33); stack<Teacher> Stack_Tea; Stack_Tea.push(t1); Stack_Tea.push(t2); Stack_Tea.push(t3); while(!Stack_Tea.empty()) { // Teacher重载了<<所以可以 cout<< cout <<Stack_Tea.top(); Stack_Tea.pop(); } } // 存放 类指针 类型 void test53() { Teacher t1("t1", 31), t2("t2", 32), t3("t3", 33); stack<Teacher*> Stack_Tea; Stack_Tea.push(&t1); Stack_Tea.push(&t2); Stack_Tea.push(&t3); // 出栈 while(!Stack_Tea.empty()) { cout << (* Stack_Tea.top()); // Stack_Tea.top() 就是&t1 Stack_Tea.pop(); } } int main() { // test51(); test52(); // test53(); return 0; }
queue
队列，栈都不能提前分配空间，需要进栈出栈, 不能遍历,
队和栈是两种封装好的数据结构
back() 返回最后一个元素
empty() 如果队列空则返回真
front() 返回第一个元素
pop() 删除第一个元素
push() 在末尾加入一个元素
size() 返回队列中元素的个数
// // Created by lk on 18-6-3. // #include <iostream> #include <queue> #include <cstring> using namespace std; // 队列的基本类型 void test61() { queue<int> q; // 队列，栈都不能提前分配空间，需要进栈出栈 // 入队 q.push(1); q.push(3); q.push(5); cout << "队头元素:" << q.front() << endl; // 返回队头元素，不是删除，栈的是删除 cout <<"队的大小:" << q.size() <<endl; cout << "队尾元素:" << q.back() << endl; // 出队 cout <<"出队: "; while(!q.empty()) { cout << q.front() << " "; q.pop(); // 删除队头元素 } } // 队列的算法 和数据类型分离 // teacher 节点 class Teacher { private: int age; char name[32]; public: Teacher() { age = 0; strcpy(name, ""); } Teacher(char *name, int age) { this->age = age; strcpy(this->name, name); } void print() { cout << "name: " << name << " age: " << age << endl; } friend ostream& operator<<(ostream &out, Teacher &obj) { out << " name: " << obj.name << " age: " << obj.age << endl; return out; } }; // 存放类 类型 void test62() { Teacher t1("t1", 31), t2("t2", 32), t3("t3", 33); queue<Teacher> queue_Tea; // 队列里面存放的是 Teacher的数据类型 queue_Tea.push(t1); // 入队 queue_Tea.push(t2); queue_Tea.push(t3); cout << "老师节点的出队: "; while(!queue_Tea.empty()) { cout << queue_Tea.front() << " "; queue_Tea.pop(); // 出队 } } // 存放指针类型 // 类似栈 。。。 int main() { // test61(); test62(); return 0; }
关联容器
https://www.cnblogs.com/xiaokang01/p/9130699.html