STL容器
容器概念
容器是用来管理某一类对象的集合。研究数据的特定排列方式,以利于搜索或排序或其他特殊目的,这一门学科我们称为数据结构。大学信息类相关专业里面,与编程最有直接关系的学科,首推数据结构与算法。几乎可以说,任何特定的数据结构都是为了实现某种特定的算法。STL容器就是将运用最广泛的一些数据结构实现出来。常用的数据结构:数组(array),链表(list),tree(树),栈(stack),队列(queue),集合(set),映射表(map),根据数据在容器中的排列特性,这些数据分为序列式容器和关联式容器两种。
- 序列式容器强调值的排序,序列式容器中的每个元素均有固定的位置,除非用删除或插入的操作改变这个位置。Vector容器、Deque容器、List容器等。
- 关联式容器是非线性的树结构,更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系,也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。关联式容器另一个显著特点是:在值中选择一个值作为关键字key,这个关键字对值起到索引的作用,方便查找。Set/multiset容器Map/multimap容器
常用容器
string容器
string容器基本概念
C风格字符串(以空字符结尾的字符数组)太过复杂难于掌握,不适合大程序的开发,所以C++标准库定义了一种string类,定义在头文件。
String和c风格字符串对比:
- Char是一个指针,String是一个类string封装了char,管理这个字符串,是一个char*型的容器。
- String封装了很多实用的成员方法查找find,拷贝copy,删除delete 替换replace,插入insert
- 不用考虑内存释放和越界 string管理char*所分配的内存。每一次string的复制,取值都由string类负责维护,不用担心复制越界和取值越界等。
string容器常用操作
string 构造函数
语法 | 解释 |
---|---|
string(); | 创建一个空的字符串 例如: string str; |
string(const string& str); | 使用一个string对象初始化另一个string对象 |
string(const char* s); | 使用字符串s初始化 |
string(int n, char c); | 使用n个字符c初始化 |
string基本赋值操作
语法 | 解释 |
---|---|
string& operator=(const char* s) | char*类型字符串 赋值给当前的字符串 |
string& operator=(const string &s) | 把字符串s赋给当前的字符串 |
string& operator=(char c) | 字符赋值给当前的字符串 |
string& assign(const char *s) | 把字符串s赋给当前的字符串 |
string& assign(const char *s, int n) | 把字符串s的前n个字符赋给当前的字符串 |
string& assign(const string &s) | 把字符串s赋给当前字符串 |
string& assign(int n, char c) | 用n个字符c赋给当前字符串 |
string& assign(const string &s, int start, int n) | 将s从start开始n个字符赋值给字符串 |
string存取字符操作
语法 | 解释 |
---|---|
char& operator[](int n) | 通过[]方式取字符 |
char& at(int n) | 通过at方法获取字符 |
string拼接操作
语法 | 解释 |
---|---|
string& operator+=(const string& str) | 重载+=操作符 |
string& operator+=(const char* str) | 重载+=操作符 |
string& operator+=(const char c) | 重载+=操作符 |
string& append(const char *s) | 把字符串s连接到当前字符串结尾 |
string& append(const char *s, int n) | 把字符串s的前n个字符连接到当前字符串结尾 |
string& append(const string &s) | 同operator+=() |
string& append(const string &s, int pos, int n) | 把字符串s中从pos开始的n个字符连接到当前字符串结尾 |
string& append(int n, char c) | 在当前字符串结尾添加n个字符c |
string查找和替换
语法 | 解释 |
---|---|
int find(const string& str, int pos = 0) const | 查找str第一次出现位置,从pos开始查找 |
int find(const char* s, int pos = 0) const | 查找s第一次出现位置,从pos开始查找 |
int find(const char* s, int pos, int n) const | 从pos位置查找s的前n个字符第一次位置 |
int find(const char c, int pos = 0) const | 查找字符c第一次出现位置 |
int rfind(const string& str, int pos = npos) const | 查找str最后一次位置,从pos开始查找 |
int rfind(const char* s, int pos = npos) const | 查找s最后一次出现位置,从pos开始查找 |
int rfind(const char* s, int pos, int n) const | 从pos查找s的前n个字符最后一次位置 |
int rfind(const char c, int pos = 0) const | 查找字符c最后一次出现位置 |
string& replace(int pos, int n, const string& str) | 替换从pos开始n个字符为字符串str |
string& replace(int pos, int n, const char* s) | 替换从pos开始的n个字符为字符串s |
string比较操作
语法 | 解释 |
---|---|
int compare(const string &s) const; | 与字符串s比较 |
int compare(const char *s) const | 与字符串s比较 |
注意:
compare函数在>时返回 1,<时返回 -1,==时返回 0。比较区分大小写,比较时参考字典顺序,排越前面的越小。
大写的A比小写的a小。
string子串
语法 | 解释 |
---|---|
string substr(int pos = 0, int n = npos) const | 返回由pos开始的n个字符组成的字符串 |
string插入和删除操作
语法 | 解释 |
---|---|
string& insert(int pos, const char* s) | 插入字符串 |
string& insert(int pos, const string& str) | 插入字符串 |
string& insert(int pos, int n, char c) | 在指定位置插入n个字符c |
string& erase(int pos, int n = npos) | 删除从Pos开始的n个字符 |
string和c-style字符串转换
//string 转 char*
string str = "itcast";
const char* cstr = str.c_str();
//char* 转 string
char* s = "itcast";
string str(s);
注意点:
在c++中存在一个从const char到string的隐式类型转换,却不存在从一个string对象到C_string的自动类型转换。对于string类型的字符串,可以通过c_str()函数返回string对象对应的C_string. 通常,程序员在整个程序中应坚持使用string类对象,直到必须将内容转化为char时才将其转换为C_string.
#include <iostream>
#include <string>
using namespace std;
int main(int argc, char** argv)
{
string s = "abcdefg";
char& a = s[2];
char& b = s[3];
a = '1';
b = '2';
cout << s << endl;
cout << (int*)s.c_str() << endl;
s = "pppppppppppppppppppppppppp";
cout << s << endl;
cout << (int*)s.c_str() << endl;
return 0;
}
运行结果如下:
ab12efg
0xb11528
pppppppppppppppppppppppppp
0xb11a28
下面举个例子:
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include <string>
#include <stdexcept>
/*
string 构造函数
string();//创建一个空的字符串 例如: string str;
string(const string& str);//使用一个string对象初始化另一个string对象
string(const char* s);//使用字符串s初始化
string(int n, char c);//使用n个字符c初始化
3.1.2.2 string基本赋值操作
string& operator=(const char* s);//char*类型字符串 赋值给当前的字符串
string& operator=(const string &s);//把字符串s赋给当前的字符串
string& operator=(char c);//字符赋值给当前的字符串
string& assign(const char *s);//把字符串s赋给当前的字符串
string& assign(const char *s, int n);//把字符串s的前n个字符赋给当前的字符串
string& assign(const string &s);//把字符串s赋给当前字符串
string& assign(int n, char c);//用n个字符c赋给当前字符串
string& assign(const string &s, int start, int n);//将s从start开始n个字符赋值给字符串
*/
void test01(){
string str;// 默认构造
string str2(str); // 拷贝构造
string str3 = str;
string str4 = "abcd";
string str5(10,'a');
cout << str4 << endl;
cout << str5 << endl;
// 基本赋值
str = "hello";
str2 = str4;
//string& assign(const char *s, int n);//把字符串s的前n个字符赋给当前的字符串
str3.assign("abcdef",4);
cout << str3 << endl;
//string& assign(const string &s, int start, int n);//将s从start开始n个字符赋值给字符串
string str6;
str6.assign(str,1,3);//ell ? hel 从0索引
cout << str6 << endl;
}
/*
string存取字符操作
char& operator[](int n);//通过[]方式取字符
char& at(int n);//通过at方法获取字符
*/
void test02(){
string s = "hello world";
for(int i = 0;i < s.size();i++){
//cout << s[i] << endl;
cout << s.at(i) << endl;
}
//[] 和 at区别?
//[] 访问越界 直接挂掉 at会抛出异常
try{
//cout << s[100] << endl;
cout << s.at(100) << endl;
} catch(out_of_range & e){
cout << e.what() << endl;
} catch(...){
cout << "越界异常" << endl;
}
}
/*
string拼接操作
string& operator+=(const string& str);//重载+=操作符
string& operator+=(const char* str);//重载+=操作符
string& operator+=(const char c);//重载+=操作符
string& append(const char *s);//把字符串s连接到当前字符串结尾
string& append(const char *s, int n);//把字符串s的前n个字符连接到当前字符串结尾
string& append(const string &s);//同operator+=()
string& append(const string &s, int pos, int n);//把字符串s中从pos开始的n个字符连接到当前字符串结尾
string& append(int n, char c);//在当前字符串结尾添加n个字符c
3.1.2.5 string查找和替换
int find(const string& str, int pos = 0) const; //查找str第一次出现位置,从pos开始查找
int find(const char* s, int pos = 0) const; //查找s第一次出现位置,从pos开始查找
int find(const char* s, int pos, int n) const; //从pos位置查找s的前n个字符第一次位置
int find(const char c, int pos = 0) const; //查找字符c第一次出现位置
int rfind(const string& str, int pos = npos) const;//查找str最后一次位置,从pos开始查找
int rfind(const char* s, int pos = npos) const;//查找s最后一次出现位置,从pos开始查找
int rfind(const char* s, int pos, int n) const;//从pos查找s的前n个字符最后一次位置
int rfind(const char c, int pos = 0) const; //查找字符c最后一次出现位置
string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
string& replace(int pos, int n, const char* s); //替换从pos开始的n个字符为字符串s
*/
void test03(){
// 拼接
string s1 = "我";
string s2 = "爱北京";
s1 += s2;
cout << s1 << endl;
s1.append("天安门");
cout << s1 << endl;
// find查找
string s = "abcdefg";
int pos = s.find("bcf"); //找不到返回是-1
cout << "pos= " << pos << endl;
int pos2 = s.rfind("bc");//rfind 和find 结果一样,内部查找顺序相反
cout << "pos2 = " << pos2 << endl; // 4 2
//替换
string s3 = "hello"; //替换从pos开始n个字符为字符串str
s3.replace(1, 3, "1111");
cout << s3 << endl; // h1111o
}
/*
string比较操作
/*
compare函数在>时返回 1,<时返回 -1,==时返回 0。
比较区分大小写,比较时参考字典顺序,排越前面的越小。
大写的A比小写的a小。
int compare(const string &s) const;//与字符串s比较
int compare(const char *s) const;//与字符串s比较
*/
void test04()
{
string s1 = "abc";
string s2 = "abcd";
if (s1.compare(s2) == 0)
{
cout << "s1 等于 s2" << endl;
}
else if (s1.compare(s2) == 1)
{
cout << "s1 大于 s2" << endl;
}
else
{
cout << "s1 小于 s2" << endl;
}
}
/*
string子串
string substr(int pos = 0, int n = npos) const;//返回由pos开始的n个字符组成的字符串
*/
void test05()
{
string s1 = "abcde";
string s2 = s1.substr(1, 3);
cout << "s2 = " << s2 << endl;
//需求 查找一个右键的 用户名
string email = "zhangtao@sina.com";
int pos = email.find("@");//8
cout << "pos " << pos << endl;
string usrName = email.substr(0, pos);
cout << "用户名为:" << usrName << endl;
}
/*
string插入和删除操作
string& insert(int pos, const char* s); //插入字符串
string& insert(int pos, const string& str); //插入字符串
string& insert(int pos, int n, char c);//在指定位置插入n个字符c
string& erase(int pos, int n = npos);//删除从Pos开始的n个字符
*/
void test06()
{
string s1 = "hello";
s1.insert(1, "111");
cout << s1 << endl; //h111ello
//删除 111
s1.erase(1, 3);
cout << s1 << endl;
}
/*
string和c-style字符串转换
*/
void func(string s)
{
cout << s << endl;
}
void func2(const char * s)
{
cout << s << endl;
}
void test07()
{
string s = "abc";
//string -> const char *
const char * p = s.c_str();
func(p); //const char * 隐式类型转换为 string
//const char * -> string
string s2(p);
//func2(s2); //string 不能隐式类型转换为 char *
}
void test08()
{
string s = "abcdefg";
char& a = s[2];
char& b = s[3];
a = '1';
b = '2';
cout << s << endl;
cout << (int*)s.c_str() << endl;
s = "pppppppppppppp";
//a = '1';
//b = '2';
cout << s << endl;
cout << (int*)s.c_str() << endl;
}
/*
写一个函数,函数内部将string字符串中的所有小写字母都变为大写字母。
*/
void test09()
{
string s = "abCdEfg";
for (int i = 0; i < s.size();i++)
{
//s[i] = toupper(s[i]);
//全变小写
s[i] = tolower(s[i]);
}
cout << s << endl;
}
int main(){
test01();
test02();
test03();
test04();
test05();
test06();
test07();
test08();
test09();
system("pause");
return 0;
}
运行结果如下:
abcd
aaaaaaaaaa
abcd
ell
h
e
l
l
o
w
o
r
l
d
basic_string::at: __n (which is 100) >= this->size() (which is 11)
我爱北京
我爱北京天安门
pos= -1
pos2 = 1
h1111o
s1 小于 s2
s2 = bcd
pos 8
用户名为:zhangtao
h111ello
hello
abc
ab12efg
0x1d1528
pppppppppppppp
0x1d1a28
abcdefg
vector容器
vector容器基本概念
vector的数据安排以及操作方式,与array非常相似,两者的唯一差别在于空间的运用的灵活性。Array是静态空间,一旦配置了就不能改变,要换大一点或者小一点的空间,可以,一切琐碎得由自己来,首先配置一块新的空间,然后将旧空间的数据搬往新空间,再释放原来的空间。Vector是动态空间,随着元素的加入,它的内部机制会自动扩充空间以容纳新元素。因此vector的运用对于内存的合理利用与运用的灵活性有很大的帮助,我们再也不必害怕空间不足而一开始就要求一个大块头的array了。Vector的实现技术,关键在于其对大小的控制以及重新配置时的数据移动效率,一旦vector旧空间满了,如果客户每新增一个元素,vector内部只是扩充一个元素的空间,实为不智,因为所谓的扩充空间(不论多大),一如刚所说,是”配置新空间-数据移动-释放旧空间”的大工程,时间成本很高,应该加入某种未雨绸缪的考虑,稍后我们便可以看到vector的空间配置策略。
vector迭代器
Vector维护一个线性空间,所以不论元素的型别如何,普通指针都可以作为vector的迭代器,因为vector迭代器所需要的操作行为,如operaroe*, operator->, operator++, operator–, operator+, operator-, operator+=, operator-=, 普通指针天生具备。Vector支持随机存取,而普通指针正有着这样的能力。所以vector提供的是随机访问迭代器(Random Access Iterators).
根据上述描述,如果我们写如下的代码:
Vector<int>::iterator it1;
Vector<Teacher>::iterator it2;
it1的型别其实就是Int*,it2的型别其实就是Teacher*.
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
using namespace std;
int main(){
vector<int> v;
for (int i = 0; i < 10;i ++){
v.push_back(i);
cout << v.capacity() << endl; // v.capacity()容器的容量
}
system("pause");
return 0;
}
vector的数据结构
Vector所采用的数据结构非常简单,线性连续空间,它以两个迭代器_Myfirst和_Mylast分别指向配置得来的连续空间中目前已被使用的范围,并以迭代器_Myend指向整块连续内存空间的尾端。为了降低空间配置时的速度成本,vector实际配置的大小可能比客户端需求大一些,以备将来可能的扩充,这边是容量的概念。换句话说,一个vector的容量永远大于或等于其大小,一旦容量等于大小,便是满载,下次再有新增元素,整个vector容器就得另觅居所。
注意:
所谓动态增加大小,并不是在原空间之后续接新空间(因为无法保证原空间之后尚有可配置的空间),而是一块更大的内存空间,然后将原数据拷贝新空间,并释放原空间。因此,对vector的任何操作,一旦引起空间的重新配置,指向原vector的所有迭代器就都失效了。
vector常用API操作
vector构造函数
语法 | 解释 |
---|---|
vector <T> v | 采用模板实现类实现,默认构造函数 |
vector(v.begin(), v.end()) | 将v[begin(), end())区间中的元素拷贝给本身 |
vector(n, elem) | 构造函数将n个elem拷贝给本身 |
vector(const vector &vec) | 拷贝构造函数 |
vector常用赋值操作
语法 | 解释 |
---|---|
assign(beg, end) | 将[beg, end)区间中的数据拷贝赋值给本身 |
assign(n, elem) | 将n个elem拷贝赋值给本身 |
vector& operator=(const vector &vec) | 重载等号操作符 |
swap(vec) | 将vec与本身的元素互换。 |
vector大小操作
语法 | 解释 |
---|---|
size() | 返回容器中元素的个数 |
empty() | 判断容器是否为空 |
resize(int num) | 重新指定容器的长度为num,若容器变长,则以默认值填充新位置。如果容器变短,则末尾超出容器长度的元素被删除 |
resize(int num, elem) | 重新指定容器的长度为num,若容器变长,则以elem值填充新位置。如果容器变短,则末尾超出容器长>度的元素被删除 |
capacity() | 容器的容量 |
reserve(int len) | 容器预留len个元素长度,预留位置不初始化,元素不可访问。 |
vector数据存取操作
语法 | 解释 |
---|---|
at(int idx) | 返回索引idx所指的数据,如果idx越界,抛出out_of_range异常。 |
operator[] | 返回索引idx所指的数据,越界时,运行直接报错 |
front() | 返回容器中第一个数据元素 |
back() | 返回容器中最后一个数据元素 |
vector插入和删除操作
语法 | 解释 |
---|---|
insert(const_iterator pos, int count,ele) | 迭代器指向位置pos插入count个元素ele. |
push_back(ele) | 尾部插入元素ele |
pop_back() | 删除最后一个元素 |
erase(const_iterator start, const_iterator end) | 删除迭代器从start到end之间的元素 |
erase(const_iterator pos) | 删除迭代器指向的元素 |
clear() | 删除容器中所有元素 |
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include <vector>
#include <list>
using namespace std;
void test01()
{
vector<int> v;
for (int i = 0; i < 10; i++){
v.push_back(i);
cout << v.capacity() << endl; // v.capacity()容器的容量
}
}
/*
vector构造函数
vector<T> v; //采用模板实现类实现,默认构造函数
vector(v.begin(), v.end());//将v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem);//构造函数将n个elem拷贝给本身。
vector(const vector &vec);//拷贝构造函数。
//例子 使用第二个构造函数 我们可以...
int arr[] = {2,3,4,1,9};
vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));
3.2.4.2 vector常用赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
vector& operator=(const vector &vec);//重载等号操作符
swap(vec);// 将vec与本身的元素互换。
3.2.4.3 vector大小操作
size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(int num);//重新指定容器的长度为num,若容器变长,则以默认值填充新位置。如果容器变短,则末尾超出容器长度的元素被删除。
resize(int num, elem);//重新指定容器的长度为num,若容器变长,则以elem值填充新位置。如果容器变短,则末尾超出容器长>度的元素被删除。
capacity();//容器的容量
reserve(int len);//容器预留len个元素长度,预留位置不初始化,元素不可访问。
*/
void printVector( vector<int>&v)
{
for (vector<int>::iterator it = v.begin(); it != v.end();it++)
{
cout << *it << " ";
}
cout << endl;
}
void test02()
{
vector <int >v;
int arr[] = { 2, 3, 4, 1, 9 };
vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));
vector<int>v2(v1.begin(), v1.end());
printVector(v2);
vector<int>v3(10, 100);
printVector(v3);
//赋值使用
vector<int>v4;
v4.assign(v3.begin(), v3.end());
printVector(v4);
v4.swap(v2);
cout << "交换后的v4 " << endl;
printVector(v4);
cout << "v4容器的大小" << v4.size() << endl;
if (v4.empty())
{
cout << "v4空" << endl;
}
else
{
cout << "v4不空" << endl;
}
//v4 23419
v4.resize(10,-1); //第二个参数是默认值 ,默认0
printVector(v4);
v4.resize(3);
printVector(v4);
}
//巧用swap收缩空间
void test03()
{
vector<int>v;
for (int i = 0; i < 100000; i++)
{
v.push_back(i);
}
cout << "v的容量" << v.capacity() << endl;
cout << "v的大小" << v.size() << endl;
v.resize(3);
cout << "v的容量" << v.capacity() << endl;
cout << "v的大小" << v.size() << endl;
//巧用swap
vector<int>(v).swap(v);
cout << "v的容量" << v.capacity() << endl;
cout << "v的大小" << v.size() << endl;
}
//reserve(int len);//容器预留len个元素长度,预留位置不初始化,元素不可访问。
void test04()
{
vector<int>v;
v.reserve(100000); //预留出空间
int * p = NULL;
int num = 0;
for (int i = 0; i < 100000;i++)
{
v.push_back(i);
if (p!=&v[0])
{
p = &v[0];
num++;
}
}
cout << num << endl;
// 开辟100000数据用了多少次
}
/*
vector数据存取操作
at(int idx); //返回索引idx所指的数据,如果idx越界,抛出out_of_range异常。
operator[];//返回索引idx所指的数据,越界时,运行直接报错
front();//返回容器中第一个数据元素
back();//返回容器中最后一个数据元素
3.2.4.5 vector插入和删除操作
insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元素ele.
push_back(ele); //尾部插入元素ele
pop_back();//删除最后一个元素
erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素
erase(const_iterator pos);//删除迭代器指向的元素
clear();//删除容器中所有元素
*/
void test05()
{
vector<int>v;
v.push_back(10);
v.push_back(30);
v.push_back(20);
v.push_back(50);
cout << "v的front" << v.front() << endl;
cout << "v的back" << v.back() << endl;
v.insert(v.begin(), 2 ,100); //参数1 迭代器 参数2 N个数 参数3 具体插入的内容
printVector(v);
v.pop_back(); //尾删
printVector(v);
v.erase(v.begin()); //删除
printVector(v);
//v.erase(v.begin(), v.end());
//v.clear(); //清空所有数据
if (v.empty() )
{
cout << "为空" << endl;
}
}
void test06()
{
//逆序遍历
vector<int>v;
for ( int i = 0; i < 10; i++)
{
v.push_back(i);
}
// printVector(v);
//reverse_iterator 逆序迭代器
for (vector<int>::reverse_iterator it = v.rbegin(); it != v.rend();it++)
{
cout << *it << " ";
}
cout << endl;
//vector迭代器是随机访问的迭代器 支持跳跃式访问
vector<int>::iterator itBegin = v.begin();
itBegin = itBegin + 3;
//如果上述写法不报错,这个迭代器是随机访问迭代器
list<int>l;
for (int i = 0; i < 10;i++)
{
l.push_back(i);
}
list<int>::iterator lIt = l.begin();
//lIt = lIt + 1; //不支持随机访问
}
int main(){
test01();
test02();
test03();
test04();
test05();
test06();
system("pause");
return 0;
}
运行结果如下:
1
2
4
4
8
8
8
8
16
16
2 3 4 1 9
100 100 100 100 100 100 100 100 100 100
100 100 100 100 100 100 100 100 100 100
交换后的v4
2 3 4 1 9
v4容器的大小5
v4不空
2 3 4 1 9 -1 -1 -1 -1 -1
2 3 4
v的容量131072
v的大小100000
v的容量131072
v的大小3
v的容量3
v的大小3
1
v的front10
v的back50
100 100 10 30 20 50
100 100 10 30 20
100 10 30 20
9 8 7 6 5 4 3 2 1 0
deque容器
deque容器基本概念
Vector容器是单向开口的连续内存空间,deque则是一种双向开口的连续线性空间。所谓的双向开口,意思是可以在头尾两端分别做元素的插入和删除操作,当然,vector容器也可以在头尾两端插入元素,但是在其头部操作效率奇差,无法被接受。
Deque容器和vector容器最大的差异,一在于deque允许使用常数项时间对头端进行元素的插入和删除操作。二在于deque没有容量的概念,因为它是动态的以分段连续空间组合而成,随时可以增加一段新的空间并链接起来,换句话说,像vector那样,”旧空间不足而重新配置一块更大空间,然后复制元素,再释放旧空间”这样的事情在deque身上是不会发生的。也因此,deque没有必须要提供所谓的空间保留(reserve)功能.虽然deque容器也提供了Random Access Iterator,但是它的迭代器并不是普通的指针,其复杂度和vector不是一个量级,这当然影响各个运算的层面。因此,除非有必要,我们应该尽可能的使用vector,而不是deque。对deque进行的排序操作,为了最高效率,可将deque先完整的复制到一个vector中,对vector容器进行排序,再复制回deque.
deque容器实现原理
Deque容器是连续的空间,至少逻辑上看来如此,连续现行空间总是令我们联想到array和vector,array无法成长,vector虽可成长,却只能向尾端成长,而且其成长其实是一个假象,事实上(1) 申请更大空间 (2)原数据复制新空间 (3)释放原空间 三步骤,如果不是vector每次配置新的空间时都留有余裕,其成长假象所带来的代价是非常昂贵的。Deque是由一段一段的定量的连续空间构成。一旦有必要在deque前端或者尾端增加新的空间,便配置一段连续定量的空间,串接在deque的头端或者尾端。Deque最大的工作就是维护这些分段连续的内存空间的整体性的假象,并提供随机存取的接口,避开了重新配置空间,复制,释放的轮回,代价就是复杂的迭代器架构。既然deque是分段连续内存空间,那么就必须有中央控制,维持整体连续的假象,数据结构的设计及迭代器的前进后退操作颇为繁琐。Deque代码的实现远比vector或list都多得多。Deque采取一块所谓的map(注意,不是STL的map容器)作为主控,这里所谓的map是一小块连续的内存空间,其中每一个元素(此处成为一个结点)都是一个指针,指向另一段连续性内存空间,称作缓冲区。缓冲区才是deque的存储空间的主体。
deque常用API
deque构造函数
语法 | 解释 |
---|---|
deque<T> deqT | 默认构造形式 |
deque(beg, end) | 构造函数将[beg, end)区间中的元素拷贝给本身 |
deque(n, elem) | 构造函数将n个elem拷贝给本身 |
deque(const deque &deq) | 拷贝构造函数 |
deque赋值操作
语法 | 解释 |
---|---|
assign(beg, end) | 将[beg, end)区间中的数据拷贝赋值给本身 |
assign(n, elem) | 将n个elem拷贝赋值给本身 |
deque& operator=(const deque &deq) | /重载等号操作符 |
swap(deq) | 将deq与本身的元素互换 |
deque大小操作
语法 | 解释 |
---|---|
deque.size() | 返回容器中元素的个数 |
deque.empty() | 判断容器是否为空 |
deque.resize(num) | 重新指定容器的长度为num,若容器变长,则以默认值填充新位置。如果容器变短,则末尾超出容器长度的元素被删除。 |
deque.resize(num, elem) | 重新指定容器的长度为num,若容器变长,则以elem值填充新位置,如果容器变短,则末尾超出容器长度的元素被删除。 |
deque双端插入和删除操作
语法 | 解释 |
---|---|
push_back(elem) | 在容器尾部添加一个数据 |
push_front(elem) | 在容器头部插入一个数据 |
pop_back() | 删除容器最后一个数据 |
pop_front() | 删除容器第一个数据 |
deque数据存取
语法 | 解释 |
---|---|
at(idx) | 返回索引idx所指的数据,如果idx越界,抛出out_of_range。 |
operator[] | 返回索引idx所指的数据,如果idx越界,不抛出异常,直接出错 |
front() | 返回第一个数据 |
back() | 返回最后一个数据 |
deque插入操作
语法 | 解释 |
---|---|
insert(pos,elem) | 在pos位置插入一个elem元素的拷贝,返回新数据的位置 |
insert(pos,n,elem) | 在pos位置插入n个elem数据,无返回值 |
insert(pos,beg,end) | 在pos位置插入[beg,end)区间的数据,无返回值 |
deque删除操作
语法 | 解释 |
---|---|
clear() | 移除容器的所有数据 |
erase(beg,end) | 删除[beg,end)区间的数据,返回下一个数据的位置 |
erase(pos) | 删除pos位置的数据,返回下一个数据的位置 |
代码如下:
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include <deque>
#include <algorithm>
/*
deque构造函数
deque<T> deqT;//默认构造形式
deque(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。
deque(n, elem);//构造函数将n个elem拷贝给本身。
deque(const deque &deq);//拷贝构造函数。
3.3.3.2 deque赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
deque& operator=(const deque &deq); //重载等号操作符
swap(deq);// 将deq与本身的元素互换
3.3.3.3 deque大小操作
deque.size();//返回容器中元素的个数
deque.empty();//判断容器是否为空
deque.resize(num);//重新指定容器的长度为num,若容器变长,则以默认值填充新位置。如果容器变短,则末尾超出容器长度的元素被删除。
deque.resize(num, elem); //重新指定容器的长度为num,若容器变长,则以elem值填充新位置,如果容器变短,则末尾超出容器长度的元素被删除。
*/
void printDeque(const deque<int>&d)
{
//iterator 普通迭代器 reverse_iterator 逆序迭代器 const_iterator 只读迭代器
for (deque<int>::const_iterator it = d.begin(); it != d.end();it++)
{
//*it = 100000;
cout << *it << " ";
}
cout << endl;
}
void test01()
{
deque<int>d;
d.push_back(10);
d.push_back(40);
d.push_back(30);
d.push_back(20);
printDeque(d);
deque<int>d2(d.begin(), d.end());
d2.push_back(10000);
//交换
d.swap(d2);
printDeque(d);
// d2 10 40 30 20
if (d2.empty())
{
cout << "为空" << endl;
}
else
{
cout << "不为空 大小为:" <<d2.size() << endl;
}
}
/*
deque双端插入和删除操作
push_back(elem);//在容器尾部添加一个数据
push_front(elem);//在容器头部插入一个数据
pop_back();//删除容器最后一个数据
pop_front();//删除容器第一个数据
3.3.3.5 deque数据存取
at(idx);//返回索引idx所指的数据,如果idx越界,抛出out_of_range。
operator[];//返回索引idx所指的数据,如果idx越界,不抛出异常,直接出错。
front();//返回第一个数据。
back();//返回最后一个数据
3.3.3.6 deque插入操作
insert(pos,elem);//在pos位置插入一个elem元素的拷贝,返回新数据的位置。
insert(pos,n,elem);//在pos位置插入n个elem数据,无返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据,无返回值。
3.3.3.7 deque删除操作
clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据,返回下一个数据的位置。
erase(pos);//删除pos位置的数据,返回下一个数据的位置。
*/
void test02()
{
deque<int>d;
d.push_back(10);
d.push_back(30);
d.push_back(20);
d.push_front(100);
d.push_front(200);
printDeque(d); // 200 100 10 30 20
//删除 头删 尾删
d.pop_back();
d.pop_front();
printDeque(d); // 100 10 30
cout << "front: " << d.front() << endl;
cout << "back: " << d.back() << endl;
//插入
deque<int>d2;
d2.push_back(50);
d2.push_back(60);
d2.insert(d2.begin(), d.begin(), d.end());
printDeque(d2); // 100 10 30 50 60
}
//排序规则
bool myCompare(int v1, int v2)
{
return v1 > v2; // 100 10
}
//排序 sort
void test03()
{
deque<int>d;
d.push_back(5);
d.push_back(15);
d.push_back(3);
d.push_back(40);
d.push_back(7);
printDeque(d);
//排序
sort(d.begin(), d.end());
printDeque(d);
//从大到小
sort(d.begin(), d.end(), myCompare);
printDeque(d);
}
int main(){
test01();
test02();
test03();
system("pause");
return EXIT_SUCCESS;
}
运行结果如下:
10 40 30 20
10 40 30 20 10000
不为空 大小为:4
200 100 10 30 20
100 10 30
front: 100
back: 30
100 10 30 50 60
5 15 3 40 7
3 5 7 15 40
40 15 7 5 3
stack容器
stack容器基本概念
stack是一种先进后出(First In Last Out,FILO)的数据结构,它只有一个出口,形式如图所示。stack容器允许新增元素,移除元素,取得栈顶元素,但是除了最顶端外,没有任何其他方法可以存取stack的其他元素。换言之,stack不允许有遍历行为。有元素推入栈的操作称为:push,将元素推出stack的操作称为pop.
stack没有迭代器
Stack所有元素的进出都必须符合”先进后出”的条件,只有stack顶端的元素,才有机会被外界取用。Stack不提供遍历功能,也不提供迭代器。
stack常用API
stack构造函数
语法 | 解释 |
---|---|
stack<T> stkT | stack采用模板类实现, stack对象的默认构造形式 |
stack(const stack &stk) | 拷贝构造函数 |
stack赋值操作
语法 | 解释 |
---|---|
stack& operator=(const stack &stk) | 重载等号操作符 |
stack数据存取操作
语法 | 解释 |
---|---|
push(elem) | 向栈顶添加元素 |
pop() | 从栈顶移除第一个元素 |
top() | 返回栈顶元素 |
stack大小操作
语法 | 解释 |
---|---|
empty() | 判断堆栈是否为空 |
size() | 返回堆栈的大小 |
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<stack>
using namespace std;
void test()
{
stack<int> v;
v.push(10);
v.push(20);
v.push(30);
v.push(40);
while (v.empty()!=true)
{
//v.emplace();
cout << v.top() << endl;
v.pop();
}
}
int main(){
test();
system("pause");
return 0;
}
运行结果如下:
40
30
20
10
queue容器
queue容器基本概念
Queue是一种先进先出(First In First Out,FIFO)的数据结构,它有两个出口,queue容器允许从一端新增元素,从另一端移除元素。
queue没有迭代器
Queue所有元素的进出都必须符合”先进先出”的条件,只有queue的顶端元素,才有机会被外界取用。Queue不提供遍历功能,也不提供迭代器。
queue常用API
queue构造函数
语法 | 解释 |
---|---|
queue<T> queT | queue采用模板类实现,queue对象的默认构造形式 |
queue(const queue &que) | 拷贝构造函数 |
queue存取、插入和删除操作
语法 | 解释 |
---|---|
push(elem) | 往队尾添加元素 |
pop() | 从队头移除第一个元素 |
back() | 返回最后一个元素 |
front() | 返回第一个元素 |
queue赋值操作
语法 | 解释 |
---|---|
queue& operator=(const queue &que) | 重载等号操作符 |
queue大小操作
语法 | 解释 |
---|---|
empty() | 判断队列是否为空 |
size() | 返回队列的大小 |
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<queue>
using namespace std;
/*Queue所有元素的进出都必须符合”先进先出”的条件,
只有queue的顶端元素,
才有机会被外界取用。
Queue不提供遍历功能,
也不提供迭代器。*/
void test()
{
//没有迭代器
queue<int> q;
q.push(10);
q.push(20);
q.push(30);
q.push(40);
queue<int> q1;
//while (!q.empty())
//{
// cout << "队头"<<q.front() << endl;
// cout << "队尾" << q.back() << endl;
// cout << q.size() << endl;
//
// q.pop();
//}
q1 = q;
while (!q1.empty())
{
cout << "队头" << q1.front() << endl;
cout << "队尾" << q1.back() << endl;
cout << q1.size() << endl;
q1.pop();
cout << "容器所占字节" << sizeof(q1) << endl;
}
}
int main()
{
test();
system("pause");
return 0;
}
运行结果如下:
队头10
队尾40
4
容器所占字节80
队头20
队尾40
3
容器所占字节80
队头30
队尾40
2
容器所占字节80
队头40
队尾40
1
容器所占字节80
list容器
list容器基本概念
链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。相较于vector的连续线性空间,list就显得负责许多,它的好处是每次插入或者删除一个元素,就是配置或者释放一个元素的空间。因此,list对于空间的运用有绝对的精准,一点也不浪费。而且,对于任何位置的元素插入或元素的移除,list永远是常数时间。List和vector是两个最常被使用的容器。List容器是一个双向链表。
- 采用动态存储分配,不会造成内存浪费和溢出
- 链表执行插入和删除操作十分方便,修改指针即可,不需要移动大量元素
- 链表灵活,但是空间和时间额外耗费较大
list容器的迭代器
List容器不能像vector一样以普通指针作为迭代器,因为其节点不能保证在同一块连续的内存空间上。List迭代器必须有能力指向list的节点,并有能力进行正确的递增、递减、取值、成员存取操作。所谓”list正确的递增,递减、取值、成员取用”是指,递增时指向下一个节点,递减时指向上一个节点,取值时取的是节点的数据值,成员取用时取的是节点的成员。由于list是一个双向链表,迭代器必须能够具备前移、后移的能力,所以list容器提供的是Bidirectional Iterators.List有一个重要的性质,插入操作和删除操作都不会造成原有list迭代器的失效。这在vector是不成立的,因为vector的插入操作可能造成记忆体重新配置,导致原有的迭代器全部失效,甚至List元素的删除,也只有被删除的那个元素的迭代器失效,其他迭代器不受任何影响。
list容器的数据结构
list容器不仅是一个双向链表,而且还是一个循环的双向链表。
list常用API
list构造函数
语法 | 解释 |
---|---|
list lstT | list采用采用模板类实现,对象的默认构造形式 |
list(beg,end) | 构造函数将[beg, end)区间中的元素拷贝给本身 |
list(n,elem) | 构造函数将n个elem拷贝给本身 |
list(const list &lst) | 拷贝构造函数。 |
list数据元素插入和删除操作
语法 | 解释 |
---|---|
push_back(elem) | 在容器尾部加入一个元素 |
pop_back() | 删除容器中最后一个元素 |
push_front(elem) | 在容器开头插入一个元素 |
pop_front() | 从容器开头移除第一个元素 |
insert(pos,elem) | 在pos位置插elem元素的拷贝,返回新数据的位置 |
insert(pos,n,elem) | 在pos位置插入n个elem数据,无返回值 |
insert(pos,beg,end) | 在pos位置插入[beg,end)区间的数据,无返回值 |
clear() | 移除容器的所有数据 |
erase(beg,end) | 删除[beg,end)区间的数据,返回下一个数据的位置 |
erase(pos) | 删除pos位置的数据,返回下一个数据的位置 |
remove(elem) | 删除容器中所有与elem值匹配的元素。 |
list大小操作
语法 | 解释 |
---|---|
size() | 返回容器中元素的个数 |
empty() | 判断容器是否为空 |
resize(num) | 重新指定容器的长度为num,若容器变长,则以默认值填充新位置。如果容器变短,则末尾超出容器长度的元素被删除。 |
resize(num, elem) | 重新指定容器的长度为num,若容器变长,则以elem值填充新位置。如果容器变短,则末尾超出容器长度的元素被删除。 |
list赋值操作
语法 | 解释 |
---|---|
assign(beg, end) | 将[beg, end)区间中的数据拷贝赋值给本身 |
assign(n, elem) | 将n个elem拷贝赋值给本身 |
list& operator=(const list &lst) | 重载等号操作符 |
swap(lst) | 将lst与本身的元素互换 |
list数据的存取
语法 | 解释 |
---|---|
front() | 返回第一个元素 |
back() | 返回最后一个元素。 |
list反转排序
语法 | 解释 |
---|---|
reverse() | 反转链表,比如lst包含1,3,5元素,运行此方法后,lst就包含5,3,1元素 |
sort() | list排序 |
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<list>
#include<string>
using namespace std;
/*
list<T> lstT;//list采用采用模板类实现,对象的默认构造形式:
list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem);//构造函数将n个elem拷贝给本身。
list(const list &lst);//拷贝构造函数。
3.6.4.2 list数据元素插入和删除操作
push_back(elem);//在容器尾部加入一个元素
pop_back();//删除容器中最后一个元素
push_front(elem);//在容器开头插入一个元素
pop_front();//从容器开头移除第一个元素
insert(pos,elem);//在pos位置插elem元素的拷贝,返回新数据的位置。
insert(pos,n,elem);//在pos位置插入n个elem数据,无返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据,无返回值。
clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据,返回下一个数据的位置。
erase(pos);//删除pos位置的数据,返回下一个数据的位置。
remove(elem);//删除容器中所有与elem值匹配的元素。
3.6.4.3 list大小操作
size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(num);//重新指定容器的长度为num,
若容器变长,则以默认值填充新位置。
如果容器变短,则末尾超出容器长度的元素被删除。
resize(num, elem);//重新指定容器的长度为num,
若容器变长,则以elem值填充新位置。
如果容器变短,则末尾超出容器长度的元素被删除。
3.6.4.4 list赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
list& operator=(const list &lst);//重载等号操作符
swap(lst);//将lst与本身的元素互换。
3.6.4.5 list数据的存取
front();//返回第一个元素。
back();//返回最后一个元素。
3.6.4.6 list反转排序
reverse();//反转链表,比如lst包含1,3,5元素,运行此方法后,lst就包含5,3,1元素。
sort(); //list排序
*/
//自定义数据类
class Person
{
public:
Person(string name, int age, int stature)
{
this->m_name = name;
this->m_age = age;
this->m_stature = stature;
}
string m_name;
int m_age;
int m_stature;//身高
};
//排序回调函数
bool personcomper(Person &p1,Person &p2)
{
if (p1.m_age == p2.m_age)
{
return p1.m_stature < p2.m_stature;
}
else
{
return p1.m_age > p2.m_age;
}
}
//打印数据
void printpreson(list<Person> &L)
{
for (list<Person>::iterator it = L.begin(); it != L.end(); ++it)
{
cout << "姓名:" <<it->m_name << " 年龄:" <<it->m_age << " 身高:" <<it->m_stature << endl;
}
}
void test()
{
list<Person>L;
Person p1("王1", 45, 160);
Person p2("王2", 47, 178);
Person p3("王3", 43, 177);
Person p4("王4", 39, 185);
Person p5("王5", 45, 180);
Person p6("王6", 45, 170);
L.push_back(p1);
L.push_back(p2);
L.push_back(p3);
L.push_back(p4);
L.push_back(p5);
L.push_back(p6);
//反转会改变容器中的数据
L.sort(personcomper);
cout << "-------------反转前--------------" << endl;
printpreson(L);//打印数据
//L.remove(p1);
cout << "开始元素 姓名:" << L.front().m_name << " 年龄:" <<
L.front().m_age << "身高" << L.front().m_stature << endl;
cout << "最后元素 姓名:" << L.back().m_name << " 年龄:" <<
L.back().m_age << "身高" << L.back().m_stature << endl;
cout << "-------------反转后--------------" << endl;
L.reverse();
printpreson(L);//打印数据
cout << "开始元素 姓名:" << L.front().m_name << " 年龄:" <<
L.front().m_age << "身高" << L.front().m_stature << endl;
cout << "最后元素 姓名:" << L.back().m_name << " 年龄:" <<
L.back().m_age << "身高" << L.back().m_stature << endl;
}
void printint(list<int> &L)
{
for (list<int>::iterator it = L.begin(); it != L.end(); ++it)
{
cout << (*it) << " ";
}
cout << endl;
}
void test01()
{
list<int>L;
for (int i = 0; i < 5; ++i)
{
L.push_back(i);
}
for (int i = 0; i < 1000; ++i)
{
L.push_front((i * 10));
}
//cout << "L的大小:" << sizeof(L) << endl;
//printint(L);
//L.sort();
//printint(L);
//L.pop_front();
//cout << "L的大小:"<<sizeof(L) << endl;
//printint(L);
}
int main(){
test();
test01();
system("pause");
return 0;
}
运行结果如下:
-------------反转前--------------
姓名:王2 年龄:47 身高:178
姓名:王1 年龄:45 身高:160
姓名:王6 年龄:45 身高:170
姓名:王5 年龄:45 身高:180
姓名:王3 年龄:43 身高:177
姓名:王4 年龄:39 身高:185
开始元素 姓名:王2 年龄:47身高178
最后元素 姓名:王4 年龄:39身高185
-------------反转后--------------
姓名:王4 年龄:39 身高:185
姓名:王3 年龄:43 身高:177
姓名:王5 年龄:45 身高:180
姓名:王6 年龄:45 身高:170
姓名:王1 年龄:45 身高:160
姓名:王2 年龄:47 身高:178
开始元素 姓名:王4 年龄:39身高185
最后元素 姓名:王2 年龄:47身高178
set/multiset容器
set容器基本概念
Set的特性是。所有元素都会根据元素的键值自动被排序。Set的元素不像map那样可以同时拥有实值和键值,set的元素即是键值又是实值。Set不允许两个元素有相同的键值。我们可以通过set的迭代器改变set元素的值吗?不行,因为set元素值就是其键值,关系到set元素的排序规则。如果任意改变set元素值,会严重破坏set组织。换句话说,set的iterator是一种const_iterator.set拥有和list某些相同的性质,当对容器中的元素进行插入操作或者删除操作的时候,操作之前所有的迭代器,在操作完成之后依然有效,被删除的那个元素的迭代器必然是一个例外。
multiset容器基本概念
multiset特性及用法和set完全相同,唯一的差别在于它允许键值重复。set和multiset的底层实现是红黑树,红黑树为平衡二叉树的一种。
树的简单知识:二叉树就是任何节点最多只允许有两个字节点。分别是左子结点和右子节点。
二叉搜索树,是指二叉树中的节点按照一定的规则进行排序,使得对二叉树中元素访问更加高效。二叉搜索树的放置规则是:任何节点的元素值一定大于其左子树中的每一个节点的元素值,并且小于其右子树的值。因此从根节点一直向左走,一直到无路可走,即得到最小值,一直向右走,直至无路可走,可得到最大值。那么在儿茶搜索树中找到最大元素和最小元素是非常简单的事情。下图为二叉搜索树:
上面我们介绍了二叉搜索树,那么当一个二叉搜索树的左子树和右子树不平衡的时候,那么搜索依据上图表示,搜索9所花费的时间要比搜索17所花费的时间要多,由于我们的输入或者经过我们插入或者删除操作,二叉树失去平衡,造成搜索效率降低。所以我们有了一个平衡二叉树的概念,所谓的平衡不是指的完全平衡。
set常用API
set构造函数
语法 | 解释 |
---|---|
set<T> st | set默认构造函数 |
mulitset<T> mst | multiset默认构造函数 |
set(const set &st) | 拷贝构造函数 |
set赋值操作
语法 | 解释 |
---|---|
set& operator=(const set &st) | 重载等号操作符 |
swap(st) | 交换两个集合容器 |
set大小操作
语法 | 解释 |
---|---|
size() | 返回容器中元素的数目 |
empty() | 判断容器是否为空 |
set插入和删除操作
语法 | 解释 |
---|---|
insert(elem) | 在容器中插入元素 |
clear() | 清除所有元素 |
erase(pos) | 删除pos迭代器所指的元素,返回下一个元素的迭代器 |
erase(beg, end) | 删除区间[beg,end)的所有元素 ,返回下一个元素的迭代器 |
erase(elem) | 删除容器中值为elem的元素 |
set查找操作
语法 | 解释 |
---|---|
find(key) | 查找键key是否存在,若存在,返回该键的元素的迭代器;若不存在,返回set.end() |
count(key) | 查找键key的元素个数 |
lower_bound(keyElem) | 返回第一个key>=keyElem元素的迭代器 |
upper_bound(keyElem) | 返回第一个key>keyElem元素的迭代器 |
equal_range(keyElem) | 返回容器中key与keyElem相等的上下限的两个迭代器 |
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<set>
#include<string>
//#include<>
using namespace std;
/*
set构造函数
set<T> st;//set默认构造函数:
mulitset<T> mst; //multiset默认构造函数:
set(const set &st);//拷贝构造函数
3.7.2.2 set赋值操作
set& operator=(const set &st);//重载等号操作符
swap(st);//交换两个集合容器
3.7.2.3 set大小操作
size();//返回容器中元素的数目
empty();//判断容器是否为空
3.7.2.4 set插入和删除操作
insert(elem);//在容器中插入元素。
clear();//清除所有元素
erase(pos);//删除pos迭代器所指的元素,返回下一个元素的迭代器。
erase(beg, end);//删除区间[beg,end)的所有元素 ,返回下一个元素的迭代器。
erase(elem);//删除容器中值为elem的元素。
*/
//equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。
//上下限 就是lower_bound upper_bound
//class Person1
//{
//public:
// Person1(string name, int age)
// {
// this->m_name = name;
// this->m_age = age;
// }
// string m_name;
// int m_age;
//};
//void printperson(const set<Person1> &L)
//{
// for (set<Person1>::iterator it = L.begin(); it != L.end(); ++it)
// {
// cout << it->m_name << it->m_age << endl;
// }
//}
//void test01()
//{
// set<Person1>L;
// Person1 p1("马1", 45);
// Person1 p2("马2", 47);
// Person1 p3("周1", 43);
// Person1 p4("李1", 39);
// Person1 p5("任1", 45);
// Person1 p6("王1", 45);
// L.insert(p1);
// L.insert(p2);
// L.insert(p3);
// L.insert(p4);
// L.insert(p5);
// printperson(L);
//}
void test()
{
set<int> S;
S.insert(10);
S.insert(50);
S.insert(20);
S.insert(30);
S.insert(40);
for (set<int>::iterator it = S.begin(); it != S.end(); ++it)
{
cout << (*it) << endl;
}
//lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
//用迭代器接收
S.lower_bound(3);
}
//指定set排序规则
//仿函数数是一个类
class myCompare//指定排序规则时要加const
{
public:
bool operator()( int v1, int v2) const
{
return v1 < v2;
}
};
void print(set<int, myCompare> &s1)
{
for (set<int, myCompare>::iterator it = s1.begin(); it != s1.end(); ++it)
{
cout << *it << " ";
}
cout << endl;
}
void test02()
{
set<int, myCompare>s1;
s1.insert(5);
s1.insert(2);
s1.insert(3);
s1.insert(4);
s1.insert(6);
print(s1);
}
class Person
{
public:
Person(string name, int age) :m_name(name), m_age(age)
{}
string m_name;
int m_age;
};
//自定义数据类型指定排序规则时所有成员都得是const成员
class compare01
{
public:
bool operator()(const Person &p1, const Person &p2)const
{
return p1.m_age > p2.m_age;
}
};
void printperson(set<Person, compare01> &s)
{
for (set<Person, compare01>::iterator it = s.begin(); it != s.end(); it++)
{
cout << "姓名:" << it->m_name << " 年龄:" << it->m_age << endl;
}
}
void test03()
{
set<Person, compare01> s;
Person p1("马1", 35);
Person p2("马2", 36);
Person p3("任1", 37);
Person p4("李1", 38);
Person p5("周1", 39);
s.insert(p1);
s.insert(p2);
s.insert(p3);
s.insert(p4);
s.insert(p5);
printperson(s);
}
int main()
{
test();
//test01();
test02();
test03();
system("pause");
return 0;
}
运行结果如下:
10
20
30
40
50
2 3 4 5 6
姓名:周1 年龄:39
姓名:李1 年龄:38
姓名:任1 年龄:37
姓名:马2 年龄:36
姓名:马1 年龄:35
对组(pair)
对组(pair)将一对值组合成一个值,这一对值可以具有不同的数据类型,两个值可以分别用pair的两个公有属性first和second访问。类模板:template <class T1, class T2> struct pair.如何创建对组?
//第一种方法创建一个对组
pair<string, int> pair1(string("name"), 20);
cout << pair1.first << endl;
//访问pair第一个值
cout << pair1.second << endl;
//访问pair第二个值//第二种
pair<string, int> pair2 = make_pair("name", 30);
cout << pair2.first << endl;
cout << pair2.second << endl;
//pair=赋值
pair<string, int> pair3 = pair2;
cout << pair3.first << endl;
cout << pair3.second << endl;
map/multimap容器
map/multimap基本概念
Map的特性是,所有元素都会根据元素的键值自动排序。Map所有的元素都是pair,同时拥有实值和键值,pair的第一元素被视为键值,第二元素被视为实值,map不允许两个元素有相同的键值。我们可以通过map的迭代器改变map的键值吗?答案是不行,因为map的键值关系到map元素的排列规则,任意改变map键值将会严重破坏map组织。如果想要修改元素的实值,那么是可以的。Map和list拥有相同的某些性质,当对它的容器元素进行新增操作或者删除操作时,操作之前的所有迭代器,在操作完成之后依然有效,当然被删除的那个元素的迭代器必然是个例外。Multimap和map的操作类似,唯一区别multimap键值可重复。Map和multimap都是以红黑树为底层实现机制。
map/multimap常用API
map构造函数
语法 | 解释 |
---|---|
map<T1, T2> mapTT | map默认构造函数 |
map(const map &mp) | 拷贝构造函数 |
map赋值操作
语法 | 解释 |
---|---|
map& operator=(const map &mp) | 重载等号操作符 |
swap(mp) | 交换两个集合容器 |
map大小操作
语法 | 解释 |
---|---|
size() | 返回容器中元素的数目 |
empty() | 判断容器是否为空 |
map插入数据元素操作
语法 | 解释 |
---|---|
map.insert(…) | 往容器插入元素,返回pair<iterator,bool> |
第一种 通过pair的方式插入对象 | mapStu.insert(pair<int, string>(3, “小张”)) |
第二种 通过pair的方式插入对象 | mapStu.inset(make_pair(-1, “校长”)) |
第三种 通过value_type的方式插入对象 | mapStu.insert(map<int, string>::value_type(1, “小李”)) |
第四种 通过数组的方式插入值 | mapStu[3] = “小刘”;mapStu[5] = “小王”; |
map删除操作
语法 | 解释 |
---|---|
clear() | 删除所有元素 |
erase(pos) | 删除pos迭代器所指的元素,返回下一个元素的迭代器 |
erase(beg,end) | 删除区间[beg,end)的所有元素 ,返回下一个元素的迭代器 |
erase(keyElem) | 删除容器中key为keyElem的对组 |
map查找操作
语法 | 解释 |
---|---|
find(key) | 查找键key是否存在,若存在,返回该键的元素的迭代器;若不存在,返回map.end() |
count(keyElem) | 返回容器中key为keyElem的对组个数。对map来说,要么是0,要么是1。对multimap来说,值可能大于1 |
lower_bound(keyElem) | 返回第一个key>=keyElem元素的迭代器 |
upper_bound(keyElem) | 返回第一个key>keyElem元素的迭代器 |
equal_range(keyElem) | 返回容器中key与keyElem相等的上下限的两个迭代器 |
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<map>
#include<string>
using namespace std;
void test()
{
map<int, string>m1;
m1.insert(make_pair(1, "马1"));
m1.insert(make_pair(2, "任1"));
m1.insert(make_pair(3, "李1"));
m1.insert(make_pair(4, "马2"));
m1.insert(make_pair(5, "张1"));
for (map<int, string>::iterator it = m1.begin(); it != m1.end(); ++it)
{
cout << "ID:" << it->first << " 姓名:" << it->second << endl;
}
//m1.find(3)返回一个迭代器,
if (m1.find(7) != m1.end())
{
cout << "----------找到------------" << endl;
cout << "ID:" << m1.find(3)->first << " 姓名:" << m1.find(3)->second << endl;
}
else
{
cout << "未找到" << endl;
}
}
//3.8.2.6 map查找操作
//find(key);//查找键key是否存在,若存在,返回该键的元素的迭代器;/若不存在,返回map.end();
//count(keyElem);//返回容器中key为keyElem的对组个数。对map来说,要么是0,要么是1。对multimap来说,值可能大于1。
//lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
//upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
//equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。
void test01()
{
map<int, int>m;
m.insert(make_pair(1, 10));
m.insert(make_pair(2, 20));
m.insert(make_pair(3, 30));
m.insert(make_pair(4, 40));
for (map<int, int>::iterator it = m.begin(); it != m.end(); ++it)
{
//打印key值
cout << "key:" << (*it).first << " value:" << it->second << endl;
}
//m.erase(key
m.erase(3);
cout << "----------删除后-------------" << endl;
for (map<int, int>::iterator it = m.begin(); it != m.end(); ++it)
{
//打印key值
cout << "key:" << (*it).first << " value:" << it->second << endl;
}
}
int main()
{
test();
test01();
system("pause");
return 0;
}
运行结果如下:
ID:1 姓名:马1
ID:2 姓名:任1
ID:3 姓名:李1
ID:4 姓名:马2
ID:5 姓名:张1
未找到
key:1 value:10
key:2 value:20
key:3 value:30
key:4 value:40
----------删除后-------------
key:1 value:10
key:2 value:20
key:4 value:40
STL容器使用时机
vector | deque | list | set | multiset | map | multimap | |
---|---|---|---|---|---|---|---|
典型内存结构 | 单端数组 | 双端数组 | 双向链表 | 二叉树 | 二叉树 | 二叉树 | 二叉树 |
可随机存取 | 是 | 是 | 否 | 否 | 否 | 对key而言:不是 | 否 |
元素搜寻速度 | 慢 | 慢 | 非常慢 | 快 | 快 | 对key而言:快 | 对key而言:快 |
元素安插移除 | 尾端 | 头尾两端 | 任何位置 | - | - | - | - |
- vector的使用场景:比如软件历史操作记录的存储,我们经常要查看历史记录,比如上一次的记录,上上次的记录,但却不会去删除记录,因为记录是事实的描述。
- deque的使用场景:比如排队购票系统,对排队者的存储可以采用deque,支持头端的快速移除,尾端的快速添加。如果采用vector,则头端移除时,会移动大量的数据,速度慢。
vector与deque的比较:
一:vector.at()比deque.at()效率高,比如vector.at(0)是固定的,deque的开始位置却是不固定的。
二:如果有大量释放操作的话,vector花的时间更少,这跟二者的内部实现有关。
三:deque支持头部的快速插入与快速移除,这是deque的优点。 - list的使用场景:比如公交车乘客的存储,随时可能有乘客下车,支持频繁的不确实位置元素的移除插入。
- set的使用场景:比如对手机游戏的个人得分记录的存储,存储要求从高分到低分的顺序排列。
- map的使用场景:比如按ID号存储十万个用户,想要快速要通过ID查找对应的用户。二叉树的查找效率,这时就体现出来了。如果是vector容器,最坏的情况下可能要遍历完整个容器才能找到该用户。