Oreo's Blog

C++学习笔记（十一）

2022/1/9 C++

# 一、set容器和multiset容器

# 1.1set基本概念

  • 特点：所有元素都会在插入时自动被排序

set/multiset属于关联式容器，底层结构使用二叉树实现

set和multi的区别：

  • set不允许容器中有重复的元素
  • multiset允许容器中有重复元素

# 1.2set构造与赋值

  • set<T> st;默认构造函数
  • set(const set &st);拷贝构造函数
  • se& operate = (const set &st);重载等号操作符
#include "iostream"
#include "set"
using namespace std;

void printSet(const set<int> &s) {
    for(set<int>::const_iterator it = s.begin(); it != s.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}

int main() {
    set<int> s1;
    // 插入数据只有insert的方式
    s1.insert(10);
    s1.insert(30);
    s1.insert(20);
    printSet(s1);

    // 拷贝构造
    set<int> s2(s1);
    printSet(s2);

    // 复制构造
    set<int> s3 = s2;
    printSet(s3);
}

# 1.3set大小和交换

统计set容器大小以及交换set容器

  • size()返回容器中的元素数目
  • empty()判断容器是否为空
  • swqp(st)交换两个集合容器

# 1.4set插入和删除

  • insert(elem)在容器中插入元素
  • clear()清楚所有元素
  • erase(pose)删除pose迭代器所指的元素，返回下一个元素的迭代器
  • erase(beg, end)删除区间[beg,end)的所有元素，返回下一个元素的迭代器
  • erase(elem)删除容器中值为elem的元素
int main() {
    // 插入元素
    set<int> s;
    s.insert(10);
    s.insert(20);
    s.insert(30);
    s.insert(40);
    printSet(s);

    // 删除元素（指定位置）
    s.erase(s.begin());
    printSet(s);

    // 删除元素（删除区间）
    s.erase(s.begin(), s.end());
    printSet(s);

    // 清空
    s.clear();
    printSet(s);
}

# 1.5set查找与统计

  • find(key)查找key是否存在，如果存在的话就返回该值的迭代器，若不存在就返回set.end()
  • count(key)统计key的元素个数（结果只能是0和1）
int main() {
    set<int> s;
    s.insert(10);
    s.insert(20);
    s.insert(30);
    s.insert(30);
    s.insert(30);
    s.insert(40);

    set<int> ::iterator pos = s.find(10);
    cout << *pos << endl;

    cout << s.count(30) << endl;
}

# 1.6set和multiset

  • set不可以插入重复的元素，但是multiset可以
  • set插入数据的同时会返回插入的结果，表示插入是否成功
  • multiset不会监测数据，所以可以插入重复的元素

# 1.7set容器排序

set容器中的默认排序规则为从小到大，如何改变排序规则--可以使用放函数

// 仿函数修改排序规则
class compare {
public:
    bool operator()(int v1, int v2) {
        return v1 > v2;
    }
};

void printSet(const set<int, compare> &s) {
    for(set<int, compare>::const_iterator it = s.begin(); it != s.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}

int main() {
    set<int, compare> s;
    s.insert(10);
    s.insert(20);
    s.insert(30);
    s.insert(30);
    s.insert(30);
    s.insert(40);
    printSet(s);
}

# 二、pair队组容器

成对出现的数据，利用队组可以返回两个数据

队组是不需要引入头文件的

  • pair<type, type> p(value1, value2)
  • pair<type, type> p = make_pair(value1, value2)
#include "iostream"
#include "string"
using namespace std;

int main() {
    pair<string, int> p1("Tom", 10);
    cout << p1.first << "：" << p1.second << endl;

    pair<string, int> p2 = make_pair("Jerry", 8);
    cout << p2.first << "：" << p2.second << endl;
}

# 三、map容器和multimap容器

# 3.1map基本概念

  • map容器中的所有元素都是pair
  • pair中第一个元素为key（键值），起到索引的作用，第二个元素被称为value（实值）
  • 所有元素都会根据元素的键值key进行排序

本质：map/multimap属于关联式容器，底层结构通过二叉树实现

优点：可以根据key值快速找到value

map和multimap的区别在于map不允许容器中有重复的key而multimap可以

# 3.2map构造与赋值

  • map<T1, T2> mp;默认构造
  • map(const map &mp);拷贝构造函数
  • map& operator=(const map &mp);重载等号操作符
//
// Created by Jacob Lee on 2022/1/8.
//
#include "iostream"
#include "string"
#include "map"
using namespace std;

void printMap(const map<int, int> &m) {
    for (map<int, int>::const_iterator it = m.begin(); it != m.end(); it++) {
        cout << it->first << ": " << it->second << endl;
    }
}

int main() {
    // 初始化map
    map<int, int> m1;
    // 插入元素（将匿名的队组加入map中）
    m1.insert(pair<int, int>(1, 10));
    m1.insert(pair<int, int>(2, 20));
    m1.insert(pair<int, int>(3, 30));
    m1.insert(pair<int, int>(4, 40));

    printMap(m1);

    // 拷贝构造
    map<int, int> m2(m1);
    printMap(m2);

    // 赋值
    map<int, int> m3;
    m3 = m3;
    printMap(m3);
    return 0;
}

# 3.3map大小和交换

  • size();返回容器中元素的数目
  • empty();判断容器中是否为空
  • swap(st);交换两个集合容器

# 3.4map元素插入删除

  • insert(elem);在容器中插入元素
  • clear();清除所有元素
  • erase(pos);删除pos迭代器所指的元素，返回下一个元素的迭代器
  • erase(beg, end);删除区间[beg, end]区间内所有的元素，返回下一个元素的迭代器
  • erase(key);删除容器中值为key的元素
int main() {
    map<int, int> m1;
    // 第一种插入元素（将匿名的队组加入map中）
    m1.insert(pair<int, int>(1, 10));
    // 第二种插入元素（使用make_pair）
    m1.insert(make_pair(2, 20));
    // 第三种插入元素
    m1.insert(map<int, int>::value_type(3, 30));
    // 第四种利用中括号
    m1[4] = 40;
    printMap(m1);

    cout << m1[1] << endl;

    // 删除元素
    m1.erase(m1.begin());
    printMap(m1);

    // 通过key删除
    m1.erase(3);
    printMap(m1);

    // 清空
    m1.clear();
    printMap(m1);
    return 0;
}

# 3.5查找与统计

  • find(key);查找key是否存在，如果存在，返回该键的元素迭代器，如果不存在则返回map.end()
  • count(key);统计key的元素个数

# 3.6map排序

在默认情况下map容器的排序规则为按照key值进行从小到大的排序

通过仿函数的方式可以更改map的排序规则

//
// Created by Jacob Lee on 2022/1/8.
//
#include "iostream"
#include "map"
using namespace std;

class compare {
public:
    bool operator()(int v1, int v2) {
        return v1 > v2;
    }
};

int main() {
    map<int, int, compare> 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));
    m.insert(make_pair(5, 50));
    m.insert(make_pair(6, 60));
    for (map<int, int, compare>::iterator it = m.begin(); it != m.end(); it++) {
        cout << it->first << ": " << it->second << endl;
    }
}