黑马程序员C++ 第三阶段 提高篇(2)

已于 2023-03-12 10:17:51 修改
阅读量168 收藏
点赞数
分类专栏： C++ 文章标签： c++ Powered by 金山文档
于 2023-03-09 15:51:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaafdfd/article/details/129424631
版权
3.8 set/ multiset 容器
3.8.1 set基本概念

简介：

所有元素都会在插入时自动被排序

本质：

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

set和multiset区别：

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

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

3.8.2 set构造和赋值

功能描述：创建set容器以及赋值

构造：

set<T> st; //默认构造函数：

set(const set &st); //拷贝构造函数

赋值：

set& operator=(const set &st); //重载等号操作符

#include<iostream>
using namespace std;
#include<set>
//set容器的构造和赋值

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

    //插入数据  只有insert方式
    s1.insert(10);
    s1.insert(40);
    s1.insert(30);
    s1.insert(20);
    s1.insert(30);

    //遍历容器
    //set容器的特点：所有元素插入时会自动被排序
    //set容器不允许插入重复值

    printSet(s1);

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

    //赋值
    set<int>s3;
    s3 = s2;
    printSet(s2);
}

int main()
{
    test01();
    system("pause");
    return 0;
}

总结：

set容器插入数据时用insert

set容器插入数据的数据会自动排序

3.8.3 set大小和交换

功能描述：

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

函数原型：

size(); //返回容器中元素的数目

empty(); //判断容器是否为空

swap(st); //交换两个集合容器

#include<iostream>
using namespace std;
#include<set>

//set容器大小和交换的操作
void printSet(set<int>& s)
{
    for (set<int>::iterator it = s.begin(); it != s.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}
//大小
void test01()
{
    set<int>s1;

    //插入数据
    s1.insert(10);
    s1.insert(30);
    s1.insert(20);
    s1.insert(40);

    printSet(s1);

    //判断是否为空
    if (s1.empty())
    {
        cout << "s1为空" << endl;
    }
    else
    {
        cout << "s1不为空" << endl;
        cout << "s1的大小为：" << s1.size() << endl;
    }

}
//交换
void test02()
{
    set<int>s1;
    s1.insert(10);
    s1.insert(30);
    s1.insert(20);
    s1.insert(40);

    set<int>s2;
    s2.insert(100);
    s2.insert(300);
    s2.insert(200);
    s2.insert(400);

    cout << "交换前" << endl;
    printSet(s1);
    printSet(s2);

    s1.swap(s2);
    cout << "交换后" << endl;
    printSet(s1);
    printSet(s2);
}

int main()
{
    //test01();
    test02();
    system("pause");
    return 0;
}

总结：

统计大小 — size

判断是否为空 — empty

交换容器 — swap

3.8.4 set插入和删除

功能描述：

set容器进行插入数据和删除数据

函数原型：

insert(elem); //在容器中插入元素。

clear(); //清除所有元素

erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。

erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。

erase(elem); //删除容器中值为elem的元素。

#include<iostream>
using namespace std;
#include<set>
//set容器插入和删除

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

void test01()
{
    set<int>s1;

    //插入数据
    s1.insert(30);
    s1.insert(10);
    s1.insert(20);
    s1.insert(40);

    printSet(s1);

    //删除
    s1.erase(s1.begin());
    printSet(s1);

    //删除重载版本
    s1.erase(30);
    printSet(s1);

    //清空
    //s1.erase(s1.begin(), s1.end());
    s1.clear();
    printSet(s1);

}

int main()
{
    test01();
    system("pause");
    return 0;
}

总结：

插入 — insert

删除 — erase

清空 — clear

3.8.5 set查找和统计

功能描述：

对set容器进行查找数据以及统计数据

函数原型：

find(key); //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();

count(key); //统计key的元素个数

#include<iostream>
using namespace std;
#include<set>

//set容器 查找和统计

void test01()
{
    //查找
    set<int>s1;

    //插入数据
    s1.insert(30);
    s1.insert(10);
    s1.insert(20);
    s1.insert(40);

    set<int>::iterator pos = s1.find(30);

    if (pos != s1.end())
    {
        cout << "找到元素" << endl;
    }
    else
    {
        cout << "未找到元素" << endl;
    }
}

//统计
void test02()
{
    set<int>s1;

    //插入数据
    s1.insert(30);
    s1.insert(10);
    s1.insert(20);
    s1.insert(40);
    s1.insert(30);
    s1.insert(30);

    //对于set而言 统计的结果要么是0 要么是1
    int num = s1.count(30);

    cout << "num = " << num << endl;
}

int main()
{
    //test01();
    test02();
    system("pause");
    return 0;
}

总结：

查找 — find （返回的是迭代器）

统计 — count （对于set，结果为0或者1）

3.8.6 set和multiset区别

学习目标：

掌握set和multiset的区别

区别：

set不可以插入重复数据，而multiset可以

set插入数据的同时会返回插入结果，表示插入是否成功

multiset不会检测数据，因此可以插入重复数据

#include<iostream>
using namespace std;
#include<set>

//set容器和multiset容器的区别

void test01()
{
    //查找
    set<int>s;

    //插入数据
    pair<set<int>::iterator, bool> ret = s.insert(10);

    if (ret.second)
    {
        cout << "第一次插入成功" << endl;
    }
    else
    {
        cout << "第一次插入失败" << endl;
    }

    ret = s.insert(10);

    if (ret.second)
    {
        cout << "第二次插入成功" << endl;
    }
    else
    {
        cout << "第二次插入失败" << endl;
    }

    multiset<int>ms;
    //允许插入重复的值
    ms.insert(10);
    ms.insert(10);
    ms.insert(10);
    for (multiset<int>::iterator it = ms.begin(); it != ms.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;

}

int main()
{
    test01();
    
    system("pause");
    return 0;
}

总结：

如果不允许插入重复数据可以利用set

如果需要插入重复数据利用multiset

3.8.7 pair对组创建

功能描述：

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

两种创建方式：

pair<type, type> p ( value1, value2 );

pair<type, type> p = make_pair( value1, value2 );

#include<iostream>
using namespace std;
#include<string>

//pair对组的创建

void test01()
{
    //第一种
    pair<string, int>p("Tom", 20);

    cout << "姓名：" << p.first << "年龄：" << p.second << endl;

    //第二种方式
    pair<string, int>p2 = make_pair("Jerry", 30);
    cout << "姓名：" << p2.first << "年龄：" << p2.second << endl;
}

int main()
{
    test01();
    
    system("pause");
    return 0;
}

总结：

两种方式都可以创建对组，记住一种即可

3.8.8 set容器排序

学习目标：

set容器默认排序规则为从小到大，掌握如何改变排序规则

主要技术点：

利用仿函数，可以改变排序规则

示例一 set存放内置数据类型

#include<iostream>
using namespace std;
#include<set>

//set容器排序

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

};

void test01()
{
    set<int>s1;

    s1.insert(10);
    s1.insert(40);
    s1.insert(20);
    s1.insert(50);
    s1.insert(30);

    for (set<int>::iterator it = s1.begin(); it != s1.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;

    //指定排序规则为从大到小

    set<int,MyCompare>s2;

    s2.insert(10);
    s2.insert(40);
    s2.insert(20);
    s2.insert(50);
    s2.insert(30);

    for (set<int,MyCompare>::iterator it = s2.begin(); it != s2.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;

}

int main()
{
    test01();
    
    system("pause");
    return 0;
}

总结：利用仿函数可以指定set容器的排序规则

示例二 set存放自定义数据类型

#include<iostream>
using namespace std;
#include<set>
#include<string>
//set容器排序 ,存放自定义数据类型

class Person
{

public:
    Person(string name,int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    string m_Name;

    int m_Age;
};

class comparePerson
{
public:
    bool operator()(const Person& p1, const Person& p2)const
    {
        //按照年龄降序
        return p1.m_Age > p2.m_Age;
    }
};

void test01()
{
    //自定义的数据类型，都会指定排序规则

    set<Person, comparePerson>s;

    //创建Person对象
    Person p1("刘备", 24);
    Person p2("关羽", 28);
    Person p3("张飞", 25);
    Person p4("赵云", 21);

    s.insert(p1);
    s.insert(p2);
    s.insert(p3);
    s.insert(p4);

    for (set<Person,comparePerson>::iterator it = s.begin(); it != s.end(); it++)
    {
        cout << "姓名：" << it->m_Name << "年龄：" << it->m_Age << endl;
    }
    cout << endl;

}

int main()
{
    test01();
    
    system("pause");
    return 0;
}

总结：

对于自定义数据类型，set必须指定排序规则才可以插入数据

3.9 map/ multimap容器
3.9.1 map基本概念

简介：

map中所有元素都是pair

pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）

所有元素都会根据元素的键值自动排序

本质：

map/multimap属于关联式容器，底层结构是用二叉树实现。

优点：

可以根据key值快速找到value值

map和multimap区别：

map不允许容器中有重复key值元素

multimap允许容器中有重复key值元素

3.9.2 map构造和赋值

功能描述：

对map容器进行构造和赋值操作

函数原型：

构造：

map<T1, T2> mp; //map默认构造函数:

map(const map &mp); //拷贝构造函数

赋值：

map& operator=(const map &mp); //重载等号操作符

#include<iostream>
using namespace std;
#include<map>
//map容器的构造和赋值

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

    //创建map容器
    map<int, int>m;
    
    m.insert(pair<int, int>(1, 10));
    m.insert(pair<int, int>(2, 20));
    m.insert(pair<int, int>(3, 30));
    m.insert(pair<int, int>(4, 40));


    printMap(m);

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

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

int main()
{
    test01();
    system("pause");
    return 0;
}

总结：map中所有元素都是成对出现，插入数据时候要使用对组

3.9.3 map大小和交换

功能描述：

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

函数原型：

size(); //返回容器中元素的数目

empty(); //判断容器是否为空

swap(st); //交换两个集合容器

#include<iostream>
using namespace std;
#include<map>
//map容器大小和交换
void printMap(map<int, int>& m)
{
    for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
    {
        cout << "key = " << it->first << " value = " << it->second << endl;
    }
    cout << endl;
}
//大小
void test01()
{
    map<int, int>m;
    m.insert(pair<int, int>(1, 10));
    m.insert(pair<int, int>(2, 20));
    m.insert(pair<int, int>(3, 30));

    if (m.empty())
    {
        cout << "m为空" << endl;
    }
    else
    {
        cout << "m不为空" << endl;
        cout << "m的大小为：" << m.size() << endl;
    }
}

//交换
void test02()
{
    map<int, int>m;
    m.insert(pair<int, int>(1, 10));
    m.insert(pair<int, int>(2, 20));
    m.insert(pair<int, int>(3, 30));

    map<int, int>m2;
    m2.insert(pair<int, int>(4, 100));
    m2.insert(pair<int, int>(5, 200));
    m2.insert(pair<int, int>(6, 300));

    cout << "交换前" << endl;
    printMap(m);
    printMap(m2);

    m.swap(m2);
    
    cout << "交换后" << endl;
    printMap(m);
    printMap(m2);
}

int main()
{
    //test01();
    test02();
    system("pause");
    return 0;
}

总结：

统计大小 — size

判断是否为空 — empty

交换容器 — swap

3.9.4 map插入和删除

功能描述：

map容器进行插入数据和删除数据

函数原型：

insert(elem); //在容器中插入元素。

clear(); //清除所有元素

erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。

erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。

erase(key); //删除容器中值为key的元素。

#include<iostream>
using namespace std;
#include<map>
//map容器 插入和删除
void printMap(map<int, int>& m)
{
    for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
    {
        cout << "key = " << it->first << " value = " << it->second << endl;
    }
    cout << endl;
}

void test01()
{
    map<int, int>m;

    //插入
    //第一种
    m.insert(pair<int, int>(1, 10));
    
    //第二种
    m.insert(make_pair(2, 20));

    //第三种
    m.insert(map<int, int>::value_type(3, 30));

    //第四种
    m[4] = 40;
    //[]不建议插入，用途，可以利用key访问到value
    //cout << m[4] << endl;
    printMap(m);

    //删除
    m.erase(m.begin());
    printMap(m);

    m.erase(3);   //按照key删除
    printMap(m);

    //清空
    //m.erase(m.begin(), m.end());
    m.clear();
    printMap(m);
}

int main()
{
    test01();
    
    system("pause");
    return 0;
}

总结：

map插入方式很多，记住其一即可

插入 — insert

删除 — erase

清空 — clear

3.9.5 map查找和统计

功能描述：

对map容器进行查找数据以及统计数据

函数原型：

find(key); //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();

count(key); //统计key的元素个数

#include<iostream>
using namespace std;
#include<map>
//map容器 查找和统计

void test01()
{
    map<int, int>m;

    m.insert(pair<int, int>(1, 10));
    m.insert(pair<int, int>(2, 20));
    m.insert(pair<int, int>(3, 30));
    m.insert(pair<int, int>(3, 30));
    map<int, int>::iterator pos = m.find(3);

    if (pos != m.end())
    {
        cout << "查到了元素 key = " << (*pos).first << " value = " << pos->second << endl;
    }
    else
    {
        cout << "未找到元素" << endl;
    }

    //统计
    //map容器不允许插入重复key 元素,count统计而言，结果要么是0，要么是1
    //multimap的统计可能大于1
    int num = m.count(3);
    cout << "num = " << num << endl;

}
int main()
{
    test01();
    system("pause");
    return 0;
}

总结：

查找 — find （返回的是迭代器）

统计 — count （对于map，结果为0或者1）

3.9.6 map容器排序

学习目标

map容器默认排序规则为 按照key值进行 从小到大排序，掌握如何改变排序规则

主要技术点:

利用仿函数，可以改变排序规则

#include<iostream>
using namespace std;
#include<map>
//map容器 排序

class MyCompare
{
public:
    bool operator()(int v1,int v2)const
    {
        //降序
        return v1 > v2;
    }
};

void test01()
{
    map<int, int, MyCompare>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));

    for (map<int, int, MyCompare>::iterator it = m.begin(); it != m.end(); it++)
    {
        cout << "key = " << it->first << " value = " << it->second << endl;
    }
}
int main()
{
    test01();
    
    system("pause");
    return 0;
}

总结：

利用仿函数可以指定map容器的排序规则

对于自定义数据类型，map必须要指定排序规则,同set容器

3.10 案例-员工分组
3.10.1 案例描述

公司今天招聘了10个员工（ABCDEFGHIJ），10名员工进入公司之后，需要指派员工在那个部门工作

员工信息有: 姓名 工资组成；部门分为：策划、美术、研发

随机给10名员工分配部门和工资

通过multimap进行信息的插入 key(部门编号) value(员工)

分部门显示员工信息

3.10.2 实现步骤

创建10名员工，放到vector中

遍历vector容器，取出每个员工，进行随机分组

分组后，将员工部门编号作为key，具体员工作为value，放入到multimap容器中

分部门显示员工信息

#include<iostream>
using namespace std;
#include<vector>
#include<string>
#include<map>
#include<ctime>
//公司今天招聘了10个员工（ABCDEFGHIJ），10名员工进入公司之后，需要指派员工在那个部门工作
//员工信息有 : 姓名 工资组成；部门分为：策划、美术、研发
//随机给10名员工分配部门和工资
//通过multimap进行信息的插入 key(部门编号) value(员工)
//分部门显示员工信息

#define CEHUA 0
#define MEISHU 1
#define YANFA 2

class Worker
{
public:
    string m_Name;
    int m_Salary;

};

void creatWorker(vector<Worker>&v)
{
    string nameSeed = "ABCDEFGHIJ";
    for (int i = 0; i < 10; i++)
    {
        Worker worker;
        worker.m_Name = "员工";
        worker.m_Name += nameSeed[i];

        worker.m_Salary = rand() % 10000 + 10000;  //10000~19999
        //将员工放入到容器中
        v.push_back(worker);
    }
}

//员工分组
void setGroup(vector<Worker>& v, multimap<int, Worker>& m)
{
    for (vector<Worker>::iterator it = v.begin(); it != v.end(); it++)
    {
        //产生随机部门编号
        int deptId = rand() % 3;   // 0,1,2
        
        //将员工插入到分组中
        //key代表部门编号，value代表具体的员工
        m.insert(make_pair(deptId, *it));
    }
}

void showWorker(multimap<int, Worker>& m)
{

    cout << "策划部门：" << endl;
    multimap<int,Worker>::iterator pos = m.find(CEHUA);
    int count = m.count(CEHUA);   //统计具体人数
    int index = 0;
    for (; pos != m.end()&&index < count;pos++,index++)
    {
        cout << "姓名：" << pos->second.m_Name << " 工资：" << pos->second.m_Salary << endl;
    }
    
    cout << "----------------------" << endl;
    cout << "美术部门：" << endl;
    pos = m.find(MEISHU);
    count = m.count(MEISHU);   //统计具体人数
    index = 0;
    for (; pos != m.end() && index < count; pos++, index++)
    {
        cout << "姓名：" << pos->second.m_Name << " 工资：" << pos->second.m_Salary << endl;
    }

    cout << "----------------------" << endl;
    cout << "研发部门：" << endl;
    pos = m.find(YANFA);
    count = m.count(YANFA);   //统计具体人数
    index = 0;
    for (; pos != m.end() && index < count; pos++, index++)
    {
        cout << "姓名：" << pos->second.m_Name << " 工资：" << pos->second.m_Salary << endl;
    }

}

int main()
{
    srand((unsigned int)time(NULL));
    //1.创建员工
    vector<Worker>vWorker;

    creatWorker(vWorker);

    //2.员工分组
    multimap<int, Worker>mWorker;
    setGroup(vWorker, mWorker);

    //3.分组显示员工
    showWorker(mWorker);

    //测试
    /*for (vector<Worker>::iterator it = vWorker.begin(); it != vWorker.end(); it++)
    {
        cout << "姓名：" << it->m_Name << " 薪水：" << it->m_Salary << endl;
    }*/
    system("pause");
    return 0;
}

总结：

当数据以键值对形式存在，可以考虑用map 或 multimap

四.STL- 函数对象
4.1 函数对象
4.1.1 函数对象概念

概念：

重载函数调用操作符的类，其对象常称为函数对象

函数对象使用重载的()时，行为类似函数调用，也叫仿函数

本质：

函数对象(仿函数)是一个类，不是一个函数

4.1.2 函数对象使用

特点：

函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值

函数对象超出普通函数的概念，函数对象可以有自己的状态

函数对象可以作为参数传递

#include<iostream>
using namespace std;
#include<string>
//函数对象（仿函数）
//函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
//函数对象超出普通函数的概念，函数对象可以有自己的状态
//函数对象可以作为参数传递

class MyAdd
{

public:
    int operator()(int v1, int v2)
    {
        return v1 + v2;
    }

};

//1.函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
void test01()
{
    MyAdd myAdd;
    cout << myAdd(10, 10) << endl;
}

//2.函数对象超出普通函数的概念，函数对象可以有自己的状态
class MyPrint
{
public:
    MyPrint()
    {
        this->count = 0;
    }
    void operator()(string test)
    {
        cout << test << endl;
        this->count++;
    }

    int count;  //内部自己的状态
};

void test02()
{
    MyPrint myPrint;
    myPrint("hello world");
    myPrint("hello world");
    myPrint("hello world");
    myPrint("hello world");

    cout << "myPrint调用的次数为：" << myPrint.count << endl;
}

//3.函数对象可以作为参数传递

void doPrint(MyPrint& mp, string test)
{
    mp(test);
}
void test03()
{
    MyPrint myPrint;
    doPrint(myPrint, "hello world");

}
int main()
{

    //test01();
    //test02();
    test03();
    system("pause");
    return 0;
}

总结：

仿函数写法非常灵活，可以作为参数进行传递。

4.2 谓词
4.2.1 谓词概念

概念：

返回bool类型的仿函数称为谓词

如果operator()接受一个参数，那么叫做一元谓词

如果operator()接受两个参数，那么叫做二元谓词

4.2.2 一元谓词
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//仿函数 返回值类型是bool数据类型，称为谓词
//一元谓词

class GreaterFive
{
public:
    bool operator()(int val)
    {
        return val > 5;
    }

};

void test01()
{
    vector<int>v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    //查找容器中 有没有大于5的数字
    //GreaterFive()匿名的函数对象
    vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
    if (it == v.end())
    {
        cout << "未找到" << endl;
    }
    else
    {
        cout << "找到了大于5的数字为：" << *it << endl;
    }
}

int main()
{
    test01();
    
    system("pause");
    return 0;
}
4.2.3 二元谓词
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//二元谓词
class MyCompare
{

public:
    bool operator()(int val1, int val2)
    {
        return val1 > val2;
    }
};

void test01()
{
    vector<int>v;
    v.push_back(10);
    v.push_back(40);
    v.push_back(20);
    v.push_back(30);
    v.push_back(50);

    sort(v.begin(), v.end());
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;

    //使用函数对象  改变算法策略 变为排序规则为从大到小
    sort(v.begin(), v.end(), MyCompare());
    cout << "--------------------" << endl;
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

int main()
{
    test01();

    system("pause");
    return 0;
}

总结：参数只有两个的谓词，称为二元谓词

4.3 内建函数对象
4.3.1 内建函数对象意义

概念：STL内建了一些函数对象

分类:

算术仿函数

关系仿函数

逻辑仿函数

用法：

这些仿函数所产生的对象，用法和一般函数完全相同

使用内建函数对象，需要引入头文件 #include<functional>

4.3.2 算术仿函数

功能描述：

实现四则运算

其中negate是一元运算，其他都是二元运算

仿函数原型：

template<class T> T plus<T> //加法仿函数

template<class T> T minus<T> //减法仿函数

template<class T> T multiplies<T> //乘法仿函数

template<class T> T divides<T> //除法仿函数

template<class T> T modulus<T> //取模仿函数

template<class T> T negate<T> //取反仿函数

#include<iostream>
using namespace std;
#include<functional>     //内建函数对象头文件
//内建函数对象  算术仿函数

//negate 一元仿函数  取反仿函数
void test01()
{
    negate<int>n;

    cout << n(50) << endl;
}
//plus 二元仿函数 加法
void test02()
{
    plus<int>p;
    cout << p(10,20) << endl;
}


int main()
{
    
    //test01();
    test02();
    system("pause");
    return 0;
}

总结：使用内建函数对象时，需要引入头文件 #include <functional>

4.3.3 关系仿函数

功能描述：

实现关系对比

仿函数原型：

template<class T> bool equal_to<T> //等于

template<class T> bool not_equal_to<T> //不等于

template<class T> bool greater<T> //大于

template<class T> bool greater_equal<T> //大于等于

template<class T> bool less<T> //小于

template<class T> bool less_equal<T> //小于等于

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<functional>
//内建函数对象 关系仿函数
//大于 greater

class MyCompare
{
public:
    bool operator()(int val1, int val2)
    {
        return val1 > val2;
    }
};

void test01()
{
    vector<int>v;
    v.push_back(10);
    v.push_back(30);
    v.push_back(40);
    v.push_back(20);
    v.push_back(50);

    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;

    //降序
    //sort(v.begin(), v.end(), MyCompare());
    //greater<int>() 内建函数对象
    sort(v.begin(), v.end(), greater<int>());
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

总结：关系仿函数中最常用的就是greater<>大于

4.3.4 逻辑仿函数

功能描述：

实现逻辑运算

函数原型：

template<class T> bool logical_and<T> //逻辑与

template<class T> bool logical_or<T> //逻辑或

template<class T> bool logical_not<T> //逻辑非

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<functional>
//内建函数对象 逻辑仿函数
//逻辑非 logical_not

void test01()
{
    vector<bool>v;

    v.push_back(true);
    v.push_back(false);
    v.push_back(true);
    v.push_back(false);

    for (vector<bool>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;

    //利用逻辑非 将容器v搬运到v2中，并执行取反操作
    vector<bool>v2;
    v2.resize(v.size());

    transform(v.begin(), v.end(), v2.begin(), logical_not<bool>());
    for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;

}

int main()
{
    test01();
    system("pause");
    return 0;
}

总结：逻辑仿函数实际应用较少，了解即可

五.STL- 常用算法

概述:

算法主要是由头文件<algorithm> <functional> <numeric>组成。

<algorithm>是所有STL头文件中最大的一个，范围涉及到比较、 交换、查找、遍历操作、复制、修改等等

<numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数

<functional>定义了一些模板类,用以声明函数对象。

5.1 常用遍历算法

学习目标：

掌握常用的遍历算法

算法简介：

for_each //遍历容器

transform //搬运容器到另一个容器中

5.1.1 for_each

功能描述：

实现遍历容器

函数原型：

for_each(iterator beg, iterator end, _func);

// 遍历算法 遍历容器元素

// beg 开始迭代器

// end 结束迭代器

// _func 函数或者函数对象

示例：

#include<iostream>
using namespace std;
#include <algorithm>
#include <vector>

//普通函数
void print01(int val)
{
    cout << val << " ";
}
//函数对象
class print02
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

//for_each算法基本用法
void test01() {

    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    //遍历算法
    for_each(v.begin(), v.end(), print01);
    cout << endl;

    for_each(v.begin(), v.end(), print02());
    cout << endl;
}

int main() {

    test01();
    system("pause");
    return 0;
}

**总结：**for_each在实际开发中是最常用遍历算法，需要熟练掌握

5.1.2 transform

功能描述：

搬运容器到另一个容器中

函数原型：

transform(iterator beg1, iterator end1, iterator beg2, _func);

//beg1 源容器开始迭代器

//end1 源容器结束迭代器

//beg2 目标容器开始迭代器

//_func 函数或者函数对象

示例：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

//常用遍历算法  搬运 transform
class TransForm
{
public:
    int operator()(int val)
    {
        return val;
    }
};

class MyPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    vector<int>v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    vector<int>vTarget; //目标容器

    vTarget.resize(v.size()); // 目标容器需要提前开辟空间

    transform(v.begin(), v.end(), vTarget.begin(), TransForm());

    for_each(vTarget.begin(), vTarget.end(), MyPrint());
}

int main() {

    test01();
    system("pause");
    return 0;
}

总结： 搬运的目标容器必须要提前开辟空间，否则无法正常搬运

5.2 常用查找算法

学习目标：

掌握常用的查找算法

算法简介：

find //查找元素

find_if //按条件查找元素

adjacent_find //查找相邻重复元素

binary_search //二分查找法

count //统计元素个数

count_if //按条件统计元素个数

5.2.1 find

功能描述：

查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()

函数原型：

find(iterator beg, iterator end, value);

// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

// beg 开始迭代器

// end 结束迭代器

// value 查找的元素

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<string>
//常用查找算法
//find
//查找内置的数据类型
void test01()
{
    vector<int>v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    //查找容器中是否有 5 这个元素
    vector<int>::iterator it = find(v.begin(), v.end(), 5);
    if (it == v.end())
    {
        cout << "没有找到" << endl;
    }
    else
    {
        cout << "找到了 " << *it << endl;
    }
}

class Person
{
public:
    Person(string name,int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    //重载== 底层find知道如何对比Person数据类型
    bool operator==(const Person& p)
    {
        if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    
    string m_Name;
    int m_Age;
};

//查找自定义的数据类型
void test02()
{
    vector<Person>v;

    //创建数据
    Person p1("aaa", 10);
    Person p2("bbb", 20);
    Person p3("ccc", 30);
    Person p4("ddd", 40);

    //放到容器中
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);

    Person pp("bbb", 20);

    vector<Person>::iterator it = find(v.begin(), v.end(), pp);
    if (it == v.end())
    {
        cout << "没有找到" << endl;
    }
    else
    {
        cout << "找到元素 姓名：" << it->m_Name << "年龄：" << it->m_Age << endl;
    }
}

int main()
{
    //test01();
    test02();

    system("pause");
    return 0;
}

总结： 利用find可以在容器中找指定的元素，返回值是迭代器

5.2.2 find_if

功能描述：

按条件查找元素

函数原型：

find_if(iterator beg, iterator end, _Pred);

// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

// beg 开始迭代器

// end 结束迭代器

// _Pred 函数或者谓词（返回bool类型的仿函数）

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<string>
//常用查找算法

//1.查找内置数据类型

class GreaterFive
{
public:
    bool operator()(int val)
    {
        return val > 5;
    }
};
void test01()
{
    vector<int>v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());

    if (it == v.end())
    {
        cout << "没有找到" << endl;
    }
    else
    {
        cout << "找到大于5的数字为：" << *it << endl;
    }


}
//2.查找自定义数据类型
class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    string m_Name;
    int m_Age;
};

class Greater20
{
public:
    bool operator()(Person &p)
    {
        return p.m_Age > 20;
    }
};
void test02()
{
    vector<Person>v;

    //创建数据
    Person p1("aaa", 10);
    Person p2("bbb", 20);
    Person p3("ccc", 30);
    Person p4("ddd", 40);

    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);

    //找年龄大于20的人
    vector<Person>::iterator it = find_if(v.begin(), v.end(), Greater20());

    if (it == v.end())
    {
        cout << "没有找到" << endl;
    }
    else
    {
        cout << "找到姓名：" << it->m_Name << "年龄：" << it->m_Age << endl;
    }
}

int main()
{
    //test01();
    test02();
    system("pause");
    return 0;
}

总结：find_if按条件查找使查找更加灵活，提供的仿函数可以改变不同的策略

5.2.3 adjacent_find

功能描述：

查找相邻重复元素

函数原型：

adjacent_find(iterator beg, iterator end);

// 查找相邻重复元素,返回相邻元素的第一个位置的迭代器

// beg 开始迭代器

// end 结束迭代器

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用查找算法 adjacent_find
void test01()
{
    vector<int>v;
    v.push_back(0);
    v.push_back(2);
    v.push_back(0);
    v.push_back(3);
    v.push_back(1);
    v.push_back(4);
    v.push_back(3);
    v.push_back(3);

    vector<int>::iterator pos = adjacent_find(v.begin(), v.end());

    if (pos == v.end())
    {
        cout << "未找到相邻重复元素" << endl;
    }
    else
    {
        cout << "找到了相邻重复元素：" << *pos << endl;
    }

}
int main()
{
    test01();
    system("pause");
    return 0;
}

总结：面试题中如果出现查找相邻重复元素，记得用STL中的adjacent_find算法

5.2.4 binary_search

功能描述：

查找指定元素是否存在

函数原型：

bool binary_search(iterator beg, iterator end, value);

// 查找指定的元素，查到 返回true 否则false

// 注意: 在无序序列中不可用

// beg 开始迭代器

// end 结束迭代器

// value 查找的元素

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用查找算法 binary_search
void test01()
{
    vector<int>v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    //v.push_back(2);   如果是无序的序列，结果未知

    //查找容器中是否有9
    //容器必须是有序的序列
    bool ret = binary_search(v.begin(), v.end(), 9);
    if (ret)
    {
        cout << "找到了" << endl;
    }
    else
    {
        cout << "未找到" << endl;
    }

}
int main()
{
    test01();
    system("pause");
    return 0;
}

**总结：**二分查找法查找效率很高，值得注意的是查找的容器中元素必须的有序序列

5.2.5 count

功能描述：

统计元素个数

函数原型：

count(iterator beg, iterator end, value);

// 统计元素出现次数

// beg 开始迭代器

// end 结束迭代器

// value 统计的元素

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<string>
//常用查找算法 cout

//1.统计内置数据类型
void test01()
{
    vector<int>v;
    
    v.push_back(10);
    v.push_back(40);
    v.push_back(30);
    v.push_back(40);
    v.push_back(20);
    v.push_back(40);

    int num = count(v.begin(), v.end(), 40);

    cout << "40的元素个数为：" << num << endl;

}
//2.统计自定义数据类型
class Person
{
public:

    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    bool operator==(const Person& p)
    {
        if (this->m_Age == p.m_Age)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    string m_Name;
    int m_Age;

};
void test02()
{
    vector<Person>v;
    
    Person p1("刘备", 35);
    Person p2("关羽", 35);
    Person p3("张飞", 35);
    Person p4("赵云", 30);
    Person p5("曹操", 40);

    //将人员插入到容器中
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    v.push_back(p5);

    Person p("诸葛亮", 35);

    int num = count(v.begin(), v.end(), p);

    cout << "和诸葛亮同岁数的人员的个数为：" << num << endl;

}
int main()
{
    //test01();
    test02();
    system("pause");
    return 0;
}

总结： 统计自定义数据类型时候，需要配合重载 operator==

5.2.6 count_if

功能描述：

按条件统计元素个数

函数原型：

count_if(iterator beg, iterator end, _Pred);

// 按条件统计元素出现次数

// beg 开始迭代器

// end 结束迭代器

// _Pred 谓词

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用的查找算法 count_if

//统计内置数据类型
class Greater20
{
public:
    bool operator()(int val)
    {
        return val > 20;
    }
};
void test01()
{
    vector<int>v;
    v.push_back(10);
    v.push_back(40);
    v.push_back(30);
    v.push_back(20);
    v.push_back(40);
    v.push_back(20);

    int num = count_if(v.begin(), v.end(), Greater20());
    cout << "在容器中大于20的元素个数为：" << num << endl;
}

class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    string m_Name;
    int m_Age;
};

class AgeGreater20
{
public:
    bool operator()(const Person& p)
    {
        return p.m_Age > 20;
    }
};
//统计自定义数据类型
void test02()
{
    vector<Person>v;

    Person p1("刘备", 35);
    Person p2("关羽", 35);
    Person p3("张飞", 35);
    Person p4("赵云", 40);
    Person p5("曹操", 20);

    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    v.push_back(p5);

    //统计 大于20岁的人员个数
    int num = count_if(v.begin(), v.end(), AgeGreater20());

    cout << "大于20岁人员的个数：" << num << endl;
}

int main()
{
    //test01();
    test02();
    system("pause");
    return 0;
}

**总结：**按值统计用count，按条件统计用count_if

5.3 常用排序算法

学习目标：

掌握常用的排序算法

算法简介：

sort //对容器内元素进行排序

random_shuffle //洗牌 指定范围内的元素随机调整次序

merge // 容器元素合并，并存储到另一容器中

reverse // 反转指定范围的元素

5.3.1 sort

功能描述：

对容器内元素进行排序

函数原型：

sort(iterator beg, iterator end, _Pred);

// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

// beg 开始迭代器

// end 结束迭代器

// _Pred 谓词

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>
#include<functional>
//常用的排序算法

void myPrint(int val)
{
    cout << val << " ";
}
void test01()
{
    vector<int>v;

    v.push_back(10);
    v.push_back(30);
    v.push_back(50);
    v.push_back(20);
    v.push_back(40);

    //利用sort进行升序
    sort(v.begin(), v.end());
    for_each(v.begin(), v.end(), myPrint);
    cout << endl;

    //改为降序
    sort(v.begin(), v.end(), greater<int>());
    for_each(v.begin(), v.end(), myPrint);
    cout << endl;

}
int main()
{
    test01();
    system("pause");
    return 0;
}

**总结：**sort属于开发中最常用的算法之一，需熟练掌握

5.3.2 random_shuffle

功能描述：

洗牌 指定范围内的元素随机调整次序

函数原型：

random_shuffle(iterator beg, iterator end);

// 指定范围内的元素随机调整次序

// beg 开始迭代器

// end 结束迭代器

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<ctime>
//常用排序算法  random_shuffle

void myPrint(int val)
{
    cout << val << " ";
}
void test01()
{
    vector<int>v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    //利用洗牌算法 打乱顺序
    random_shuffle(v.begin(), v.end());
    for_each(v.begin(), v.end(), myPrint);
    cout << endl;

}

int main()
{
    srand((unsigned int)time(NULL));
    test01();
    system("pause");
    return 0;
}

**总结：**random_shuffle洗牌算法比较实用，使用时记得加随机数种子

5.3.3 merge

功能描述：

两个容器元素合并，并存储到另一容器中

函数原型：

merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 容器元素合并，并存储到另一容器中

// 注意: 两个容器必须是有序的

// beg1 容器1开始迭代器

// end1 容器1结束迭代器

// beg2 容器2开始迭代器

// end2 容器2结束迭代器

// dest 目标容器开始迭代器

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用排序算法 merge
void myPrint(int val)
{
    cout << val << " ";
}

void test01()
{
    vector<int>v1;
    vector<int>v2;

    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
        v2.push_back(i + 1);
    }

    //目标容器
    vector<int>vTarget;
    //提前给目标容器分配内存
    vTarget.resize(v1.size() + v2.size());
    merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    for_each(vTarget.begin(), vTarget.end(), myPrint);
}

int main()
{
    test01();
    system("pause");
    return 0;
}

**总结：**merge合并的两个容器必须的有序序列

5.3.4 reverse

功能描述：

将容器内元素进行反转

函数原型：

reverse(iterator beg, iterator end);

// 反转指定范围的元素

// beg 开始迭代器

// end 结束迭代器

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用的排序算法 reverse

void myPrint(int val)
{
    cout << val << " ";
}
void test01()
{
    vector<int>v;
    v.push_back(10);
    v.push_back(30);
    v.push_back(50);
    v.push_back(20);
    v.push_back(40);

    cout << "反转前：" << endl;
    for_each(v.begin(), v.end(), myPrint);
    cout << endl;

    cout << "反转后：" << endl;
    reverse(v.begin(), v.end());
    for_each(v.begin(), v.end(), myPrint);
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

**总结：**reverse反转区间内元素，面试题可能涉及到

5.4 常用拷贝和替换算法

学习目标：

掌握常用的拷贝和替换算法

算法简介：

copy // 容器内指定范围的元素拷贝到另一容器中

replace // 将容器内指定范围的旧元素修改为新元素

replace_if // 容器内指定范围满足条件的元素替换为新元素

swap // 互换两个容器的元素

5.4.1 copy

功能描述：

容器内指定范围的元素拷贝到另一容器中

函数原型：

copy(iterator beg, iterator end, iterator dest);

// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

// beg 开始迭代器

// end 结束迭代器

// dest 目标起始迭代器

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用拷贝和替换算法 copy

void myPrint(int val)
{
    cout << val << " ";
}
void test01()
{
    vector<int>v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    vector<int>v2;
    v2.resize(v.size());
    copy(v.begin(), v.end(), v2.begin());
    for_each(v2.begin(), v2.end(), myPrint);
    cout << endl;

}

int main()
{
    test01();
    system("pause");
    return 0;
}

**总结：**利用copy算法在拷贝时，目标容器记得提前开辟空间

5.4.2 replace

功能描述：

将容器内指定范围的旧元素修改为新元素

函数原型：

replace(iterator beg, iterator end, oldvalue, newvalue);

// 将区间内旧元素 替换成 新元素

// beg 开始迭代器

// end 结束迭代器

// oldvalue 旧元素

// newvalue 新元素

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用拷贝和替换算法 replace

class MyPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};
void test01()
{
    vector<int>v;
    v.push_back(20);
    v.push_back(30);
    v.push_back(50);
    v.push_back(30);
    v.push_back(40);
    v.push_back(20);
    v.push_back(10);
    v.push_back(20);

    cout << "替换前：" << endl;
    for_each(v.begin(), v.end(), MyPrint());
    cout << endl;

    //将 20 替换为 2000
    replace(v.begin(), v.end(), 20, 2000);
    cout << "替换后：" << endl;
    for_each(v.begin(), v.end(), MyPrint());
    cout << endl;

}

int main()
{
    test01();
    system("pause");
    return 0;
}

**总结：**replace会替换区间内满足条件的元素

5.4.3 replace_if

功能描述:

将区间内满足条件的元素，替换成指定元素

函数原型：

replace_if(iterator beg, iterator end, _pred, newvalue);

// 按条件替换元素，满足条件的替换成指定元素

// beg 开始迭代器

// end 结束迭代器

// _pred 谓词

// newvalue 替换的新元素

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用拷贝和替换算法 replace_if

class MyPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

class Greater30
{
public:
    bool operator()(int val)
    {
        return val >= 30;
    }
};
void test01()
{
    vector<int>v;
    v.push_back(10);
    v.push_back(40);
    v.push_back(20);
    v.push_back(40);
    v.push_back(30);
    v.push_back(50);
    v.push_back(20);
    v.push_back(30);

    cout << "替换前：" << endl;
    for_each(v.begin(), v.end(), MyPrint());
    cout << endl;

    //将大于等于30  替换为3000
    replace_if(v.begin(), v.end(), Greater30(), 3000);
    cout << "替换后：" << endl;
    for_each(v.begin(), v.end(), MyPrint());
    cout << endl;

}

int main()
{
    test01();
    system("pause");
    return 0;
}

**总结：**replace_if按条件查找，可以利用仿函数灵活筛选满足的条件

5.4.4 swap

功能描述：

互换两个容器的元素

函数原型：

swap(container c1, container c2);

// 互换两个容器的元素

// c1容器1

// c2容器2

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用拷贝和替换算法 swap

class MyPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    vector<int>v1;
    vector<int>v2;

    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
        v2.push_back(i + 100);
    }
    cout << "交换前：" << endl;
    for_each(v1.begin(), v1.end(), MyPrint());
    cout << endl;
    for_each(v2.begin(), v2.end(), MyPrint());
    cout << endl;


    cout << "----------------------------------" << endl;

    swap(v1, v2);

    cout << "交换后：" << endl;
    for_each(v1.begin(), v1.end(), MyPrint());
    cout << endl;
    for_each(v2.begin(), v2.end(), MyPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}
5.5 常用算术生成算法

学习目标：

掌握常用的算术生成算法

注意：

算术生成算法属于小型算法，使用时包含的头文件为 #include <numeric>

算法简介：

accumulate // 计算容器元素累计总和

fill // 向容器中添加元素

5.5.1 accumulate

功能描述：

计算区间内 容器元素累计总和

函数原型：

accumulate(iterator beg, iterator end, value);

// 计算容器元素累计总和

// beg 开始迭代器

// end 结束迭代器

// value 起始值

#include<iostream>
using namespace std;
#include<vector>
#include<numeric>

//常用算术生成算法
void test01()
{
    vector<int>v;

    for (int i = 0; i <= 100; i++)
    {
        v.push_back(i);
    }

    //参数3 起始累加值
    int total = accumulate(v.begin(), v.end(), 0);
    cout << "total = " << total << endl;

}
int main()
{
    test01();
    system("pause");
    return 0;
}

**总结：**accumulate使用时头文件注意是 numeric，这个算法很实用

5.5.2 fill

功能描述：

向容器中填充指定的元素

函数原型：

fill(iterator beg, iterator end, value);

// 向容器中填充元素

// beg 开始迭代器

// end 结束迭代器

// value 填充的值

#include<iostream>
using namespace std;
#include<vector>
#include<numeric>
#include<algorithm>
//常用算术生成算法 fill

void myPrint(int val)
{
    cout << val << " ";
}
void test01()
{
    vector<int>v;

    v.resize(10);

    //后期重新填充
    fill(v.begin(), v.end(), 100);
    for_each(v.begin(), v.end(), myPrint);

}
int main()
{
    test01();
    system("pause");
    return 0;
}

**总结：**利用fill可以将容器区间内元素填充为 指定的值

5.6 常用集合算法

学习目标：

掌握常用的集合算法

算法简介：

set_intersection // 求两个容器的交集

set_union // 求两个容器的并集

set_difference // 求两个容器的差集

5.6.1 set_intersection

功能描述：

求两个容器的交集

函数原型：

set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 求两个集合的交集

// 注意:两个集合必须是有序序列

// beg1 容器1开始迭代器

// end1 容器1结束迭代器

// beg2 容器2开始迭代器

// end2 容器2结束迭代器

// dest 目标容器开始迭代器

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用的集合算法 set_intersection

void myPrint(int val)
{
    cout << val << " ";
}
void test01()
{
    vector<int>v1;

    vector<int>v2;

    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
        v2.push_back(i + 5);
    }

    vector<int>vTarget;
    //目标容器需要提前开辟空间
    //最特殊的情况 大容器包含小容器 取最小的容器size即可
    vTarget.resize(min(v1.size(), v2.size()));

    //获取交集
    vector<int>::iterator itEnd = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    for_each(vTarget.begin(), itEnd , myPrint);
    cout << endl;
}


int main()
{
    test01();
    system("pause");
    return 0;
}

总结：

求交集的两个集合必须的有序序列

目标容器开辟空间需要从两个容器中取小值

set_intersection返回值既是交集中最后一个元素的位置

5.6.2 set_union

功能描述：

求两个集合的并集

函数原型：

set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 求两个集合的并集

// 注意:两个集合必须是有序序列

// beg1 容器1开始迭代器

// end1 容器1结束迭代器

// beg2 容器2开始迭代器

// end2 容器2结束迭代器

// dest 目标容器开始迭代器

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用的集合算法 set_union
void myPrint(int val)
{
    cout << val << " ";
}
void test01()
{
    vector<int>v1;
    vector<int>v2;

    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
        v2.push_back(i + 5);
    }

    vector<int>vTarget;
    //目标容器要提前开辟空间
    //最特殊的情况 两个容器没有交集 并集就是两个容器size相加

    vTarget.resize(v1.size() + v2.size());

    vector<int>::iterator itEnd = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

    for_each(vTarget.begin(), itEnd , myPrint);
    cout << endl;
}


int main()
{
    test01();
    system("pause");
    return 0;
}

总结：

求并集的两个集合必须的有序序列

目标容器开辟空间需要两个容器相加

set_union返回值既是并集中最后一个元素的位置

5.6.3 set_difference

功能描述：

求两个集合的差集

函数原型：

set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 求两个集合的差集

// 注意:两个集合必须是有序序列

// beg1 容器1开始迭代器

// end1 容器1结束迭代器

// beg2 容器2开始迭代器

// end2 容器2结束迭代器

// dest 目标容器开始迭代器

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用的集合算法 set_difference

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

void test01()
{
    vector<int>v1;
    vector<int>v2;

    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
        v2.push_back(i + 5);
    }

    //创建目标容器
    vector<int>vTarget;
    //给目标容器开辟空间
    //最特殊情况 两个容器没有交集 取两个容器中大的size作为目标容器开辟空间
    vTarget.resize(max(v1.size(), v2.size()));

    cout << "v1和v2的差集为：" << endl;

    vector<int>::iterator itEnd = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

    for_each(vTarget.begin(), itEnd , myPrint);
    cout << endl;

    cout << "v2和v1的差集为：" << endl;

    itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());

    for_each(vTarget.begin(), itEnd, myPrint);
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

总结：

求差集的两个集合必须的有序序列

目标容器开辟空间需要从两个容器取较大值

“科普两下”泛二级秒收站群程序（SEO新视野）
qq_39163387的博客
05-22 1216
想要实现日收泛二级尽可能的多乃至收满760条，就要尽可能的多绑定泛二级，当前域名绑定的越多越好，然后再尽可能的多token推送。本套程序调用show.php作为实现泛目录功能的文件，通过引用fx.php，实现通过ip段允许查看真实页面，ip端默认为百度权重蜘蛛段，可以实现访客直接跳转广告页，且模拟蜘蛛都无法查看到网站源码。本套程序是一月发布的“科普一下”泛二级程序的升级版本，结合百度收录的最新特点：泛二级内页泛收，以及K站特点：主页与历史不符，对此进行了专项的优化，并对整站全局关键词作出了转码的调整。
搜狗推送工具之泛站程序实现泛收录
zhanguoSEO的博客
01-05 940
最近很多站长朋友问我别人的搜狗泛收录是怎么起来的？搜狗的百万蜘蛛怎么来的？搜狗推送有没有必要做？ 今天笔者就来分析一下搜狗收录到底应该怎么做？首先人们都知道搜狗推送是做搜狗seo收录的重要一环，通过seo推送，主动将链接曝光给搜狗，增加蜘蛛spider抓取频率，从而促进网站收录。话不多说，搜狗泛收录到底应该怎么做才能实现！ 说到这里，我们首先要知道怎么样才有可能被搜狗收录？可以从以下4个角度进行考虑。首先我们的域名选择最好是老域名，人们都知道好的域名自带蜘蛛。搜索引擎给老域名的一个pr是不.
黑马程序员C++学习笔记（第三阶段核心：STL）--- 更新中
TI__boyue的博客
07-04 1239
目录vector 动态数组嵌套传送门 vector 动态数组 (*begin) 解析的是 vector<数据类型> 中的数据类型 #include<iostream> using namespace std; #include<vector> #include<algorithm> void test01(){ // 创建 vector<int> v; // 插入尾部 v.push_back(10); v.push_back(20)
泛域名站群,泛域名程序
qq_787143156的博客
04-01 710
泛域名站群是一种利用大量类似的泛域名来建立多个网站，并通过这些网站链接到主网站，以提升主网站的排名和流量的策略。泛域名站群通常包含大量的子域名，这些子域名指向不同的页面，但它们的内容大部分是重复或相似的，目的是通过增加外部链接来提升主网站的权重。泛域名站群的免费工具主要是一些开源软件或在线平台，它们提供了简单易用的功能来创建和管理泛域名站群。
2024泛程序最新模板在哪里下载？泛码网都有什么程序
最新发布
FANMAW002的博客
09-06 521
在搜索引擎优化（SEO）的复杂世界中，泛程序玩法是一种高级技术，它涉及到利用泛站群技术来提高网站在搜索引擎中的排名和可见度。seoa3。com作为一名资深SEO从业者，我将深入探讨泛程序的工作原理、优势、风险以及最佳实践。
第三阶段 黑马程序员C++提高编程
06-07
黑马程序员C++提高编程PDF版
黑马程序员C++ 第三阶段 提高篇(1)
aaafdfd的博客
03-09 331
黑马C++提高篇
黑马程序员匠心之作 C++教程_第5阶段-C++提高编程资料讲义.rar
03-19
《黑马程序员匠心之作 C++教程_第5阶段-C++提高编程资料讲义》是一份针对C++编程初学者精心制作的教程资料，旨在帮助学习者深入理解和提升C++编程技能。这份讲义涵盖了许多关键的C++知识点，下面将对其进行详细解读...
黑马程序员C++从0到1笔记教程-pdf带目录
05-07
有七个阶段：第1阶段C++ 匠心之作 从0到1入门，第2阶段实战-通讯录管理，第3阶段-C++核心编程 资料，第4阶段实战-基于多态的企业职工系统，第5阶段-C++提高编程资料，第6阶段实战-基于STL泛化编程的演讲比赛资料，第...
《黑马程序员》C++提高编程(三)
ZONGXP的博客
05-29 2911
黑马程序员C++教程笔记
搜狗泛目录站群程序
qq_787143156的博客
10-24 2575
搜狗的中文历史老域名 新站通常是会有个观察期，而老域名可以轻松省去这个观察期，让网站快速收录，让你收录的文章可以立刻索引。这也是老域名最大的优势 有建站历史：必须要有过建站历史的域名才能称为老域名。注意：注册时间长，但从未建过站的，不是我们这里所指的老域名。 网站模板独特标签（搜狗官方解答） 每个网页都需要有合适的标题，网站首页标题建议使用站点名称或者站点代表的公司、机构名称；其余的内容页面，标题建议做成与正文内...
PHP版站群 全自动泛解析站群程序 赠送教程_PHP泛站_站群_
10-03
php泛站群系统，泛目录和泛域名都支持
2022图片内容泛站|图片聚合搜索程序|养站增收录程序
qq_26057339的博客
04-11 222
本程序调用搜狗图片数据实现图片聚合搜索 聚合搜索懂得都懂 程序优势： 搜狗盗链不占空间 搜狗图片正规图片 聚合搜索无限内容 相关搜索无限页面 程序适用： 程序适用于百度搜索和搜狗搜索 推荐使用本程序进行搜狗搜索优化 下载地址：http://blog.zhoumoniuzai.com/post/10.html ...
2020新版零距离泛站泛目录源码程序
09-01
最新可用，带安装说明，推荐使用nginx跑。必须PHP7以下，推荐PHP5.6 伪静态使用thinkphp的即可
搜狗泛站群程序源码_泛站源码_搜狗_站群_泛站群_泛站_
10-04
搜狗泛站程序源码，做排名的利器。搜狗流量
第三阶段程序员C++核心编程.pdf
07-24
本文从【第三阶段程序员C++核心编程.pdf】文件内容中提炼出的C++编程知识点包括内存管理、面向对象编程、new和delete操作符以及引用的使用等多个方面。 首先，C++程序在运行时的内存分配主要分为四个区域：代码区、...
黑马程序员C++学习笔记＜第一阶段_基础篇＞
qq_45283176的博客
01-03 4203
这里写自定义目录标题前言1初识C++1.1第一个C++程序1.1.1创建项目2数据类型3运算符4程序流程结构5数组6函数7指针8结构体新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 前言 配套视频网址： 黑马程序员：htt
泛站程序源码
01-25
php的源码，适合做泛站群
淘宝泛站程序+php版批量单页站群软件
07-02
内含四个源码；都是站群 别说appkey不能用了，源码很老，sinaapp不能用之类的 发这个源码就是让大家下载看看玩完的，有需求就下载
泛站群程序
04-24
泛站群程序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值