c++ STL常用容器使用(vector、deque、stack、queue、list、set、map等)

1、vector 使用

动态数组，也叫可变数组，容器的空间是动态增长的，当空间不足时，申请更大一块空间，让后将原数据拷贝到新空间中，并释放原空间

1.1、初始化操作

    int arr[] = {1,3,2,5};
    // 1、方式一(初始化)
    vector<int> v1;
    // 容器尾部插入数据
    v1.push_back(1);    
    v1.push_back(2);
    v1.pop_back(); // 尾部删除一个元素

    // 2、方式二(初始化)
    vector<int> v2(arr,arr+sizeof(arr)/sizeof(arr[0]));

    // 3、方式三(初始化)
    vector<int> v3(v2);

    // 4、方式4(初始化)
    vector<int> v4(v2.begin(),v2.end());

    // 5、方式5(初始化) 给n个elem
    vector<int> v5(10,2);  

1.2、赋值操作

    // 将v5区间的数据拷贝给v4
    v4.assign(v5.begin(),v5.end());
    
    // 将2个3拷贝复制给v4
    v4.assign(2,3);
    
    // 重载了=， 将v1的内容复制给v4
    v4 = v1;
    
    // 交换
    v4.swap(v3);

1.3、元素个数，容器容量

    cout<<v4.size()<<endl;  // v4的元素个数
    cout<<v4.capacity()<<endl;// v4容量
    cout<<v4.empty()<<endl; // 判断容器是否为空，为空时true
    v4.resize(10);  // 重新指定大小
    v4.reserve(12); // 容器预留12个元素，预留不初始化，元素不可以访问
    cout<<v4.capacity()<<endl;
    
    // 利用swap收缩空间
    vector<int>(v4).swap(v4);
    cout<<v4.size()<<endl;
    cout<<v4.capacity()<<endl;

1.4、取值操作

    cout<<v4.at(0)<<endl;   // 越界抛出异常
    cout<<v4[0]<<endl;  //  越界直接奔溃
    cout<<v4.front()<<endl; // 返回容器第一个元素
    cout<<v4.back()<<endl;  // 返回容器最后一个元素
    v4.insert(v4.begin(),4,1);  // 开始位置插入4个1
    v4.erase(v4.begin());   // 删除迭代器制定元素
    v4.clear(); //  清除所有元素

1.5、测试代码

#include 
#include 

using namespace std;

void print_vector(vector<int>& p)
{   // 通过迭代器遍历容器
    for(vector<int>::iterator it=p.begin(); it!= p.end(); it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
}

void test01()
{
    int arr[] = {1,3,2,5};
    // 1、方式一(初始化)
    vector<int> v1;
    // 容器尾部插入数据
    v1.push_back(1);    
    v1.push_back(2);
    v1.pop_back(); // 尾部删除一个元素
    print_vector(v1);

    // 2、方式二(初始化)
    vector<int> v2(arr,arr+sizeof(arr)/sizeof(arr[0]));
    print_vector(v2);

    // 3、方式三(初始化)
    vector<int> v3(v2);
    print_vector(v3);

    // 4、方式4(初始化)
    vector<int> v4(v2.begin(),v2.end());
    print_vector(v4);

    // 5、方式5(初始化) 给n个elem
    vector<int> v5(10,2);  
    print_vector(v5);

    // 赋值操作
    // 将v5区间的数据拷贝给v4
    v4.assign(v5.begin(),v5.end());
    print_vector(v4);
    
    // 将2个3拷贝复制给v4
    v4.assign(2,3);
    print_vector(v4);
    // 重载了=， 将v1的内容复制给v4
    v4 = v1;
    print_vector(v4);
    // 交换
    v4.swap(v3);
    print_vector(v4);

    cout<<v4.size()<<endl;  // v4的元素个数
    cout<<v4.capacity()<<endl;// v4容量
    cout<<v4.empty()<<endl; // 判断容器是否为空，为空时true
    v4.resize(10);  // 重新指定大小
    v4.reserve(12); // 容器预留12个元素，预留不初始化，元素不可以访问
    cout<<v4.capacity()<<endl;

    // 利用swap收缩空间
    vector<int>(v4).swap(v4);
    cout<<v4.size()<<endl;
    cout<<v4.capacity()<<endl;

    // 取值
    cout<<v4.at(0)<<endl;   // 越界抛出异常
    cout<<v4[0]<<endl;  //  越界直接奔溃
    cout<<v4.front()<<endl; // 返回容器第一个元素
    cout<<v4.back()<<endl;  // 返回容器最后一个元素
    v4.insert(v4.begin(),4,1);  // 开始位置插入4个1
    print_vector(v4);
    v4.erase(v4.begin());   // 删除迭代器制定元素
    print_vector(v4);
    v4.clear(); //  清除所有元素

}

2、deque 双向数组

deque容器对比vector，支持插入删除容器头部元素，其他部分使用方法都一样，通过下面小案例使用

#include 
#include 
#include 
#include 
#include 
using namespace std;

/*
评委打分案例（sort算法排序）
创建5个选手（姓名，得分），10个评委对5个选手进行打分
得分规则去掉最高分，去掉最低分，取平均分
按得分对5名选手进行排名
*/

class player
{
public:
    player()
    {

    }
    player(string name,int score):mName(name),mscore(score)
    {

    }
    string mName;
    int mscore;
};

void create_play(vector<player>& v)
{
    string nameseed = "ABCDE";
    for(int i=0;i<5;i++)
    {
        player p;
        p.mName = "选手";
        p.mName += nameseed[i];
        p.mscore = 0;
        v.push_back(p);
    }
}


void fun2(int val)
{
    cout<<val<<" ";
}

void set_Score(vector<player>& v)
{	// 遍历vector容器
    for(vector<player>::iterator it=v.begin();it!=v.end();it++)
    {
        deque<int> dScore;
        // 模拟进行打分
        for(int j=0;j<10;j++)
        {	// 随机生成分数
            int score = rand()%41+60;
            dScore.push_back(score);
        }
        // 对分数排序，默认从小到大
        sort(dScore.begin(),dScore.end());
        dScore.pop_front();
        dScore.pop_back();
        // 求平均分
        int totalScore = 0;
        for(deque<int>::iterator dit=dScore.begin();dit!=dScore.end();dit++)
        {
            totalScore += (*dit);
        }
        int avg = totalScore/dScore.size();
        // 保存分数
        (*it).mscore = avg;

        // for_each(dScore.begin(),dScore.end(),fun2);
    }
}

// 排序规则
bool mycompare(player& p1,player& p2)
{
    return p1.mscore>p2.mscore;
}

void print_rank(vector<player>& v)
{
    // 排序
    sort(v.begin(),v.end(),mycompare);    
    // 打印
    for(vector<player>::iterator it = v.begin();it!=v.end();it++)
    {
        cout<<"姓名："<<(*it).mName<<"得分："<<(*it).mscore<<endl;
    }
}

int main()
{
    // 定义vector容器，保存选手信息学
    vector<player> vplist;
    create_play(vplist);
    set_Score(vplist);
    print_rank(vplist);

    return 0;
}

3、stack、queue（栈，队列）

栈：先进后出
队列：先进先出
两者都，不提供迭代器，不能遍历，不支持随机存取

3.1、stack简单使用

#include 
    stack<int> s1;
    s1.push(1);
    s1.push(3);
    s1.push(4);
    s1.push(2); // 插入元素
    cout<<s1.size();    // 元素个数
    while(!s1.empty())
    {
        cout<<s1.top()<<" ";    // 返回栈顶元素
        s1.pop();   // 删除栈顶元素
    }
    cout<<endl;

3.2、queue队列简单使用

    queue<int> q1;
    q1.push(3);
    q1.push(1);
    q1.push(4);
    q1.push(2); // 插入元素
    cout<<q1.front()<<endl; // 返回第一个元素 3
    cout<<q1.back()<<endl;  // 返回最后一个元素2
    cout<<q1.size()<<endl;  // 返回大小
    while(!q1.empty())
    {
        cout<<q1.front()<<" ";
        q1.pop();   // 删除队列头元素
    }
    cout<<endl;

4、list 链表

list是一个双向链表容器，插入删除元素比较高效
list不可以随机存取元素，

    list<int> l1;		// 其他初始化方式和上面容器用法一样
    l1.push_back(11);   // 尾部插入
    l1.push_front(12);  // 头尾插入
    l1.push_back(12);
    l1.push_back(31);
    l1.push_back(21);

    l1.pop_front(); // 头部删除
    l1.pop_back();  // 尾部删除

    l1.insert(l1.begin(),2,3);  // 开始位置插入2个3

    l1.erase(l1.begin());   // 删除第一个元素
    l1.remove(12);  // 删除元素中所有12 

    l1.size();  // 容器元素个数
    l1.empty(); // 容器是否为空
    l1.resize(10);  // 重新指定容器长度

    l1.reverse();   /// 反转链表
    l1.sort();	// 排序
  	// 链表自带排序
    // 因为 sort 只支持可随机访问的容器，list不可以

5、set/multiset

set和multiset区别：
set不支持插入重复值
multiset支持

常用API：
clear()
erase(迭代器)
erase(迭代器区间)
erase(elem) // 删除容器中值为elem元素
find(key) // 查找key是否存在，返回改键的元素迭代器，若不存在，返回set.end()
count(key) // 统计key的元素个数

通过仿函数给自定义数据类型，排序

#include 
#include 
#include 

using namespace std;

// 自定义数据类型
class Person
{
public:
    Person(string name,int age,int height)
    {
        this->m_name = name;
        this->m_age = age;
        this->m_height = height;
    }
    string m_name;
    int m_age;
    int m_height;
};


class comparaPerson
{
public:
// 仿函数
    bool operator()(const Person&p1,const Person& p2)
    {
        return p1.m_age<p2.m_age;
    }
};

int main()
{
    set<Person,comparaPerson> s1;
    Person p1("刘备",44,125);
    Person p2("关羽",123,155);
    Person p3("张飞",32,115);
    Person p4("赵云",12,175);
    Person p5("曹操",35,115);
    Person p6("小乔",35,145);
    Person p7("大乔",45,125);

    s1.insert(p1);
    s1.insert(p2);
    s1.insert(p3);
    s1.insert(p4);
    s1.insert(p5);
    s1.insert(p6);
    s1.insert(p7);

    for(set<Person,comparaPerson>::iterator it=s1.begin();it!=s1.end();it++)
    {
        cout<<it->m_name<<" "<<it->m_age<<" "<<it->m_height<<endl;
    }

    return 0;
}

6、pair

pair<string,int> p1;
p1 = make_pair("刘备",111); // 初始化
cout<<p1.first<<" "<<p1.second<<endl;

7、map/multimap

pair第一个键，第二个值
所有元素都会根据元素的键值自动进行排序(从小到大)
map和multimap区别：map不允许容器中有重复的key值，multimap允许

size()  // 元素个数
swap()  // 交换
erase(m.begin())    // 删除第一个元素
erase(m.begin(),m.end())    // 区间删除
erase(3)   // 按照key的方式删除 
find(key) // 按照key的方式操作，如果有返回元素迭代器，若不存在，返回end();
cout(key)   // 统计key元素个数

#include 
// 插入：四种方式，前三种，存在就插入失败
mymap.insert(pair<int,int>(10,10)); 
mymap.insert(make_pair(10,10));
mymap.insert(map<int,int>::value_type(10,10));

mymap[40] = 40  // 不存在就插入，存在就替换value