• STL - 常用算法

    概述：

    • 算法主要是由头文件组成
    • 是所有STL头文件中最大的一个，范围涉及比较、 交换、查找、遍历操作、复制、修改等等
    • 体积很小，只包括几个在序列上面进行简单数学运算的模板函数
    • 定义了一些模板类，用以声明函数对象。

    5.1. 常用遍历算法

    学习目标：

    • 掌握常用的遍历算法

    算法简介：

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

    5.1.1. for_each

    功能描述：

    • 实现遍历容器
    • 在实际开发中最常用的遍历算法，必须熟练掌握

    函数原型：

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

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

    // beg 开始迭代器

    // end 结束迭代器

    // _func 函数或者函数对象

    1. #include<iostream>
    2. using namespace std;
    3. #include<vector>
    4. #include<algorithm>
    5.  
    6. // 普通函数
    7. void Print01(int val)
    8. {
    9.     cout << val << ' ';
    10. }
    11.  
    12. // 仿函数
    13. class Print02
    14. {
    15. public:
    16.     void operator()(int val)
    17.     {
    18.         cout << val << ' ';
    19.     }
    20. };
    21.  
    22. void Test01()
    23. {
    24.     vector<int> v;
    25.  
    26.     for(int i = 0; i < 10; i++)
    27.     {
    28.         v.push_back(i);
    29.     }
    30.  
    31.     for_each(v.begin(), v.end(), Print01);
    32.     cout << endl;
    33.  
    34.     for_each(v.begin(), v.end(), Print02());
    35.     cout << endl;
    36. }
    37.  
    38. int main()
    39. {
    40.     Test01();
    41.     return 0;
    42. }
    43.  
    44. 输出：
    45. -----------------------------------------------------------------------------------------
    46. 0 1 2 3 4 5 6 7 8 9 
    47. 0 1 2 3 4 5 6 7 8 9

    5.1.2. transform

    功能描述：

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

    函数原型：

    • transform(iterator begl, iterator endl, iterator beg2, _func);

    //beg1 源容器开始迭代器

    //end1 源容器结束迭代器

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

    //_func 函数或者函数对象

    1. #include<iostream>
    2. using namespace std;
    3. #include<vector>
    4. #include<algorithm>
    5.  
    6. // 仿函数
    7. class Transform
    8. {
    9. public:
    10.     int operator()(int val)
    11.     {
    12.         return val + 100;
    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.  
    29.     for(int i = 0; i < 10; i++)
    30.     {
    31.         v.push_back(i);
    32.     }
    33.  
    34.     vector<int> vTarget;
    35.     vTarget.resize(v.size());  // 目标容器需要提前开辟空间
    36.  
    37.     transform(v.begin(), v.end(), vTarget.begin(), Transform());
    38.  
    39.     for_each(vTarget.begin(), vTarget.end(), MyPrint());
    40.     cout << endl;
    41. }
    42.  
    43. int main()
    44. {
    45.     Test01();
    46.     return 0;
    47. }
    48.  
    49. 输出：
    50. -----------------------------------------------------------------------------------------
    51. 100 101 102 103 104 105 106 107 108 109

    5.2. 常用查找算法

    学习目标：

    • 掌握常用的查找算法

    算法简介:

    • find //查找元素
    • find_if //按条件查找元素
    • adjacent_find //查找相邻重复元素
    • binary_search //二分查找法
    • count //统计元素个数
    • count_if //按条件统计元素个数

    5.2.1. find

    功能描述：

    • 查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()
    • 利用find可以在容器中找到指定的元素，返回值是迭代器

    函数原型：

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

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

    // beg 开始迭代器

    // end 结束迭代器

    // value 查找的元素

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6.  
    7.  
    8. // 查找内置数据类型
    9. void Test01()
    10. {
    11.     vector<int> v;
    12.  
    13.     for(int i = -5; i < 10; i++)
    14.     {
    15.         v.push_back(i);
    16.     }
    17.  
    18.     vector<int>::iterator it = find(v.begin(), v.end(), 5);
    19.     if (it == v.end())
    20.     {
    21.         cout << "not find!" << endl;
    22.     }
    23.     else
    24.     {
    25.         cout << "find-" << *it << endl;
    26.     }
    27.  
    28. }
    29.  
    30. // 查找自定义数据类型
    31. class Person
    32. {
    33. public:
    34.     Person(string name, int age) : m_name(name), m_age(age){}
    35.  
    36.     // 重载 == ，让底层的find知道如何对比person数据类型
    37.     bool operator==(const Person & p)
    38.     {
    39.         if(this->m_name == p.m_name && this->m_age == p.m_age)
    40.         {
    41.             return true;
    42.         }
    43.         else
    44.         {
    45.             return false;
    46.         }
    47.     }
    48.  
    49.     string m_name;
    50.     int m_age;
    51. };
    52.  
    53. void Test02()
    54. {
    55.         vector<Person> v;
    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(v.begin(), v.end(), p2);
    68.         if (it == v.end())
    69.         {
    70.             cout << "not find!" << endl;
    71.         }
    72.         else
    73.         {
    74.             cout << "find-name:" << it->m_name << " find-age:" << it->m_age << endl;
    75.         }
    76. }
    77.  
    78. int main()
    79. {
    80.     Test01();
    81.     Test02();
    82.  
    83.     return 0;
    84. }
    85.  
    86. 输出：
    87. -----------------------------------------------------------------------------------------
    88. find-5
    89. find-name:bbb find-age:20

    5.2.2. find_if

    功能描述：

    • 按条件查找元素

    函数原型：

    • find _if(iterator beg, iterator end, _pred);

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

    // beg 开始迭代器

    // end 结束迭代器

    // _Pred 函数或者谓词(返回bool类型的仿函数)

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6.  
    7. class GreaterFive
    8. {
    9. public:
    10.     bool operator()(int val)
    11.     {
    12.         return val > 5;
    13.     }
    14. };
    15.  
    16. class Person
    17. {
    18. public:
    19.  
    20.     Person(string name, int age) : m_name(name), m_age(age){}
    21.  
    22.     string m_name;
    23.     int m_age;
    24. };
    25.  
    26. // 查找内置数据类型
    27. void Test01()
    28. {
    29.     vector<int> v;
    30.  
    31.     for(int i = 0; i < 10; i++)
    32.     {
    33.         v.push_back(i);
    34.     }
    35.     
    36.     vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
    37.  
    38.     if(it == v.end())
    39.     {
    40.         cout << "没有找到" << endl;
    41.     }
    42.     else
    43.     {
    44.         cout << "找到了大于5的数字为：" << *it << endl;
    45.     }
    46. }
    47.  
    48. class Greater20
    49. {
    50. public:
    51.     bool operator()(Person &p)
    52.     {
    53.         return p.m_age > 20;
    54.     }
    55. };
    56.  
    57. void Test02()
    58. {
    59.     vector<Person> v;
    60.  
    61.     Person p1("孙悟空", 100);
    62.     Person p2("猪八戒", 80);
    63.     Person p3("沙僧", 30);
    64.     Person p4("唐僧", 10);
    65.  
    66.     v.push_back(p1);
    67.     v.push_back(p2);
    68.     v.push_back(p3);
    69.     v.push_back(p4);
    70.  
    71.     vector<Person>::iterator it = find_if(v.begin(), v.end(), Greater20());
    72.  
    73.     if(it == v.end())
    74.     {
    75.         cout << "没有找到" << endl;
    76.     }
    77.     else
    78.     {
    79.         cout << "找到了大于20岁的人：" << it->m_name << " " << it->m_age << endl;
    80.     }
    81.  
    82. }
    83.  
    84. int main()
    85. {
    86.     Test01();
    87.     Test02();
    88.  
    89.     return 0;
    90. }
    91.  
    92. 输出：
    93. -----------------------------------------------------------------------------------------
    94. 找到了大于5的数字为：6
    95. 找到了大于20岁的人：孙悟空 100

    5.2.3. adjacent_find

    功能描述：

    • 查找相邻重复元素

    函数原型：

    • adjacent find(iterator beg, iterator end);

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

    // beg 开始迭代器

    // end 结束迭代器

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6.  
    7. // 查找内置数据类型
    8. void Test01()
    9. {
    10.     vector<int> v;
    11.  
    12.     v.push_back(0);
    13.     v.push_back(2);
    14.     v.push_back(4);
    15.     v.push_back(6);
    16.     v.push_back(6);
    17.     v.push_back(8);
    18.     v.push_back(10);
    19.     v.push_back(10);
    20.     
    21.     vector<int>::iterator it = adjacent_find(v.begin(), v.end());
    22.  
    23.     if(it == v.end())
    24.     {
    25.         cout << "没有找到" << endl;
    26.     }
    27.     else
    28.     {
    29.         cout << "找到的第一个相邻重复元素为：" << *it << endl;
    30.     }
    31. }
    32.  
    33.  
    34. int main()
    35. {
    36.     Test01();
    37.  
    38.     return 0;
    39. }
    40.  
    41. 输出：
    42. -----------------------------------------------------------------------------------------
    43. 找到的相邻重复元素为：6

    5.2.4. binary_search

    功能描述：

    • 查找指定元素是否存在
    • 二分查找，指数级运算，速度非常快
    • 二分查找法查找效率很高，值得注意的是查找的容器中的元素必须是有序序列，否则结果不一定对

    函数原型：

    • bool binary search(iterator beg, iterator end, value);

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

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

    // beg 开始迭代器

    // end 结束迭代器

    // value 查找的元素

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6.  
    7. // 查找内置数据类型
    8. void Test01()
    9. {
    10.     vector<int> v;
    11.  
    12.     v.push_back(0);
    13.     v.push_back(2);
    14.     v.push_back(4);
    15.     v.push_back(6);
    16.     v.push_back(6);
    17.     v.push_back(8);
    18.     v.push_back(10);
    19.     v.push_back(10);
    20.     
    21.     bool ret = binary_search(v.begin(), v.end(), 9);
    22.  
    23.     if(!ret)
    24.     {
    25.         cout << "没有找到" << endl;
    26.     }
    27.     else
    28.     {
    29.         cout << "成功找到" << endl;
    30.     }
    31. }
    32.  
    33.  
    34. int main()
    35. {
    36.     Test01();
    37.  
    38.     return 0;
    39. }
    40.  
    41. 输出：
    42. -----------------------------------------------------------------------------------------
    43. 没有找到

    5.2.5. count

    功能描述：

    • 统计元素个数

    函数原型：

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

    // 统计元素出现次数

    // beg 开始迭代器

    // end 结束迭代器

    // value 统计的元素

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6.  
    7. class Person
    8. {
    9. public:
    10.  
    11.     Person(string name, int age) : m_name(name), m_age(age){}
    12.  
    13.     bool operator==(const Person & p)
    14.     {
    15.         if(this->m_age == p.m_age)
    16.         {
    17.             return true;
    18.         }
    19.         else
    20.         {
    21.             return false;
    22.         }
    23.     }
    24.  
    25.     string m_name;
    26.     int m_age;
    27. };
    28. // 查找内置数据类型
    29. void Test01()
    30. {
    31.     vector<int> v;
    32.  
    33.     v.push_back(0);
    34.     v.push_back(2);
    35.     v.push_back(4);
    36.     v.push_back(6);
    37.     v.push_back(6);
    38.     v.push_back(8);
    39.     v.push_back(10);
    40.     v.push_back(10);
    41.     v.push_back(10);
    42.     
    43.     int num = count(v.begin(), v.end(), 10);
    44.  
    45.     cout << "10的元素个数为：" << num << endl;
    46. }
    47.  
    48. void Test02()
    49. {
    50.     vector<Person> v;
    51.  
    52.     Person p1("刘备", 35);
    53.     Person p2("关羽", 35);
    54.     Person p3("张飞", 35);
    55.     Person p4("赵云", 30);
    56.     Person p5("曹操", 44);
    57.  
    58.     Person p("诸葛亮", 35);
    59.  
    60.     v.push_back(p1);
    61.     v.push_back(p2);
    62.     v.push_back(p3);
    63.     v.push_back(p4);
    64.     v.push_back(p5);
    65.  
    66.     
    67.     int num = count(v.begin(), v.end(), p);
    68.  
    69.     cout << "和诸葛亮同岁的人有：" << num << "个" << endl;
    70. }
    71.  
    72.  
    73. int main()
    74. {
    75.     Test01();
    76.     Test02();
    77.  
    78.     return 0;
    79. }
    80.  
    81. 输出：
    82. -----------------------------------------------------------------------------------------
    83. 10的元素个数为：3
    84. 和诸葛亮同岁的人有：3个

    5.2.6. count_if

    功能描述：

    • 按条件统计元素个数

    函数原型：

    • count_if(iterator beg, iterator end, _Pred);

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

    // beg 开始迭代器

    // end 结束迭代器

    // _Pred 谓词

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6.  
    7. class Person
    8. {
    9. public:
    10.  
    11.     Person(string name, int age) : m_name(name), m_age(age){}
    12.  
    13.     bool operator==(const Person & p)
    14.     {
    15.         if(this->m_age == p.m_age)
    16.         {
    17.             return true;
    18.         }
    19.         else
    20.         {
    21.             return false;
    22.         }
    23.     }
    24.  
    25.     string m_name;
    26.     int m_age;
    27. };
    28.  
    29. class Greater20
    30. {
    31. public:
    32.     bool operator()(int v1)
    33.     {
    34.         return v1 > 20;
    35.     }
    36. };
    37.  
    38. // 查找内置数据类型
    39. void Test01()
    40. {
    41.     vector<int> v;
    42.  
    43.     v.push_back(0);
    44.     v.push_back(2);
    45.     v.push_back(4);
    46.     v.push_back(6);
    47.     v.push_back(6);
    48.     v.push_back(8);
    49.     v.push_back(10);
    50.     v.push_back(30);
    51.     v.push_back(50);
    52.     
    53.     int num = count_if(v.begin(), v.end(), Greater20());
    54.  
    55.     cout << "大于20的元素个数为：" << num << endl;
    56. }
    57.  
    58. class GreaterPerson
    59. {
    60. public:
    61.     bool operator()(const Person & p)
    62.     {
    63.         return p.m_age > 20;
    64.     }
    65. };
    66.  
    67. void Test02()
    68. {
    69.     vector<Person> v;
    70.  
    71.     Person p1("刘备", 35);
    72.     Person p2("关羽", 35);
    73.     Person p3("张飞", 35);
    74.     Person p4("赵云", 30);
    75.     Person p5("曹操", 44);
    76.  
    77.     v.push_back(p1);
    78.     v.push_back(p2);
    79.     v.push_back(p3);
    80.     v.push_back(p4);
    81.     v.push_back(p5);
    82.  
    83.     int num = count_if(v.begin(), v.end(), GreaterPerson());
    84.  
    85.     cout << "年龄大于20的人数：" << num << endl;
    86. }
    87.  
    88.  
    89. int main()
    90. {
    91.     Test01();
    92.     Test02();
    93.  
    94.     return 0;
    95. }
    96.  
    97. 输出：
    98. -----------------------------------------------------------------------------------------
    99. 大于20的元素个数为：2
    100. 年龄大于20的人数：5

    5.3. 常用排序算法

    学习目标：

    • 掌握常用的排序算法

    算法简介：

    • sort // 对容器内元素进行排序
    • random_shuffle // 洗牌，指定范围内的元素随机调整次序
    • merge // 容器元素合并，并存储到另一容器中
    • reverse // 反转指定范围的元素

    5.3.1. sort

    功能描述：

    • 对容器内元素进行排序（默认从小到大）

    函数原型：

    • sort(iterator beg, iterator end, _Pred);

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

    // beg 开始迭代器

    // end 结束迭代器

    // _Pred 谓词

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6.  
    7. void MyPrint(int val)
    8. {
    9.     cout << val << " ";
    10. }
    11.  
    12. // 查找内置数据类型
    13. void Test01()
    14. {
    15.     vector<int> v;
    16.  
    17.     v.push_back(1);
    18.     v.push_back(3);
    19.     v.push_back(5);
    20.     v.push_back(2);
    21.     v.push_back(4);
    22.     v.push_back(9);
    23.     v.push_back(7);
    24.     
    25.     sort(v.begin(), v.end());
    26.     for_each(v.begin(), v.end(), MyPrint);
    27.     cout << endl;
    28.  
    29.     sort(v.begin(), v.end(), greater<int>());
    30.     for_each(v.begin(), v.end(), MyPrint);
    31.     cout << endl;
    32. }
    33.  
    34.  
    35. int main()
    36. {
    37.     Test01();
    38.  
    39.     return 0;
    40. }
    41.  
    42. 输出：
    43. -----------------------------------------------------------------------------------------
    44. 1 2 3 4 5 7 9 
    45. 9 7 5 4 3 2 1

    5.3.2. random_shuffle

    功能描述：

    • 洗牌，指定范围内的元素随机调整次序
    • 若想每次都不一样，要加随机数种子

    函数原型：

    • random_shuffle(iterator_beg, iterator_end);

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

    // beg 开始迭代器

    // end 结束迭代器

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6. #include<ctime>
    7.  
    8. void MyPrint(int val)
    9. {
    10.     cout << val << " ";
    11. }
    12.  
    13. void Test01()
    14. {
    15.     srand((unsigned int) time (NULL));
    16.     vector<int> v;
    17.  
    18.     for (int i = 0; i < 10; i++)
    19.     {
    20.         v.push_back(i);
    21.     }
    22.     
    23.     random_shuffle(v.begin(), v.end());
    24.     for_each(v.begin(), v.end(), MyPrint);
    25.     cout << endl;
    26.  
    27.     random_shuffle(v.begin(), v.end());
    28.     for_each(v.begin(), v.end(), MyPrint);
    29.     cout << endl;
    30. }
    31.  
    32. int main()
    33. {
    34.     Test01();
    35.  
    36.     return 0;
    37. }
    38.  
    39. 输出：
    40. -----------------------------------------------------------------------------------------
    41. 0 8 6 4 5 1 7 2 3 9 
    42. 0 3 1 2 4 6 8 9 7 5

    5.3.3. merge

    功能描述：

    • 两个容器元素合并，并存储到另一容器中
    • 目标容器需要提前开辟空间
    • 合并后的序列还是一个有序序列

    函数原型：

    • merge(iterator begl, iterator end1, iterator beg2, iterator end2, iterator dest);

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

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

    // beg1 容器1开始迭代器

    // end1 容器1结束迭代器

    // beg2 容器2开始迭代器

    // end2 容器2结束迭代器

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

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6.  
    7. void MyPrint(int val)
    8. {
    9.     cout << val << " ";
    10. }
    11.  
    12. // 查找内置数据类型
    13. void Test01()
    14. {
    15.     vector<int> v1;
    16.     vector<int> v2;
    17.  
    18.     for(int i = 0; i < 10; i++)
    19.     {
    20.         v1.push_back(i);
    21.         v2.push_back(i+1);
    22.     }
    23.     
    24.     vector<int> v3;
    25.     v3.resize(v1.size() + v2.size());
    26.     
    27.     merge(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin());
    28.  
    29.     for_each(v3.begin(), v3.end(), MyPrint);
    30.     cout << endl;
    31. }
    32.  
    33.  
    34. int main()
    35. {
    36.     Test01();
    37.  
    38.     return 0;
    39. }
    40.  
    41. 输出：
    42. -----------------------------------------------------------------------------------------
    43. 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10

    5.3.4. reverse

    功能描述：

    • 将容器内元素进行反转

    函数原型：

    • reverse(iterator beg,iterator end);

    // 反转指定范围的元素

    // beg 开始迭代器

    // end 结束迭代器

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6.  
    7. void MyPrint(int val)
    8. {
    9.     cout << val << " ";
    10. }
    11.  
    12. // 查找内置数据类型
    13. void Test01()
    14. {
    15.     vector<int> v;
    16.  
    17.     for(int i = 0; i < 10; i++)
    18.     {
    19.         v.push_back(i);
    20.     }
    21.     
    22.     reverse(v.begin(), v.end());
    23.  
    24.     for_each(v.begin(), v.end(), MyPrint);
    25.     cout << endl;
    26. }
    27.  
    28. int main()
    29. {
    30.     Test01();
    31.  
    32.     return 0;
    33. }
    34.  
    35. 输出：
    36. -----------------------------------------------------------------------------------------
    37. 9 8 7 6 5 4 3 2 1 0

    5.4. 常用拷贝和替换算法

    学习目标：

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

    算法简介：

    • copy // 容器内指定范围的元素拷贝到另一容器中
    • replace // 将容器内指定范围的旧元素修改为新元素
    • replace_if // 容器内指定范围满足条件的元素替换为新元素
    • swap // 互换两个容器的元素

    5.4.1. copy

    功能描述：

    • 容器内指定范围的元素拷贝到另一容器中
    • 目标容器要提前开辟空间

    函数原型：

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

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

    // beg 开始迭代器

    // end 结束迭代器

    // dest 目标起始迭代器

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6.  
    7. void MyPrint(int val)
    8. {
    9.     cout << val << " ";
    10. }
    11.  
    12. // 查找内置数据类型
    13. void Test01()
    14. {
    15.     vector<int> v;
    16.  
    17.     for(int i = 0; i < 10; i++)
    18.     {
    19.         v.push_back(i);
    20.     }
    21.     
    22.     vector<int> v2;
    23.     v2.resize(v.size());
    24.  
    25.     copy(v.begin(), v.end(), v2.begin());
    26.     
    27.     for_each(v2.begin(), v2.end(), MyPrint);
    28.     cout << endl;
    29. }
    30.  
    31. int main()
    32. {
    33.     Test01();
    34.  
    35.     return 0;
    36. }
    37.  
    38. 输出：
    39. -----------------------------------------------------------------------------------------
    40. 0 1 2 3 4 5 6 7 8 9

    5.4.2. replace

    功能描述：

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

    函数原型：

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

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

    // beg 开始迭代器

    // end 结束迭代器

    // oldvalue 旧元素

    // newvalue 新元素

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6.  
    7. class MyPrint
    8. {
    9. public:
    10.  
    11.     void operator()(int val)
    12.     {
    13.         cout << val << " ";
    14.     }
    15. };
    16.  
    17. // 查找内置数据类型
    18. void Test01()
    19. {
    20.     vector<int> v;
    21.  
    22.     for(int i = 0; i < 10; i++)
    23.     {
    24.         v.push_back(i);
    25.     }
    26.     
    27.     replace(v.begin(), v.end(), 3, 100);
    28.  
    29.     for_each(v.begin(), v.end(), MyPrint());
    30.     cout << endl;
    31. }
    32.  
    33. int main()
    34. {
    35.     Test01();
    36.  
    37.     return 0;
    38. }
    39.  
    40. 输出：
    41. -----------------------------------------------------------------------------------------
    42. 0 1 2 100 4 5 6 7 8 9

    5.4.3. replace_if

    功能描述：

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

    函数原型：

    • replace if(iterator beg, iterator end, _pred, newvalue);

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

    // beg 开始迭代器

    // end 结束迭代器

    // _pred 谓词

    // newvalue 替换的新元素

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6.  
    7. class Greater5
    8. {
    9. public:
    10.  
    11.     bool operator()(int val)
    12.     {
    13.         return val > 5;
    14.     }
    15. };
    16.  
    17. class MyPrint
    18. {
    19. public:
    20.     void operator()(int val)
    21.     {
    22.         cout << val << " ";
    23.     }
    24. };
    25.  
    26. // 查找内置数据类型
    27. void Test01()
    28. {
    29.     vector<int> v;
    30.  
    31.     for(int i = 0; i < 10; i++)
    32.     {
    33.         v.push_back(i);
    34.     }
    35.     
    36.     replace_if(v.begin(), v.end(), Greater5(), 100);
    37.  
    38.     for_each(v.begin(), v.end(), MyPrint());
    39.     cout << endl;
    40. }
    41.  
    42. int main()
    43. {
    44.     Test01();
    45.  
    46.     return 0;
    47. }
    48.  
    49. 输出：
    50. -----------------------------------------------------------------------------------------
    51. 0 1 2 3 4 5 100 100 100 100

    5.4.4. swap

    功能描述：

    • 互换两个容器的元素

    函数原型：

    • swap(container c1,container c2);

    // 互换两个容器的元素

    // c1容器1

    // c2容器2

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6.  
    7. class MyPrint
    8. {
    9. public:
    10.     void operator()(int val)
    11.     {
    12.         cout << val << " ";
    13.     }
    14. };
    15.  
    16. // 查找内置数据类型
    17. void Test01()
    18. {
    19.     vector<int> v1;
    20.     vector<int> v2;
    21.  
    22.     for(int i = 0; i < 10; i++)
    23.     {
    24.         v1.push_back(i);
    25.         v2.push_back(i+100);
    26.     }
    27.     
    28.     cout << "交换前：" << endl;
    29.     for_each(v1.begin(), v1.end(), MyPrint());
    30.     for_each(v2.begin(), v2.end(), MyPrint());
    31.     cout << endl;
    32.  
    33.     swap(v1, v2);
    34.     
    35.     cout << "交换后：" << endl;
    36.     for_each(v1.begin(), v1.end(), MyPrint());
    37.     for_each(v2.begin(), v2.end(), MyPrint());
    38.     cout << endl;
    39. }
    40.  
    41. int main()
    42. {
    43.     Test01();
    44.  
    45.     return 0;
    46. }
    47.  
    48. 输出：
    49. -----------------------------------------------------------------------------------------
    50. 交换前：
    51. 0 1 2 3 4 5 6 7 8 9 100 101 102 103 104 105 106 107 108 109
    52. 交换后：
    53. 100 101 102 103 104 105 106 107 108 109 0 1 2 3 4 5 6 7 8 9

    5.5. 常用算术生成算法

    学习目标：

    • 掌握常用的算术生成算法

    注意：

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

    算法简介：

    • accumulate // 计算容器元素累计总和
    • fill // 向容器中添加元素

    5.5.1. accumulate

    功能描述：

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

    函数原型：

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

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

    // beg 开始迭代器

    // end 结束迭代器

    // value 起始值

    1. #include<iostream>
    2. using namespace std;
    3. #include<vector>
    4. #include<numeric>
    5.  
    6. // 查找内置数据类型
    7. void Test01()
    8. {
    9.     vector<int> v;
    10.  
    11.     for(int i = 0; i <= 100; i++)
    12.     {
    13.         v.push_back(i);
    14.     }
    15.     
    16.     int total = accumulate(v.begin(), v.end(), 0);
    17.  
    18.     cout << total << endl;
    19. }
    20.  
    21. int main()
    22. {
    23.     Test01();
    24.  
    25.     return 0;
    26. }
    27.  
    28. 输出：
    29. -----------------------------------------------------------------------------------------
    30. 5050

    5.5.2. fill

    功能描述：

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

    函数原型：

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

    // 向容器中填充元素

    // beg 开始迭代器

    // end 结束迭代器

    // value 填充的值

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6. #include<numeric>
    7.  
    8. class MyPrint
    9. {
    10. public:
    11.     void operator()(int val)
    12.     {
    13.         cout << val << " ";
    14.     }
    15. };
    16.  
    17. void Test01()
    18. {
    19.     vector<int> v;
    20.  
    21.     // 初始化容器大小为10，并全部填充为0
    22.     v.resize(10);
    23.     for(vector<int>::iterator it = v.begin(); it != v.end(); it++)
    24.     {
    25.         cout << *it << ' ';
    26.     }
    27.     cout << endl;
    28.  
    29.     // 重新填充
    30.     fill(v.begin(), v.end(), 100);
    31.     for_each(v.begin(), v.end(), MyPrint());
    32. }
    33.  
    34. int main()
    35. {
    36.     Test01();
    37.  
    38.     return 0;
    39. }
    40.  
    41. 输出：
    42. -----------------------------------------------------------------------------------------
    43. 0 0 0 0 0 0 0 0 0 0 
    44. 100 100 100 100 100 100 100 100 100 100

    5.6. 常用集合算法

    学习目标：

    • 掌握常用的集合算法

    算法简介：

    • set_intersection // 求两个容器的交集
    • set_union // 求两个容器的并集
    • set_difference // 求两个容器的差集

    5.6.1. set_intersection

    功能描述：

    • 求两个容器的交集

    函数原型：

    • set_intersection(iterator begl, iterator end1, iterator beg2, iterator end2, iterator dest);

    // 求两个集合的交集

    // beg1 容器1开始迭代器

    // end1 容器1结束迭代器

    // beg2 容器2开始迭代器

    // end2 容器2结束迭代器

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

    总结：

    • 求交集的两个集合必须是有序序列
    • 目标容器开辟的空间为两个容器中size最小的哪一个
    • set_intersection的返回值是交集迭代器中最后一个元素的位置
    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6. #include<numeric>
    7.  
    8. class MyPrint
    9. {
    10. public:
    11.     void operator()(int val)
    12.     {
    13.         cout << val << " ";
    14.     }
    15. };
    16.  
    17. void Test01()
    18. {
    19.     vector<int> v1;
    20.     vector<int> v2;
    21.  
    22.     for(int i = 0; i < 10; i++)
    23.     {
    24.         v1.push_back(i);                  // 0~9
    25.         v2.push_back(i + 5);              // 5~14
    26.     }
    27.  
    28.     vector<int> vTarget;
    29.  
    30.     // 目标容器需要提前开辟空间
    31.     // 最特殊情况：大容器完全包含小容器，开辟空间时取小容器的size即可
    32.     vTarget.resize(min(v1.size(), v2.size()));
    33.  
    34.     // 获取交集
    35.     vector<int>::iterator itEnd = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    36.  
    37.     for_each(vTarget.begin(), vTarget.end(), MyPrint());
    38.     cout << endl;
    39.     for_each(vTarget.begin(), itEnd, MyPrint());
    40. }
    41.  
    42. int main()
    43. {
    44.     Test01();
    45.  
    46.     return 0;
    47. }
    48.  
    49. 输出：
    50. -----------------------------------------------------------------------------------------
    51. 5 6 7 8 9 0 0 0 0 0 
    52. 5 6 7 8 9

    5.6.2. set_union

    功能描述：

    • 求两个集合的并集

    函数原型：

    • set_union(iterator begl, iterator end1, iterator beg2, iterator end2, iterator dest);

    // 求两个集合的并集

    // beg1 容器1开始迭代器

    // end1 容器1结束迭代器

    // beg2 容器2开始迭代器

    // end2 容器2结束迭代器

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

    总结：

    • 求并集的两个集合必须是有序序列
    • 目标容器开辟的空间为两个容器的size相加
    • set_intersection的返回值是交集迭代器中最后一个元素的位置
    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6. #include<numeric>
    7.  
    8. class MyPrint
    9. {
    10. public:
    11.     void operator()(int val)
    12.     {
    13.         cout << val << " ";
    14.     }
    15. };
    16.  
    17. void Test01()
    18. {
    19.     vector<int> v1;
    20.     vector<int> v2;
    21.  
    22.     for(int i = 0; i < 10; i++)
    23.     {
    24.         v1.push_back(i);                  // 0~9
    25.         v2.push_back(i + 5);              // 5~14
    26.     }
    27.  
    28.     vector<int> vTarget;
    29.  
    30.     // 目标容器需要提前开辟空间
    31.     // 最特殊情况：大容器与小容器完全不重合，开辟空间时取两个容器size之和
    32.     vTarget.resize(v1.size() + v2.size());
    33.  
    34.     // 获取并集
    35.     vector<int>::iterator itEnd = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    36.  
    37.     for_each(vTarget.begin(), vTarget.end(), MyPrint());
    38.     cout << endl;
    39.     for_each(vTarget.begin(), itEnd, MyPrint());
    40. }
    41.  
    42. int main()
    43. {
    44.     Test01();
    45.  
    46.     return 0;
    47. }
    48.  
    49. 输出：
    50. -----------------------------------------------------------------------------------------
    51. 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 0 0 0 0 0 
    52. 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

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

    总结：

    • 求并集的两个集合必须是有序序列
    • 目标容器开辟的空间为两个容器的size相加
    • set_intersection的返回值是交集迭代器中最后一个元素的位置
    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4. #include<vector>
    5. #include<algorithm>
    6. #include<numeric>
    7.  
    8. class MyPrint
    9. {
    10. public:
    11.     void operator()(int val)
    12.     {
    13.         cout << val << " ";
    14.     }
    15. };
    16.  
    17. void Test01()
    18. {
    19.     vector<int> v1;
    20.     vector<int> v2;
    21.  
    22.     for(int i = 0; i < 10; i++)
    23.     {
    24.         v1.push_back(i);                  // 0~9
    25.         v2.push_back(i + 5);              // 5~14
    26.     }
    27.  
    28.     vector<int> vTarget;
    29.  
    30.     // 目标容器需要提前开辟空间
    31.     // 最特殊情况：大容器与小容器完全不重合，开辟空间时取两个容器size之和
    32.     vTarget.resize(max(v1.size(), v2.size()));
    33.  
    34.     // 获取并集
    35.     vector<int>::iterator itEnd = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    36.  
    37.     cout << "v1和v2的差集为：" << endl;
    38.     for_each(vTarget.begin(), itEnd, MyPrint());
    39.     cout << endl;
    40.  
    41.     cout << "v2和v1的差集为：" << endl;
    42.     itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
    43.     for_each(vTarget.begin(), itEnd, MyPrint());
    44. }
    45.  
    46. int main()
    47. {
    48.     Test01();
    49.  
    50.     return 0;
    51. }
    52.  
    53. 输出：
    54. -----------------------------------------------------------------------------------------
    55. v1和v2的差集为：
    56. 0 1 2 3 4
    57. v2和v1的差集为：
    58. 10 11 12 13 14
  • 相关阅读:
    游戏服务器搭建过程中Maven多模块编译遇到的一些问题
    SpringBoot整合JWT
    ModbusTCP 转 Profinet 主站网关在博图配置案例
    【每日一题Day337】LC460LFU 缓存 | 双链表+哈希表
    【Linux】详解自主实现HTTP服务器
    K-近邻算法分类和回归
    【CANoe/CANalyzer脚本】通过CAPL发送NM帧报文测试网络管理
    FS4061A(5V USB输入、双节锂电池串联应用、5v升压充电8.4v管理IC
    python基于PHP+MySQL的校园帮忙领取快递平台
    关于接口测试问题，这些文章推荐你反复看看
  • 原文地址：https://blog.csdn.net/qq_53795212/article/details/139663800