C++ STL常用算法

目录

​​1. 常用遍历算法​​

​​1.1 for_each遍历容器​​

​​1.2 transorm 搬运容器到另一个容器中​​

​​2. 常用查找算法​​

​​2.1 find查找算法​​

​​2.2 find_if条件查询​​

​​2.3 adjacent_find 查找相邻重复元素.​​

​​2.4 binary_search 二分查找 ​​

​​2.5 count 统计元素个数​​

​​2.6 count_if 条件统计​​

​​3.排序算法​​

​​3.1 sort对容器元素排序​​

​​3.2 random_shuffle 随机调整顺序​​

​​3.3 merge容器元素合并​​

​​3.4 reverse 将容器元素反转​​

​​4. 拷贝和替换算法​​

​​4.1 copy容器拷贝​​

​​4.2 replace 容器元素替换​​

​​4.3 replace_if条件替换​​

​​4.4 swap容器元素互换​​

​​5. 常用算术生成算法​​

​​5.1 accumulate容器元素累加和​​

​​5.2 fill容器填充​​

​​6. 常用集合算法​​

​​6.1 set_intersection求容器交集​​

​​6.2 set_union 求两个集合的并集​​

​​6.3 set_difference求容器差集​​

---

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

1. 常用遍历算法

1.1 for_each遍历容器

函数原型：for_each(iterator begin, iterator end, _func);

• • 
    
• // 遍历算法 遍历容器元素
• // beg 开始迭代器
• // end 结束迭代器
• // _func 函数或者函数对象
  • 
    

#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
//普通函数
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;
}

1.2 transorm 搬运容器到另一个容器中

​​函数原型:transform(iterator beg1, iterator end1, iterator beg2, _func);​​

• • 
    
• //beg1 源容器开始迭代器
• //end1 源容器结束迭代器
• //beg2 目标容器开始迭代器
• //_func 函数或者函数对象
  • 
    

注意目标容器必须要提前开辟空间

#include<vector>
#include<algorithm>
#include <iostream>
using namespace std;
//常用遍历算法  搬运 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;
}

2. 常用查找算法

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

2.1 find查找算法

函数原型：

• ​​find(iterator beg, iterator end, value);​​
  // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
  // beg 开始迭代器
  // end 结束迭代器
  // value 查找的元素
  

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

2.2 find_if条件查询

函数原型：

• ​​find_if(iterator beg, iterator end, _Pred);​​
  // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
  // beg 开始迭代器
  // end 结束迭代器
  // _Pred 函数或者谓词（返回bool类型的仿函数）
  

#include <algorithm>
#include <vector>
#include <string>
#include<iostream>
using namespace std;
//内置数据类型
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 + 1);
    }

    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();
}

2.3 adjacent_find 查找相邻重复元素.

函数原型：

• ​​adjacent_find(iterator beg, iterator end);​​
  // 查找相邻重复元素,返回相邻元素的第一个位置的迭代器
  // beg 开始迭代器
  // end 结束迭代器
  

#include <algorithm>
#include <vector>

void test01()
{
  vector<int> v;
  v.push_back(1);
  v.push_back(2);
  v.push_back(5);
  v.push_back(2);
  v.push_back(4);
  v.push_back(4);
  v.push_back(3);

  //查找相邻重复元素
  vector<int>::iterator it = adjacent_find(v.begin(), v.end());
  if (it == v.end()) {
    cout << "找不到!" << endl;
  }
  else {
    cout << "找到相邻重复元素为:" << *it << endl;
  }
}

2.4 binary_search 二分查找

函数原型：

• ​​bool binary_search(iterator beg, iterator end, value);​​// 查找指定的元素，查到 返回true 否则false
  // 注意: 在无序序列中不可用
  // beg 开始迭代器
  // end 结束迭代器
  // value 查找的元素
  

#include <algorithm>
#include <vector>

void test01()
{
  vector<int>v;

  for (int i = 0; i < 10; i++)
  {
    v.push_back(i);
  }
  //二分查找
  bool ret = binary_search(v.begin(), v.end(),2);
  if (ret)
  {
    cout << "找到了" << endl;
  }
  else
  {
    cout << "未找到" << endl;
  }
}

int main() {

  test01();

  system("pause");

  return 0;
}

2.5 count 统计元素个数

函数原型：

• ​​count(iterator beg, iterator end, value);​​
  // 统计元素出现次数
  // beg 开始迭代器
  // end 结束迭代器
  // value 统计的元素
  

#include <algorithm>
#include <vector>

//内置数据类型
void test01()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(4);
    v.push_back(5);
    v.push_back(3);
    v.push_back(4);
    v.push_back(4);

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

    cout << "4的个数为： " << num << endl;
}

//自定义数据类型
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("曹操", 25);

    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 = " << num << endl;
}
int main() {

    //test01();

    test02();

    system("pause");

    return 0;
}

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

2.6 count_if 条件统计

函数原型：

• ​​count_if(iterator beg, iterator end, _Pred);​​// 按条件统计元素出现次数
  // beg 开始迭代器
  // end 结束迭代器
  // _Pred 谓词
  

#include <algorithm>
#include <vector>
#include<iostream>
using namespace std;
class Greater4
{
public:
  bool operator()(int val)
  {
    return val >= 4;
  }
};

//内置数据类型
void test01()
{
  vector<int> v;
  v.push_back(1);
  v.push_back(2);
  v.push_back(4);
  v.push_back(5);
  v.push_back(3);
  v.push_back(4);
  v.push_back(4);

  int num = count_if(v.begin(), v.end(), Greater4());

  cout << "大于4的个数为： " << 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 AgeLess35
{
public:
  bool operator()(const Person &p)
  {
    return p.m_Age < 35;
  }
};
void test02()
{
  vector<Person> v;

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

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

  int num = count_if(v.begin(), v.end(), AgeLess35());
  cout << "小于35岁的个数：" << num << endl;
}


int main() {

  //test01();

  test02();

  system("pause");

  return 0;
}

3.排序算法

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

3.1 sort对容器元素排序

函数原型：

• ​​sort(iterator beg, iterator end, _Pred);​​
  // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
  // beg 开始迭代器
  // end 结束迭代器
  // _Pred 谓词
  

#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
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;
}

3.2 random_shuffle 随机调整顺序

函数原型：

• • 
    
• ​​random_shuffle(iterator beg, iterator end);​​
  // 指定范围内的元素随机调整次序
  // beg 开始迭代器
  // end 结束迭代器
  
• random_shuffle洗牌算法比较实用，使用时记得加随机数种子
  
  • 
    

3.3 merge容器元素合并

函数原型：

• ​​merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);​​
  // 容器元素合并，并存储到另一容器中.
  // 注意: 两个容器必须是有序的

// beg1 容器1开始迭代器

// end1 容器1结束迭代器

// beg2 容器2开始迭代器

// end2 容器2结束迭代器

// dest 目标容器开始迭代器，目标容器必须要提前开辟空间

3.4 reverse 将容器元素反转

函数原型：

• ​​reverse(iterator beg, iterator end);​​// 反转指定范围的元素
  // beg 开始迭代器
  // end 结束迭代器
  

4. 拷贝和替换算法

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

4.1 copy容器拷贝

函数原型：

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

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

// beg 开始迭代器

// end 结束迭代器

// dest 目标起始迭代器

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

#include <algorithm>
#include <vector>
#include<iostream>
using namespace std;
class myPrint
{
public:
  void operator()(int val)
  {
    cout << val << " ";
  }
};

void test01()
{
  vector<int> v1;
  for (int i = 0; i < 10; i++) {
    v1.push_back(i + 1);
  }
  vector<int> v2;
  v2.resize(v1.size());
  copy(v1.begin(), v1.end(), v2.begin());

  for_each(v2.begin(), v2.end(), myPrint());
  cout << endl;
}

int main() {

  test01();

  system("pause");

  return 0;
}

4.2 replace 容器元素替换

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

函数原型：

• ​​replace(iterator beg, iterator end, oldvalue, newvalue);​​// 将区间内旧元素 替换成 新元素
  // beg 开始迭代器
  // end 结束迭代器
  // oldvalue 旧元素
  // newvalue 新元素
  

4.3 replace_if条件替换

函数原型：

• ​​replace_if(iterator beg, iterator end, _pred, newvalue);​​// 按条件替换元素，满足条件的替换成指定元素
  // beg 开始迭代器
  // end 结束迭代器
  // _pred 谓词
  // newvalue 替换的新元素
  

#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
class myPrint
{
public:
  void operator()(int val)
  {
    cout << val << " ";
  }
};

class ReplaceGreater30
{
public:
  bool operator()(int val)
  {
    return val >= 30;
  }

};

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

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

  //将容器中大于等于的30 替换成 3000
  cout << "替换后：" << endl;
  replace_if(v.begin(), v.end(), ReplaceGreater30(), 3000);
  for_each(v.begin(), v.end(), myPrint());
  cout << endl;
}

int main() {

  test01();

  system("pause");

  return 0;
}

4.4 swap容器元素互换

互换两个容器的元素

函数原型：

• ​​swap(container c1, container c2);​​
  // 互换两个容器的元素
  // c1容器1
  // c2容器2
  

5. 常用算术生成算法

5.1 accumulate容器元素累加和

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

函数原型：​​ccumulate(iterator beg, iterator end, value);​​

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

// beg 开始迭代器

// end 结束迭代器

// value 起始值

5.2 fill容器填充

功能描述：

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

函数原型：

• ​​fill(iterator beg, iterator end, value);​​// 向容器中填充元素
  // beg 开始迭代器
  // end 结束迭代器
  // value 填充的值
  

vector<int> v;

v.resize(10);

//填充 fill(v.begin(), v.end(), 100);

6. 常用集合算法

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

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; //取两个里面较小的值给目标容器开辟空间

vTarget.resize(min(v1.size(), v2.size()));
 //返回目标容器的最后一个元素的迭代器地址 
vector<int>::iterator itEnd = set_intersection(v1.begin(),
     v1.end(), v2.begin(), v2.end(), vTarget.begin());

6.2 set_union 求两个集合的并集

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

        // beg1 容器1开始迭代器

        // end1 容器1结束迭代器

        // beg2 容器2开始迭代器

        // end2 容器2结束迭代器

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

总结：

• • 
    
• 求并集的两个集合必须的有序序列
• 目标容器开辟空间需要两个容器相加
• set_union返回值既是并集中最后一个元素的位置
  • 
    

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

• 
  

求差集的两个集合必须的有序序列
目标容器开辟空间需要从两个容器取较大值

•