• C++进阶--2

    4 STL- 函数对象

    4.1 函数对象

    4.1.1 函数对象概念

    概念：

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

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

    本质：

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

    4.1 函数对象

    4.1.1 函数对象概念

    概念：

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

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

    本质：

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

    1. #include <string>
    2.  
    3. //1、函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
    4. class MyAdd
    5. {
    6. public :
    7. 	int operator()(int v1,int v2)
    8. 	{
    9. 		return v1 + v2;
    10. 	}
    11. };
    12.  
    13. void test01()
    14. {
    15. 	MyAdd myAdd;
    16. 	cout << myAdd(10, 10) << endl;
    17. }
    18.  
    19. //2、函数对象可以有自己的状态
    20. class MyPrint
    21. {
    22. public:
    23. 	MyPrint()
    24. 	{
    25. 		count = 0;
    26. 	}
    27. 	void operator()(string test)
    28. 	{
    29. 		cout << test << endl;
    30. 		count++; //统计使用次数
    31. 	}
    32.  
    33. 	int count; //内部自己的状态
    34. };
    35. void test02()
    36. {
    37. 	MyPrint myPrint;
    38. 	myPrint("hello world");
    39. 	myPrint("hello world");
    40. 	myPrint("hello world");
    41. 	cout << "myPrint调用次数为： " << myPrint.count << endl;
    42. }
    43.  
    44. //3、函数对象可以作为参数传递
    45. void doPrint(MyPrint &mp , string test)
    46. {
    47. 	mp(test);
    48. }
    49.  
    50. void test03()
    51. {
    52. 	MyPrint myPrint;
    53. 	doPrint(myPrint, "Hello C++");
    54. }

    4.2 谓词

    4.2.1 谓词概念

    概念：

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

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

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

    4.2.2 一元谓词
    1. #include <vector>
    2. #include <algorithm>
    3.  
    4. //1.一元谓词
    5. struct GreaterFive{
    6. 	bool operator()(int val) {
    7. 		return val > 5;
    8. 	}
    9. };
    10.  
    11. void test01() {
    12.  
    13. 	vector<int> v;
    14. 	for (int i = 0; i < 10; i++)
    15. 	{
    16. 		v.push_back(i);
    17. 	}
    18.     // GreaterFive() 匿名对象   find_if()按区间查找对象
    19. 	vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
    20. 	if (it == v.end()) {
    21. 		cout << "没找到!" << endl;
    22. 	}
    23. 	else {
    24. 		cout << "找到:" << *it << endl;  //  6
    25. 	}
    26.  
    27. }
    4.2.3 二元谓词
    1. #include <vector>
    2. #include <algorithm>
    3. //二元谓词
    4. class MyCompare
    5. {
    6. public:
    7. 	bool operator()(int num1, int num2)
    8. 	{
    9. 		return num1 > num2;
    10. 	}
    11. };
    12.  
    13. void test01()
    14. {
    15. 	vector<int> v;
    16. 	v.push_back(10);
    17. 	v.push_back(40);
    18. 	v.push_back(20);
    19. 	v.push_back(30);
    20. 	v.push_back(50);
    21.  
    22. 	//默认从小到大
    23. 	sort(v.begin(), v.end());
    24. 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    25. 	{
    26. 		cout << *it << " ";
    27. 	}
    28. 	cout << endl;
    29. 	cout << "----------------------------" << endl;
    30.  
    31. 	//使用函数对象改变算法策略，排序从大到小
    32. 	sort(v.begin(), v.end(), MyCompare());
    33. 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    34. 	{
    35. 		cout << *it << " ";
    36. 	}
    37. 	cout << endl;
    38. }

    4.3 内建函数对象

    4.3.1 内建函数对象意义

    概念：

    • STL内建了一些函数对象

    分类:

    • 算术仿函数

    • 关系仿函数

    • 逻辑仿函数

    用法：

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

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

    4.3.2 算术仿函数

    功能描述：

    • 实现四则运算

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

    仿函数原型：

    • template T plus //加法仿函数

    • template T minus //减法仿函数

    • template T multiplies //乘法仿函数

    • template T divides //除法仿函数

    • template T modulus //取模仿函数

    • template T negate //取反仿函数

    1. #include <functional>
    2. //negate
    3. void test01()
    4. {
    5. 	negate<int> n;
    6. 	cout << n(50) << endl;  // -50
    7. }
    8.  
    9. //plus
    10. void test02()
    11. {
    12. 	plus<int> p;
    13. 	cout << p(10, 20) << endl;  // 30
    14. }
    4.3.3 关系仿函数

    功能描述：

    • 实现关系对比

    仿函数原型：

    • template bool equal_to //等于

    • template bool not_equal_to //不等于

    • template bool greater //大于

    • template bool greater_equal //大于等于

    • template bool less //小于

    • template bool less_equal //小于等于

    1. #include <functional>
    2. #include <vector>
    3. #include <algorithm>
    4.  
    5. class MyCompare
    6. {
    7. public:
    8. 	bool operator()(int v1,int v2)
    9. 	{
    10. 		return v1 > v2;
    11. 	}
    12. };
    13. void test01()
    14. {
    15. 	vector<int> v;
    16.  
    17. 	v.push_back(10);
    18. 	v.push_back(30);
    19. 	v.push_back(50);
    20. 	v.push_back(40);
    21. 	v.push_back(20);
    22.  
    23. 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
    24. 		cout << *it << " ";
    25. 	}
    26. 	cout << endl;
    27.  
    28. 	//自己实现仿函数
    29. 	//sort(v.begin(), v.end(), MyCompare());
    30. 	//STL内建仿函数  大于仿函数  效果与上面一致
    31. 	sort(v.begin(), v.end(), greater<int>());
    32.  
    33. 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
    34. 		cout << *it << " ";
    35. 	}
    36. 	cout << endl;
    37. }
    38.  
    39. int main() {
    40.  
    41. 	test01();
    42.  
    43. 	system("pause");
    44.  
    45. 	return 0;
    46. }
    4.3.4 逻辑仿函数

    功能描述：

    • 实现逻辑运算

    函数原型：

    • template bool logical_and //逻辑与

    • template bool logical_or //逻辑或

    • template bool logical_not //逻辑非

    1. #include <vector>
    2. #include <functional>
    3. #include <algorithm>
    4. void test01()
    5. {
    6. 	vector<bool> v;
    7. 	v.push_back(true);
    8. 	v.push_back(false);
    9. 	v.push_back(true);
    10. 	v.push_back(false);
    11.  
    12. 	for (vector<bool>::iterator it = v.begin();it!= v.end();it++)
    13. 	{
    14. 		cout << *it << " ";
    15. 	}
    16. 	cout << endl;  //  1 0 1 0
    17.  
    18. 	//逻辑非  将v容器搬运到v2中，并执行逻辑非运算
    19. 	vector<bool> v2;
    20. 	v2.resize(v.size());
    21. 	transform(v.begin(), v.end(),  v2.begin(), logical_not<bool>());
    22. 	for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++)
    23. 	{
    24. 		cout << *it << " ";
    25. 	}
    26. 	cout << endl;  // 0 1 0 1
    27. }
    28.  
    29. int main() {
    30.  
    31. 	test01();
    32.  
    33. 	system("pause");
    34.  
    35. 	return 0;
    36. }

    5 STL- 常用算法

    概述:

    • 算法主要是由头文件 组成。

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

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

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

    5.1 常用遍历算法

    算法简介：

    • for_each //遍历容器

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

    5.1.1 for_each

    功能描述：

    • 实现遍历容器

    函数原型：

    • for_each(iterator beg, iterator end, _func);

      // beg 开始迭代器        end 结束迭代器

      // _func 函数或者函数对象

    1. #include <algorithm>
    2. #include <vector>
    3.  
    4. //普通函数
    5. void print01(int val) 
    6. {
    7. 	cout << val << " ";
    8. }
    9. //函数对象
    10. class print02 
    11. {
    12.  public:
    13. 	void operator()(int val) 
    14. 	{
    15. 		cout << val << " ";
    16. 	}
    17. };
    18.  
    19. //for_each算法基本用法
    20. void test01() {
    21.  
    22. 	vector<int> v;
    23. 	for (int i = 0; i < 10; i++) 
    24. 	{
    25. 		v.push_back(i);
    26. 	}
    27.  
    28. 	//遍历算法
    29. 	for_each(v.begin(), v.end(), print01);
    30. 	cout << endl;
    31.  
    32. 	for_each(v.begin(), v.end(), print02());
    33. 	cout << endl;
    34. }
    5.1.2 transform(搬运)

    功能描述：

    • 搬运容器到另一个容器中

    函数原型：

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

    //beg1 源容器开始迭代器        end1 源容器结束迭代器

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

    //_func 函数或者函数对象

    1. #include<vector>
    2. #include<algorithm>
    3.  
    4. //常用遍历算法  搬运 transform
    5.  
    6. class TransForm
    7. {
    8. public:
    9. 	int operator()(int val)
    10. 	{
    11. 		return val;
    12. 	}
    13.  
    14. };
    15.  
    16. class MyPrint
    17. {
    18. public:
    19. 	void operator()(int val)
    20. 	{
    21. 		cout << val << " ";
    22. 	}
    23. };
    24.  
    25. void test01()
    26. {
    27. 	vector<int>v;
    28. 	for (int i = 0; i < 10; i++)
    29. 	{
    30. 		v.push_back(i);
    31. 	}
    32.  
    33. 	vector<int>vTarget; //目标容器
    34. 	vTarget.resize(v.size()); // 目标容器需要提前开辟空间
    35.  
    36. 	transform(v.begin(), v.end(), vTarget.begin(), TransForm());
    37. 	for_each(vTarget.begin(), vTarget.end(), MyPrint());
    38. }

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

    5.2 常用查找算法

    • find //查找元素

    • find_if //按条件查找元素

    • adjacent_find //查找相邻重复元素

    • binary_search //二分查找法

    • count //统计元素个数

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

    • find_first_of()  //查找在原字符串中第一个与指定字符串（或字符）中的某个字符匹配的字符

    • find_last_of()函数 //逆向查找在原字符串中最后一个与指定字符串（或字符）中的某个字符匹配的字符

    string str=“abcdefab”;
    cout< cout<

    string str=“abcdefab”;
    cout< cout< 

    1. #include<iostream>
    2. using namespace std;
    3. int main()
    4. {
    5.     string str="abcdefab";
    6.     cout<<str.find_first_of('a')<<endl;//第二个参数为0，默认从下标为0开始查找。
    7.     cout<<str.find_first_of("hce")<<endl;//待查串hce第一个出现在原串str中的字符是c，返回str中c的下标2,故结果为2。
    8.     cout<<str.find_first_of("ab",1)<<endl;//从下标为1开始查，待查串ab第一个出现在原串str中的字符是b，返回b的下标，结果为1。
    9.     cout<<str.find_first_of('h')<<endl;//原串没有待查字符h，故查不到，返回npos。
    10.     cout<<str.find_first_of("hw")<<endl;//待查子串任一字符在原串中都找不到，故查不到，返回npos。
    11.     cout<<str.find_last_of("wab")<<endl;//原串最后一个字符首先与待查子串的每一个字符一一比较，一旦有相同的就输出原串该字符的下标.。结果为b的下标7。
    12.     cout<<str.find_last_of("wab",5)<<endl;
    13.     //从原串中下标为5开始逆向查找，首先f与待查子串每一字符比较，若有相同的就输出该字符在原串的下标。
    14.     //若一个都没有，就依次逆向比较，即e再与待查子串一一比较，直到原串的b与待查子串中的b相同，然后输出该b在原串的下标1。
    15.     cout<<str.find_last_of("fab",5)<<endl;//输出f在原串的下标5。
    16.     cout<<str.find_last_of("fab",7)<<endl;//输出b在原串的下标7。
    17.     cout<<str.find_last_of("hwk")<<endl;//原串没有待查子串的任何字符，故返回npos。
    18.     return 0;
    19. }
    20. //有效的下标应该在0~len-1范围内。len=str.size();
    21.  
    22. /*
    23. 0
    24. 2
    25. 1
    26. 18446744073709551615
    27. 18446744073709551615
    28. 7
    29. 1
    30. 5
    31. 7
    32. 18446744073709551615
    33. */

     

    5.2.1 find

    功能描述：

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

    函数原型：

    • find(iterator beg, iterator end, value);

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

      // beg 开始迭代器                end 结束迭代器                value 查找的元素

      查找自定义类型时要重载 == 

    1. #include <algorithm>
    2. #include <vector>
    3. #include <string>
    4. // 内置数据类型
    5. void test01() {
    6. 	vector<int> v;
    7. 	for (int i = 0; i < 10; i++) {
    8. 		v.push_back(i + 1);
    9. 	}
    10. 	//查找容器中是否有 5 这个元素
    11. 	vector<int>::iterator it = find(v.begin(), v.end(), 5);
    12. 	if (it == v.end()) 
    13. 	{
    14. 		cout << "没有找到!" << endl;
    15. 	}
    16. 	else 
    17. 	{
    18. 		cout << "找到:" << *it << endl;
    19. 	}
    20. }
    21. // 自定义类型
    22. class Person {
    23. public:
    24. 	Person(string name, int age) 
    25. 	{
    26. 		this->m_Name = name;
    27. 		this->m_Age = age;
    28. 	}
    29. 	//重载==
    30. 	bool operator==(const Person& p) 
    31. 	{
    32. 		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age) 
    33. 		{
    34. 			return true;
    35. 		}
    36. 		return false;
    37. 	}
    38.  
    39. public:
    40. 	string m_Name;
    41. 	int m_Age;
    42. };
    43.  
    44. void test02() {
    45. 	vector<Person> v;
    46.  
    47. 	//创建数据
    48. 	Person p1("aaa", 10);
    49. 	Person p2("bbb", 20);
    50. 	Person p3("ccc", 30);
    51. 	Person p4("ddd", 40);
    52.  
    53. 	v.push_back(p1);
    54. 	v.push_back(p2);
    55. 	v.push_back(p3);
    56. 	v.push_back(p4);
    57.  
    58. 	vector<Person>::iterator it = find(v.begin(), v.end(), p2);
    59. 	if (it == v.end()) 
    60. 	{
    61. 		cout << "没有找到!" << endl;
    62. 	}
    63. 	else 
    64. 	{
    65. 		cout << "找到姓名:" << it->m_Name << " 年龄: " << it->m_Age << endl;
    66. 	}
    67. }
    5.2.2 find_if

    功能描述：

    • 按条件查找元素

    函数原型：

    find_if(iterator beg, iterator end, _Pred);

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

    // beg 开始迭代器        end 结束迭代器        _Pred 函数或者谓词（返回bool类型的仿函数）

    1. #include <algorithm>
    2. #include <vector>
    3. #include <string>
    4.  
    5. //内置数据类型
    6. class GreaterFive
    7. {
    8. public:
    9. 	bool operator()(int val)
    10. 	{
    11. 		return val > 5;
    12. 	}
    13. };
    14.  
    15. void test01() {
    16.  
    17. 	vector<int> v;
    18. 	for (int i = 0; i < 10; i++) {
    19. 		v.push_back(i + 1);
    20. 	}
    21.  
    22. 	vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
    23. 	if (it == v.end()) {
    24. 		cout << "没有找到!" << endl;
    25. 	}
    26. 	else {
    27. 		cout << "找到大于5的数字:" << *it << endl;  // 6
    28. 	}
    29. }
    30.  
    31. //自定义数据类型
    32. class Person {
    33. public:
    34. 	Person(string name, int age)
    35. 	{
    36. 		this->m_Name = name;
    37. 		this->m_Age = age;
    38. 	}
    39. public:
    40. 	string m_Name;
    41. 	int m_Age;
    42. };
    43.  
    44. class Greater20
    45. {
    46. public:
    47. 	bool operator()(Person &p)
    48. 	{
    49. 		return p.m_Age > 20;
    50. 	}
    51.  
    52. };
    53. void test02() {
    54. 	vector<Person> v;
    55.  
    56. 	//创建数据
    57. 	Person p1("aaa", 10);
    58. 	Person p2("bbb", 20);
    59. 	Person p3("ccc", 30);
    60. 	Person p4("ddd", 40);
    61.  
    62. 	v.push_back(p1);
    63. 	v.push_back(p2);
    64. 	v.push_back(p3);
    65. 	v.push_back(p4);
    66.  
    67. 	vector<Person>::iterator it = find_if(v.begin(), v.end(), Greater20());
    68. 	if (it == v.end())
    69. 	{
    70. 		cout << "没有找到!" << endl;
    71. 	}
    72. 	else
    73. 	{
    74. 		cout << "找到姓名:" << it->m_Name << " 年龄: " << it->m_Age << endl;
    75. 	}
    76. }

    5.2.3 adjacent_find(查找相邻重复)

    功能描述：

    • 查找相邻重复元素

    函数原型：

    adjacent_find(iterator beg, iterator end);

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

    // beg 开始迭代器        end 结束迭代器

    1. #include <algorithm>
    2. #include <vector>
    3.  
    4. void test01()
    5. {
    6. 	vector<int> v;
    7. 	v.push_back(1);
    8. 	v.push_back(2);
    9. 	v.push_back(5);
    10. 	v.push_back(2);
    11. 	v.push_back(4);
    12. 	v.push_back(4);
    13. 	v.push_back(3);
    14.  
    15. 	//查找相邻重复元素
    16. 	vector<int>::iterator it = adjacent_find(v.begin(), v.end());
    17. 	if (it == v.end()) {
    18. 		cout << "找不到!" << endl;
    19. 	}
    20. 	else {
    21. 		cout << "找到相邻重复元素为:" << *it << endl;  // 4
    22. 	}
    23. }
    5.2.4 binary_search

    功能描述：

    • 查找指定元素是否存在

    函数原型：

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

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

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

    // beg 开始迭代器                end 结束迭代器                value 查找的元素

    1. #include <algorithm>
    2. #include <vector>
    3.  
    4. void test01()
    5. {
    6. 	vector<int>v;
    7.  
    8. 	for (int i = 0; i < 10; i++)
    9. 	{
    10. 		v.push_back(i);
    11. 	}
    12. 	//二分查找
    13. 	bool ret = binary_search(v.begin(), v.end(),2);
    14. 	if (ret)
    15. 	{
    16. 		cout << "找到了" << endl;
    17. 	}
    18. 	else
    19. 	{
    20. 		cout << "未找到" << endl;
    21. 	}
    22. }
    5.2.5 count(统计)

    功能描述：

    • 统计元素个数

    函数原型：

    count(iterator beg, iterator end, value);

    // 统计元素出现次数

    // beg 开始迭代器                end 结束迭代器                value 统计的元素

    1. #include <algorithm>
    2. #include <vector>
    3.  
    4. //内置数据类型
    5. void test01()
    6. {
    7. 	vector<int> v;
    8. 	v.push_back(1);
    9. 	v.push_back(2);
    10. 	v.push_back(4);
    11. 	v.push_back(5);
    12. 	v.push_back(3);
    13. 	v.push_back(4);
    14. 	v.push_back(4);
    15.  
    16. 	int num = count(v.begin(), v.end(), 4);
    17.  
    18. 	cout << "4的个数为： " << num << endl;  // 3
    19. }
    20.  
    21. //自定义数据类型
    22. class Person
    23. {
    24. public:
    25. 	Person(string name, int age)
    26. 	{
    27. 		this->m_Name = name;
    28. 		this->m_Age = age;
    29. 	}
    30. 	bool operator==(const Person & p)
    31. 	{
    32. 		if (this->m_Age == p.m_Age)
    33. 		{
    34. 			return true;
    35. 		}
    36. 		else
    37. 		{
    38. 			return false;
    39. 		}
    40. 	}
    41. 	string m_Name;
    42. 	int m_Age;
    43. };
    44.  
    45. void test02()
    46. {
    47. 	vector<Person> v;
    48.  
    49. 	Person p1("刘备", 35);
    50. 	Person p2("关羽", 35);
    51. 	Person p3("张飞", 35);
    52. 	Person p4("赵云", 30);
    53. 	Person p5("曹操", 25);
    54.  
    55. 	v.push_back(p1);
    56. 	v.push_back(p2);
    57. 	v.push_back(p3);
    58. 	v.push_back(p4);
    59. 	v.push_back(p5);
    60.     
    61.     Person p("诸葛亮",35);
    62.  
    63. 	int num = count(v.begin(), v.end(), p);
    64. 	cout << "num = " << num << endl;
    65. }
    5.2.6 count_if(条件统计)

    功能描述：

    • 按条件统计元素个数

    函数原型：

    count_if(iterator beg, iterator end, _Pred);

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

    // beg 开始迭代器                end 结束迭代器                _Pred 谓词

    1. #include <algorithm>
    2. #include <vector>
    3.  
    4. class Greater4
    5. {
    6. public:
    7. 	bool operator()(int val)
    8. 	{
    9. 		return val >= 4;
    10. 	}
    11. };
    12.  
    13. //内置数据类型
    14. void test01()
    15. {
    16. 	vector<int> v;
    17. 	v.push_back(1);
    18. 	v.push_back(2);
    19. 	v.push_back(4);
    20. 	v.push_back(5);
    21. 	v.push_back(3);
    22. 	v.push_back(4);
    23. 	v.push_back(4);
    24.  
    25. 	int num = count_if(v.begin(), v.end(), Greater4());
    26.  
    27. 	cout << "大于4的个数为： " << num << endl;
    28. }
    29.  
    30. //自定义数据类型
    31. class Person
    32. {
    33. public:
    34. 	Person(string name, int age)
    35. 	{
    36. 		this->m_Name = name;
    37. 		this->m_Age = age;
    38. 	}
    39.  
    40. 	string m_Name;
    41. 	int m_Age;
    42. };
    43.  
    44. class AgeLess35
    45. {
    46. public:
    47. 	bool operator()(const Person &p)
    48. 	{
    49. 		return p.m_Age < 35;
    50. 	}
    51. };
    52. void test02()
    53. {
    54. 	vector<Person> v;
    55.  
    56. 	Person p1("刘备", 35);
    57. 	Person p2("关羽", 35);
    58. 	Person p3("张飞", 35);
    59. 	Person p4("赵云", 30);
    60. 	Person p5("曹操", 25);
    61.  
    62. 	v.push_back(p1);
    63. 	v.push_back(p2);
    64. 	v.push_back(p3);
    65. 	v.push_back(p4);
    66. 	v.push_back(p5);
    67.  
    68. 	int num = count_if(v.begin(), v.end(), AgeLess35());
    69. 	cout << "小于35岁的个数：" << num << endl;
    70. }

    5.3 常用排序算法

    算法简介：

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

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

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

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

    5.3.1 sort(排序)

    函数原型：

    sort(iterator beg, iterator end, _Pred);

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

    // beg 开始迭代器                end 结束迭代器                 _Pred 谓词

    1. #include <algorithm>
    2. #include <vector>
    3.  
    4. void myPrint(int val)
    5. {
    6. 	cout << val << " ";
    7. }
    8.  
    9. void test01() {
    10. 	vector<int> v;
    11. 	v.push_back(10);
    12. 	v.push_back(30);
    13. 	v.push_back(50);
    14. 	v.push_back(20);
    15. 	v.push_back(40);
    16.  
    17. 	//sort默认从小到大排序
    18. 	sort(v.begin(), v.end());
    19. 	for_each(v.begin(), v.end(), myPrint);
    20. 	cout << endl;
    21.  
    22. 	//从大到小排序  greater<int>()内置的函数
    23. 	sort(v.begin(), v.end(), greater<int>());
    24. 	for_each(v.begin(), v.end(), myPrint);
    25. 	cout << endl;
    26. }
    5.3.2 random_shuffle(随机打乱)

    功能描述：

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

    函数原型：

    random_shuffle(iterator beg, iterator end);

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

    // beg 开始迭代器                end 结束迭代器

    1. #include <algorithm>
    2. #include <vector>
    3. #include <ctime>
    4.  
    5. class myPrint
    6. {
    7. public:
    8. 	void operator()(int val)
    9. 	{
    10. 		cout << val << " ";
    11. 	}
    12. };
    13.  
    14. void test01()
    15. {
    16.     // 保证随机
    17. 	srand((unsigned int)time(NULL));
    18. 	vector<int> v;
    19. 	for(int i = 0 ; i < 10;i++)
    20. 	{
    21. 		v.push_back(i);
    22. 	}
    23. 	for_each(v.begin(), v.end(), myPrint());
    24. 	cout << endl;
    25.  
    26. 	//打乱顺序
    27. 	random_shuffle(v.begin(), v.end());
    28. 	for_each(v.begin(), v.end(), myPrint());
    29. 	cout << endl;
    30. }
    5.3.3 merge (合并)

    功能描述：

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

    函数原型：

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

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

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

    // beg1 容器1开始迭代器                end1 容器1结束迭代器

    //beg2 容器2开始迭代器                end2 容器2结束迭代器

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

    1. #include <algorithm>
    2. #include <vector>
    3.  
    4. class myPrint
    5. {
    6. public:
    7. 	void operator()(int val)
    8. 	{
    9. 		cout << val << " ";
    10. 	}
    11. };
    12.  
    13. void test01()
    14. {
    15. 	vector<int> v1;
    16. 	vector<int> v2;
    17. 	for (int i = 0; i < 10 ; i++) 
    18.     {
    19. 		v1.push_back(i);
    20. 		v2.push_back(i + 1);
    21. 	}
    22.  
    23. 	vector<int> vtarget;
    24. 	//目标容器需要提前开辟空间
    25. 	vtarget.resize(v1.size() + v2.size());
    26. 	//合并  需要两个有序序列
    27. 	merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vtarget.begin());
    28. 	for_each(vtarget.begin(), vtarget.end(), myPrint());
    29. 	cout << endl;
    30. }
    5.3.4 reverse(反转)

    功能描述：

    • 将容器内元素进行反转

    函数原型：

    reverse(iterator beg, iterator end);

    // 反转指定范围的元素

    // beg 开始迭代器                end 结束迭代器

    1. #include <algorithm>
    2. #include <vector>
    3.  
    4. class myPrint
    5. {
    6. public:
    7. 	void operator()(int val)
    8. 	{
    9. 		cout << val << " ";
    10. 	}
    11. };
    12.  
    13. void test01()
    14. {
    15. 	vector<int> v;
    16. 	v.push_back(10);
    17. 	v.push_back(30);
    18. 	v.push_back(50);
    19. 	v.push_back(20);
    20. 	v.push_back(40);
    21.  
    22. 	cout << "反转前： " << endl;
    23. 	for_each(v.begin(), v.end(), myPrint());
    24. 	cout << endl;
    25.  
    26. 	cout << "反转后： " << endl;
    27.  
    28. 	reverse(v.begin(), v.end());
    29. 	for_each(v.begin(), v.end(), myPrint());
    30. 	cout << endl;
    31. }

    5.4 常用拷贝和替换算法

    算法简介：

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

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

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

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

    5.4.1 copy(拷贝)

    功能描述：

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

    函数原型：

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

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

    // beg 开始迭代器        end 结束迭代器        dest 目标起始迭代器

    1. v2.resize(v1.size());  // 提前开辟空间
    2. copy(v1.begin(), v1.end(), v2.begin());
    5.4.2 replace(修改元素)

    功能描述：

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

    函数原型：

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

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

    // beg 开始迭代器        end 结束迭代器        oldvalue 旧元素        newvalue 新元素

    1. replace(v.begin(), v.end(), 20,2000);
    2. // 20 用 2000 替换
    5.4.3 replace_if(条件替换)

    功能描述:

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

    函数原型：

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

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

    // beg 开始迭代器        end 结束迭代器        _pred 谓词        newvalue 替换的新元素

    1. // 仿函数
    2. class ReplaceGreater30
    3. {
    4. public:
    5. 	bool operator()(int val)
    6. 	{
    7. 		return val >= 30;
    8. 	}
    9.  
    10. };
    11.  
    12. replace_if(v.begin(), v.end(), ReplaceGreater30(), 3000);

    5.4.4 swap

    功能描述：

    • 互换两个容器的元素

    函数原型：

    swap(container c1, container c2);

    // 互换两个容器的元素

    // c1容器1                c2容器2

    swap(v1, v2);

    5.5 常用算术生成算法

    注意：

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

    算法简介：

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

    • fill // 向容器中添加元素

    5.5.1 accumulate(sum)

    功能描述：

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

    函数原型：

    accumulate(iterator beg, iterator end, value);

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

    // beg 开始迭代器        end 结束迭代器        value 起始值

    1. #include <numeric>
    2. #include <vector>
    3. void test01()
    4. {
    5. 	vector<int> v;
    6. 	for (int i = 0; i <= 100; i++) {
    7. 		v.push_back(i);
    8. 	}
    9.  
    10. 	int total = accumulate(v.begin(), v.end(), 0);
    11. 	cout << "total = " << total << endl;
    12. }
    13.  
    14. int main() {
    15.  
    16. 	test01();
    17. 	system("pause");
    18. 	return 0;
    19. }
    5.5.2 fill(填充)

    功能描述：

    • 向容器中填充指定的元素

    函数原型：

    fill(iterator beg, iterator end, value);

    // 向容器中填充元素

    // beg 开始迭代器        end 结束迭代器        value 填充的值

    1. vector<int> v;
    2. v.resize(10);
    3. //填充
    4. fill(v.begin(), v.end(), 100);

    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 目标容器开始迭代器

    1. void test01()
    2. {
    3. 	vector<int> v1;
    4. 	vector<int> v2;
    5. 	for (int i = 0; i < 10; i++)
    6.     {
    7. 		v1.push_back(i);
    8. 		v2.push_back(i+5);
    9. 	}
    10.  
    11. 	vector<int> vTarget;
    12. 	//取两个里面较小的值给目标容器开辟空间
    13. 	vTarget.resize(min(v1.size(), v2.size()));
    14.  
    15. 	//返回目标容器的最后一个元素的迭代器地址
    16. 	vector<int>::iterator itEnd = 
    17.         set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    18.  
    19. 	for_each(vTarget.begin(), itEnd, myPrint());
    20. 	cout << endl;
    21. }
    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 目标容器开始迭代器

    1. void test01()
    2. {
    3. 	vector<int> v1;
    4. 	vector<int> v2;
    5. 	for (int i = 0; i < 10; i++) {
    6. 		v1.push_back(i);
    7. 		v2.push_back(i+5);
    8. 	}
    9.  
    10. 	vector<int> vTarget;
    11. 	//取两个容器的和给目标容器开辟空间
    12. 	vTarget.resize(v1.size() + v2.size());
    13.  
    14. 	//返回目标容器的最后一个元素的迭代器地址
    15. 	vector<int>::iterator itEnd = 
    16.         set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    17.  
    18. 	for_each(vTarget.begin(), itEnd, myPrint());
    19. 	cout << endl;
    20. }

    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 目标容器开始迭代器

    1. void test01()
    2. {
    3. 	vector<int> v1;
    4. 	vector<int> v2;
    5. 	for (int i = 0; i < 10; i++) {
    6. 		v1.push_back(i);
    7. 		v2.push_back(i+5);
    8. 	}
    9.  
    10. 	vector<int> vTarget;
    11. 	//取两个里面较大的值给目标容器开辟空间
    12. 	vTarget.resize( max(v1.size() , v2.size()));
    13.  
    14. 	//返回目标容器的最后一个元素的迭代器地址
    15. 	cout << "v1与v2的差集为： " << endl;
    16. 	vector<int>::iterator itEnd = 
    17.         set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    18. 	for_each(vTarget.begin(), itEnd, myPrint());
    19. 	cout << endl;
    20.  
    21.  
    22. 	cout << "v2与v1的差集为： " << endl;
    23. 	itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
    24. 	for_each(vTarget.begin(), itEnd, myPrint());
    25. 	cout << endl;
    26. }

  • 相关阅读:
    6 个 Python f 字符串提示和技巧
    Spring Boot 学习总结（34）—— spring-boot-starter-xxx 和 xxx-spring-boot-starter 区别？
    数学建模之多项式回归
    计算机竞赛 题目：基于深度学习的图像风格迁移 - [ 卷积神经网络 机器视觉 ]
    Power Series and Laplace Transforms
    SpringBoot整合SQLite
    halcon测量助手使用笔记
    Java的集合框架总结
    npm ERR! code ELIFECYCLE
    计算机网络笔记2 物理层
  • 原文地址：https://blog.csdn.net/weixin_45699456/article/details/132724095