C艹算法库

<algorithm>用于操作容器（如数组、向量、列表等）的算法。这些算法包括排序、搜索、复制、比较等

排序算法

函数：std::sort

定义：对容器中的元素进行排序。

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

bool compare(int a, int b) {
    return a < b;
}

int main() {
    std::vector<int> v = {5, 3, 9, 1, 4};
    std::sort(v.begin(), v.end(), compare); // 使用自定义比较函数
    for (int i : v) {
        std::cout << i << " "; // 输出: 1 3 4 5 9
    }

    std::sort(v.begin(), v.end(), std::less<int>()); // 使用标准库比较函数对象
    for (int i : v) {
        std::cout << i << " "; // 输出: 1 3 4 5 9
    }

    return 0

其中 compare 是一个可选的比较函数，用于自定义排序方式。

搜索算法

函数：std::find

定义：在容器中查找与给定值匹配的第一个元素。

语法：

auto it = find(container.begin(), container.end(), value);

如果找到，it 将指向匹配的元素；如果没有找到，it 将等于 container.end()。

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
  std::vector<int> numbers = {1, 2, 3, 4, 5};
  auto it = std::find(numbers.begin(), numbers.end(), 3);

  if (it != numbers.end()) {
    std::cout << "Found: " << *it << std::endl;//Found: 3
  } else {
    std::cout << "Value not found." << std::endl;
  }

  return 0;
}

复制算法

函数：std::copy

定义：将一个范围内的元素复制到另一个容器或数组。

语法：

copy(source_begin, source_end, destination_begin);

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
  std::vector<int> source = {1, 2, 3, 4, 5};
  int destination[5];
  std::copy(source.begin(), source.end(), destination);

  for (int i = 0; i < 5; ++i) {
    std::cout << destination[i] << " ";//1 2 3 4 5
  }
  std::cout << std::endl;

  return 0;
}

比较算法

函数：std::equal

定义：比较两个容器或两个范围内的元素是否相等。

语法：

bool result = equal(first1, last1, first2, compare_function);

\#include <algorithm>
\#include <vector>
\#include <iostream>

bool custom_compare(int a, int b) {
    return (a % 10) == (b % 10); // 比较个位数是否相等
}

int main() {
  std::vector<int> v1 = {1, 2, 3, 4, 5};
  std::vector<int> v2 = {1, 2, 3, 4, 5};

  bool are_equal = std::equal(v1.begin(), v1.end(), v2.begin(), custom_compare);
  std::cout << (are_equal ? "Vectors are equal." : "Vectors are not equal.") << std::endl;

  return 0;
}

常用的函数对象

<functional> 头文件中定义了一些常用的函数对象，包括：

std::function 是一个通用的多态函数封装器，它可以保存、复制和调用任何可以调用的目标（如函数指针、Lambda 表达式、绑定表达式、或者其他可调用对象）。

#include <functional>
#include <iostream>

void say_hello() {
    std::cout << "Hello, World!\n";
}

int main() {
    std::function<void()> func = say_hello;
    func(); // 调用封装的函数
    return 0;
}

std::bind 用于绑定函数的部分参数，返回一个新的函数对象，该对象可以通过传递剩余的参数来调用。

#include <functional>
#include <iostream>

int add(int a, int b) {
    return a + b;
}

int main() {
    auto add_five = std::bind(add, 5, std::placeholders::_1);//相当于替换函数名
    std::cout << add_five(3) << "\n"; // 输出8
    return 0;
}

std::less<T>: 封装了小于运算符 <。用于比较两个对象，判断前一个对象是否小于后一个对象。

std::greater<T>:封装了大于运算符 >。用于比较两个对象，判断前一个对象是否大于后一个对象。

std::equal_to<T>:封装了相等运算符 ==。用于比较两个对象是否相等。

std::not_equal_to<T>: 封装了不等运算符 !=。用于比较两个对象是否不相等。

std::greater_equal<T>:封装了大于等于运算符 >=。用于比较前一个对象是否大于或等于后一个对象。

std::less_equal<T>:封装了小于等于运算符 <=。用于比较前一个对象是否小于或等于后一个对象。

std::plus<T>: 实现加法运算符 +。

std::minus<T>: 实现减法运算符 -。

std::multiplies<T>: 实现乘法运算符 *。

std::divides<T>: 实现除法运算符 /。

std::modulus<T>: 实现取模运算符 %。

std::unary_negate: 用于对一元谓词进行逻辑取反。