C++ 对模板（Template）支持得很好，STL 就是借助模板把常用的数据结构及其算法都实现了一遍，并且做到了数据结构和算法的分离。例如，vector 的底层为顺序表（数组），list 的底层为双向链表，deque 的底层为循环队列，set 的底层为红黑树，hash_set 的底层为哈希表。
基础使用
Vector
旧空间不足而重新配置一块更大空间，然后复制元素，再释放旧空间
#include <iostream>
#include <vector>
using namespace std;
int main(){
vector<int> v;
for (int i = 0; i < 5; i++)
{
v.push_back(i);
}
//vector的迭代器不支持it<v.end()的写法，因此循环条件只能it!=v.end()
for (vector<int>::iterator it=v.begin(); it!=v.end();it++)
{
cout<<*it<<" ";
}
return 0;
}void std::vector<int>::push_back(const int &__x);
void std::vector<int>::pop_back();
std::size_t std::vector<int>::size();
void std::vector<int>::clear();
insert(__position,__x);
erase(__position);
erase(__positionBegin,__positionEnd);void PrintVector(vector<int>& v)
{
for (auto x : v)
{
cout << x << " ";
}
cout << endl;
}
vector<int> v1; //1.默认构造，无参构造
for (int i = 0; i < 10; ++i)
{
v1.push_back(i);
}
PrintVector(v1);
//2.利用区间方式构造
vector<int> v2(v1.begin(), v1.end());
PrintVector(v2);
//3.n个element方式构造
vector<int> v3(10, 100); //10个100
PrintVector(v3);
//4.拷贝构造
vector<int> v4(v3);
PrintVector(v4);
//直接赋值
vector<int> v2;
v2 = v1;
//assign赋值
vector<int> v3;
v3.assign(v1.begin(), v1.end());
//n个element赋值
vector<int> v4;
v4.assign(10, 100);Set
#include <iostream>
#include <set>
using namespace std;
//除了vector和string之外的STL容器都不支持*(it+i)的访问方式，因此只能按照如下方式枚举
int main()
{
set<int> st;
st.insert(5);
st.insert(2);
st.insert(6);
for (set<int>::iterator it = st.begin(); it != st.end(); it++)
{
cout << *it << endl;
}
return 0;
}#include <set>
#include <iostream>
int main(void)
{
set<char> st;
st.insert('C');
set<int>::iterator it = st.find('C'); //在set中查找2，返回其迭代器
cout << *it << endl;
st.erase(st.find('C'));
set<char>::iterator it = st.find('A');
st.erase(it, st.end()); // erase elems after A
cout << st.size() << endl;
return 0;
}仿函数
#include <iostream>
#include <set>
#include "print.h"
using namespace std;
class MyCompare{
public:
//仿函数
bool operator()(int v1, int v2) const
{
return v1 > v2; //降序排列
}
};
int main()
{
set<int> s1;
s1.insert(10);
s1.insert(60);
s1.insert(30);
s1.insert(20);
s1.insert(90);
s1.insert(70);
print(s1); //默认升序
//降序显示
set<int, MyCompare> s2;
s2.insert(10);
s2.insert(20);
s2.insert(90);
s2.insert(70);
for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); ++it)
{
cout << *it << " ";
}
cout << endl;
}Deque
#include <deque>
deque<int> d1;
for (int i = 0; i < 10; ++i)
{
d1.push_back(i);
}
deque<int> d2(d1);
deque<int> d3(10, 100);
deque<int> d4;
d4 = d3;
if (d1.empty())
{
cout << "deque容器为空" << endl;
}
else
{
cout << "deque容器不为空" << endl;
cout << "deque容器的大小为：" << d1.size() << endl;
//deque容器无capacity - 容量
}
//改变大小
//d1.resize(15);
d1.resize(15,1);
print(d1);
d1.resize(5);
print(d1);
//首尾操作
deque<int> d;
d.push_back(10);
d.push_back(20); //尾插
d.push_front(100);
d.push_front(200); //头插
print(d); //200 100 10 20
d.pop_back(); //尾删
d.pop_front(); //头删
print(d); //100 10List
#include <list>
list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem);//构造函数将n个elem拷贝给本身。
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值匹配的元素。Array (C++11)
#include <array>
#include <iostream>
using namespace std;
int main()
{
array<int,5> a = {1,2,3,4,5};
for(auto i:a)
{
std::cout << "value is " << i << std::endl;
}
return 0;
}Priority_queue
#include <queue>
priority_queue<int,vector<int>,greater<int>> q;
q.push(9);
q.push(2);
q.push(7);
q.push(3);
q.push(-8);
q.push(1);实际题目
评委打分 vec+deque
void SetScore(vector<Person>& v)
{
int avg = 0;
srand((unsigned int)time(NULL)); //随机化种子
for (vector<Person>::iterator it = v.begin(); it != v.end(); ++it) //每位选手的外层遍历（5）
{
//将评委的打分放入deque容器
deque<int> d;
for (int i = 0; i < 10; ++i)
{
int score = rand() % 41 + 60; //评委随机打分40~60
d.push_back(score);
}
//观察评委打分情况
cout<< it->m_name << "的十位评委打分为：" << endl;
for (deque<int>::iterator dit = d.begin(); dit != d.end(); ++dit) //每位评委的内层遍历（10）
{
cout << *dit << " ";
}
cout << endl;
//排序
sort(d.begin(), d.end());
//去除最高分和最低分
d.pop_back();
d.pop_front();
//取平均数
int sum = 0; //放入循环内部，累加完一个玩家的十位评委的总分置零重新记数
for (deque<int>::iterator dit = d.begin(); dit != d.end(); ++dit) //每位评委的内层遍历（10）
{
sum += *dit; //累加每位玩家十位评委的打分
}
cout << "总分为：" << sum << " ";
cout << endl<<endl;
avg = sum / d.size(); //计算每一位玩家的平均分
it->m_score = avg;
}
}员工分组
#include <iostream>
#include <vector>
#include <map>
#include <ctime>
#include <iterator>
#include <string>
using namespace std;
#define CH 0 //策划部
#define MS 1 //美术部
#define YF 2 //研发部
class Person {
public:
string m_name;
int m_salary;
};
void CreateWorker(vector<Person>& v)
{
string NameSeed = "ABCDEFGHIJ";
for (int i = 0; i < 10; ++i)
{
//编号
Person p;
p.m_name = "员工";
p.m_name += NameSeed[i];
//薪水
p.m_salary = rand() % 10000 + 10000; //10000~19999
v.push_back(p);
}
}
void SetGroup(vector<Person>& v, multimap<int, Person>& m)
{
for (vector<Person>::iterator it = v.begin(); it != v.end(); ++it)
{
//随机化三个部门
int dep = rand() % 3; //0~2
//key：部门 value：员工
m.insert(pair<int, Person>(dep, *it)); //将十个员工放入三个部门
}
}
void ShowGroup(multimap<int, Person>& m)
{
//策划部（0） A B C
int count1 = m.count(CH); // 统计策划部的人数
multimap<int,Person>::iterator pos=m.find(CH); //查找
cout << "策划部" << endl;
for (int index = 0; pos != m.end() && index < count1; ++pos,index++)
{
cout << "编号：" << pos->second.m_name<< "\t薪水：" << pos->second.m_salary << endl;
}
cout << "---------------------------------" << endl;
//美术部（1） D E F
int count2 = m.count(MS); // 统计美术部的人数
pos = m.find(MS); //查找
cout << "美术部" << endl;
for (int index = 0; pos != m.end() && index < count2; ++pos,index++)
{
cout << "编号：" << pos->second.m_name << "\t薪水：" << pos->second.m_salary << endl;
}
cout << "---------------------------------" << endl;
//研发部（2） G H I J
int count3 = m.count(YF); // 统计美术部的人数
pos = m.find(YF); //查找
cout << "研发部" << endl;
for (int index = 0; pos != m.end() && index < count3; ++pos,index++)
{
cout << "编号：" << pos->second.m_name << "\t薪水：" << pos->second.m_salary << endl;
}
cout << "---------------------------------" << endl;
}
void test()
{
srand((unsigned int)time(NULL));
vector<Person> vWorker;
//创建10个员工
CreateWorker(vWorker);
//初始化测试
/*for (vector<Person>::iterator it = vWorker.begin(); it != vWorker.end(); ++it)
{
cout << "编号：" << it->m_name << "\t薪水：" << it->m_salary << endl;
}
cout << "---------------------------------" << endl;*/
//员工分组
multimap<int,Person> mWorker;
SetGroup(vWorker, mWorker);
//显示员工分组
ShowGroup(mWorker);
}
int main(void)
{
test();
return 0;
}相关面试-底层原理
问：vector的实现与增长（提问概率：★★★★★）
vector是stl提供的动态数组，想了解他就要从他的特性开始分析。首先，他是一个模板类，意味着可以存放各种类型的元素，同时他也是一个数组，存储是连续的。 里面保存了三个指针，分别指向头、数据尾、数组尾。
内存分配:常规的数组必须在定义的时候就分配好固定的大小，而vector可以动态的改变，也就说明他可以动态的申请与释放内存。我们要知道，频繁的申请与释放内存对程序的效率影响是非常大的，因为如果当前地址空间不够用的话，就需要重新找一块更大的空间来装数据，再把数据全部都拷贝过去。所以vector为了达到比较好的效果，在添加元素的时候会多申请一定大小的内存，从而减少内存分配的次数。capacity()返回的就是包括缓冲区在内的空间大小，而size()返回的就是当前实际使用的空间大小。
如果想主动的提前分配内存，可以使用reserve(n)，如果n大于当前的capacity就会强制重新分配一次内存，超出实际使用的部分就会成为缓存区。如果想直接构造出长度为n的动态数组可以使用resize(n)，会严格使其size大小为n，如果n比当前size小的话，大于size的数据都会被清空移除；如果n比当前size大比capacity小，就会添加额外的元素（新增的元素可以是默认值，也可以是传入的参数）；如果比capacity还大的话还会重新执行一次内存分配（并不一定要调用reverse，直接分配）新的空间的大小为_Oldcapacity + _Oldcapacity / 2（如果n>_Oldcapacity + _Oldcapacity / 2，那么新的内存空间大小就是n）
关于内存释放，如果只是简单的调用 clear()全部清空数据，erase()清空部分数据都只是单纯的清空里面的数据并不会释放掉。默认只会在调用vector的析构函数的时候才会真正释放空间，所以如果想强制释放内存空间，正式的做法是resize（0），然后调用C++11的shrink_to_fit()。C++11之前有一个特殊的方法，那就是新建一个空的vector，然后与这个vector使用swap进行内存交换，那么原来的vector就会释放。另外，由于涉及到模板，也就会涉及到迭代器，凡是重新申请过内存，插入删除数据的，迭代器都会失效，理解上也很容易就是指针可能指向的不是你原来的那个位置了。
问：map的实现 unordered_map的原理；如果从空的table开始一直增加元素，会出现什么情况？（提问概率：★★★★★）
map分为有序map和无序map（unordered_map），实现的基本数据结构分别是红黑树与哈希表。(set同理)里面每一个元素是一个pair< const key_type,mapped_type >类型，注意key是const的，不可以修改。对于一个数据结构，常见的操作无非是查找，插入，删除。红黑树作为一种二叉搜索树，具有log(n)的查找效率，不过前提是数据具有足够的随机性。！！！
hashmap理想上则是具有常数平均时间的效率，或者说一次或几次就可以查到，当然如果数据量过大，散列表空间就不能和数据量保持1：1，这时候就要靠hash函数来处理数据，将数据尽可能的分散在不同的桶bucket里面。
sgi stl的hash使用的是开链操作来避免hash表空间过大又想保持一定效率的问题，开链就是在一个位置用链表来存储所有冲突项。其实hashmap里面常说的桶bucket就是vector数组的一个元素，每个桶里面的数据是以链表(开链)的形式存储，进一步来说这些操作与定义都是通过一个基本的数据结构hashtable来实现的，所有的无序关联容器都是。hashtable里面的hash函数就是常说的取模函数，根据存储数据key值(注意，是对key而不是value)对桶的长度取余数来存放。默认提供的hash函数无法处理常见内置类型以外的数据，如各种自定义类，其实string本身也算是特殊类型，但是语言内部可以转为const char*处理，他经过函数处理也会得到一个size类型（一般对字符串的哈希函数比较特别，参考各种字符串Hash函数比较）。
什么时候需要rehash？当你的桶里面的平均数量（Map大小/桶的数量）大于max(这个可以自己设置)，就需要rehash。也可以主动调用rehash(n),保证桶的数量大于n，注意n是桶的数量。改变桶的数量就相当于改变Vector的长度，如果超过vector的capacity就会调用Vector的扩容机制（但是实际上他每次hash的时候都会直接调用vector的reserve进行扩容）。
什么时候执行reserve（Java里好像是resize）？注意map的reserve与vector的reserve不一样，他的目的并不是扩容，而是希望当前哈希表里面可以容纳n个元素。如果n>桶的数量*负载因子的时候就会触发rehash，否则不会触发。rehash有可能进一步触发vector的扩容。参考下面的英文注释。
问：stl里heap与priority_queue？（提问概率：★★）
heap是基于vector来实现的，不过他不属于容器组件，因为他的主要是为优先级队列priority_queue的实现提供基础结构。所谓的优先级队列，其实就是队首元素一定是当前队列中优先级最高的那一个，只能通过 top() 函数来访问队首元素。我们知道最大堆与最小堆拥有这种特性，所以很适合用来实现priority_queue，当然其他数据结构也可以实现，不过从实现复杂度与计算复杂度等方面heap最为合适。
问：stl里面各个容器的基础数据结构是？（提问概率：★★★★）
图截自STL源码分析一书，常问的是优先级队列，hashmap，map底层的数据结构是什么。答案分别是Vector，hashtable以及RB—tree（红黑树），具体细节大家可以仔细看一下关于容器的这两章内容。
123
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
