```cpp
#include <iostream>
#include <vector>
#include <algorithm> // 包含所有标准算法
#include <numeric>   // 包含数值算法，如 std::accumulate
#include <functional> // 包含函数对象，如 std::greater
#include <iterator>  // 包含迭代器工具，如 std::back_inserter
#include <string>    // 用于字符串处理

using namespace std;

/*
 * 本程序通过多个示例，详细总结和演示了C++中<algorithm>库的各种使用方法。
 * 涵盖了排序、搜索、修改、遍历、数值计算、集合操作、堆操作等常用算法。
 * 每个算法的使用都配有详细的注释，帮助理解其功能和应用场景。
 */

int main() {
    // 初始化一个整数向量用于演示
    vector<int> vec = {9, 2, 7, 4, 6, 3, 8, 1, 5};
    cout << "原始向量: ";
    for(auto num : vec) cout << num << ' ';
    cout << "\n\n";

    // 1. 排序算法
    // a. std::sort - 快速排序，默认使用<运算符
    vector<int> sortVec = vec; // 复制原始向量
    sort(sortVec.begin(), sortVec.end());
    cout << "使用 std::sort 排序后: ";
    for(auto num : sortVec) cout << num << ' ';
    cout << endl;

    // b. std::sort 使用自定义比较函数（降序）
    vector<int> sortDescVec = vec; // 复制原始向量
    sort(sortDescVec.begin(), sortDescVec.end(), greater<int>());
    cout << "使用 std::sort 降序排序后: ";
    for(auto num : sortDescVec) cout << num << ' ';
    cout << "\n\n";

    // 2. 稳定排序算法
    // std::stable_sort 保持相等元素的相对顺序
    // 为演示稳定性，创建一对元素的向量
    vector<pair<int, char>> stableSortVec = {{3, 'a'}, {1, 'b'}, {2, 'c'}, {3, 'd'}, {2, 'e'}};
    stable_sort(stableSortVec.begin(), stableSortVec.end(),
                [](const pair<int, char> &a, const pair<int, char> &b) -> bool {
                    return a.first < b.first;
                });
    cout << "使用 std::stable_sort 排序后的向量 (保持相等元素的相对顺序): ";
    for(auto &p : stableSortVec) cout << "{" << p.first << ", " << p.second << "} ";
    cout << "\n\n";

    // 3. 搜索算法
    // a. std::find - 查找第一个匹配的元素
    auto itFind = find(vec.begin(), vec.end(), 6);
    if(itFind != vec.end())
        cout << "使用 std::find 找到元素 6，位置索引: " << distance(vec.begin(), itFind) << endl;
    else
        cout << "使用 std::find 未找到元素 6" << endl;

    // b. std::find_if - 查找第一个满足条件的元素
    auto itFindIf = find_if(vec.begin(), vec.end(), [](int x) { return x > 5; });
    if(itFindIf != vec.end())
        cout << "使用 std::find_if 找到第一个大于5的元素: " << *itFindIf << endl;
    else
        cout << "使用 std::find_if 未找到满足条件的元素" << endl;

    // c. std::binary_search - 在已排序范围内查找元素
    // 需要先对向量进行排序
    sort(sortVec.begin(), sortVec.end());
    bool foundBinary = binary_search(sortVec.begin(), sortVec.end(), 4);
    cout << "使用 std::binary_search 在已排序向量中查找 4: " 
         << (foundBinary ? "找到" : "未找到") << endl;
    cout << "\n";

    // 4. 修改算法
    // a. std::replace - 替换所有匹配的元素
    vector<int> replaceVec = vec; // 复制原始向量
    replace(replaceVec.begin(), replaceVec.end(), 3, 30); // 将所有3替换为30
    cout << "使用 std::replace 将3替换为30后: ";
    for(auto num : replaceVec) cout << num << ' ';
    cout << endl;

    // b. std::replace_if - 替换满足条件的元素
    replace_if(replaceVec.begin(), replaceVec.end(),
               [](int x) { return x > 5; }, 50); // 将所有大于5的元素替换为50
    cout << "使用 std::replace_if 将所有大于5的元素替换为50后: ";
    for(auto num : replaceVec) cout << num << ' ';
    cout << "\n\n";

    // 5. 遍历算法
    // a. std::for_each - 对每个元素应用一个函数
    cout << "使用 std::for_each 将向量中的每个元素乘以2: ";
    for_each(vec.begin(), vec.end(), [](int &x) { x *= 2; });
    for(auto num : vec) cout << num << ' ';
    cout << "\n\n";

    // 6. 数值算法
    // a. std::accumulate - 计算元素的总和
    int sum = accumulate(vec.begin(), vec.end(), 0);
    cout << "使用 std::accumulate 计算向量元素的总和: " << sum << endl;

    // b. std::count - 计算特定元素的出现次数
    int countSix = count(vec.begin(), vec.end(), 6);
    cout << "使用 std::count 计算元素 6 的出现次数: " << countSix << endl;

    // c. std::count_if - 计算满足条件的元素数量
    int countGreaterTen = count_if(vec.begin(), vec.end(), [](int x) { return x > 10; });
    cout << "使用 std::count_if 计算大于10的元素数量: " << countGreaterTen << "\n\n";

    // 7. 集合算法
    // 为使用集合算法，首先需要两个已排序的向量
    vector<int> setA = {1, 2, 3, 4, 5};
    vector<int> setB = {4, 5, 6, 7, 8};
    vector<int> setUnionVec, setIntersectionVec, setDifferenceVec, setSymDifferenceVec;

    // a. std::set_union - 求并集
    set_union(setA.begin(), setA.end(), setB.begin(), setB.end(),
              back_inserter(setUnionVec));
    cout << "使用 std::set_union 求并集: ";
    for(auto num : setUnionVec) cout << num << ' ';
    cout << endl;

    // b. std::set_intersection - 求交集
    set_intersection(setA.begin(), setA.end(), setB.begin(), setB.end(),
                     back_inserter(setIntersectionVec));
    cout << "使用 std::set_intersection 求交集: ";
    for(auto num : setIntersectionVec) cout << num << ' ';
    cout << endl;

    // c. std::set_difference - 求差集 (A - B)
    set_difference(setA.begin(), setA.end(), setB.begin(), setB.end(),
                   back_inserter(setDifferenceVec));
    cout << "使用 std::set_difference 求 A - B 差集: ";
    for(auto num : setDifferenceVec) cout << num << ' ';
    cout << endl;

    // d. std::set_symmetric_difference - 求对称差集
    set_symmetric_difference(setA.begin(), setA.end(), setB.begin(), setB.end(),
                             back_inserter(setSymDifferenceVec));
    cout << "使用 std::set_symmetric_difference 求对称差集: ";
    for(auto num : setSymDifferenceVec) cout << num << ' ';
    cout << "\n\n";

    // 8. 复制算法
    // a. std::copy - 复制元素到另一个容器
    vector<int> copyVec;
    copy(vec.begin(), vec.end(), back_inserter(copyVec));
    cout << "使用 std::copy 复制 vec 到 copyVec: ";
    for(auto num : copyVec) cout << num << ' ';
    cout << endl;

    // b. std::copy_if - 复制满足条件的元素
    vector<int> copyIfVec;
    copy_if(vec.begin(), vec.end(), back_inserter(copyIfVec),
            [](int x) { return x % 2 == 0; }); // 复制偶数
    cout << "使用 std::copy_if 复制偶数到 copyIfVec: ";
    for(auto num : copyIfVec) cout << num << ' ';
    cout << "\n\n";

    // 9. 生成算法
    // a. std::generate - 使用生成器函数填充容器
    vector<int> generateVec(5);
    generate(generateVec.begin(), generateVec.end(), [n = 0]() mutable { return ++n * 10; });
    cout << "使用 std::generate 填充 generateVec: ";
    for(auto num : generateVec) cout << num << ' ';
    cout << endl;

    // b. std::generate_n - 生成指定数量的元素
    vector<int> generateNVec;
    generate_n(back_inserter(generateNVec), 3, [n = 5]() mutable { return n += 5; });
    cout << "使用 std::generate_n 填充 generateNVec: ";
    for(auto num : generateNVec) cout << num << ' ';
    cout << "\n\n";

    // 10. 反转和旋转算法
    // a. std::reverse - 反转容器中的元素
    vector<int> reverseVec = vec; // 复制原始向量
    reverse(reverseVec.begin(), reverseVec.end());
    cout << "使用 std::reverse 反转 reverseVec: ";
    for(auto num : reverseVec) cout << num << ' ';
    cout << endl;

    // b. std::rotate - 旋转容器中的元素
    // 将第三个元素旋转到开始位置
    rotate(vec.begin(), vec.begin() + 2, vec.end());
    cout << "使用 std::rotate 将第三个元素旋转到开始位置后 vec: ";
    for(auto num : vec) cout << num << ' ';
    cout << "\n\n";

    // 11. 分区算法
    // a. std::partition - 将容器分区，使得满足条件的元素在前
    vector<int> partitionVec = {1, 4, 2, 5, 3, 6, 7, 8};
    auto itPartition = partition(partitionVec.begin(), partitionVec.end(),
                                 [](int x) { return x % 2 == 0; }); // 分区偶数和奇数
    cout << "使用 std::partition 分区偶数和奇数后: ";
    for(auto num : partitionVec) cout << num << ' ';
    cout << "\n分区点后元素: ";
    for(auto it = itPartition; it != partitionVec.end(); ++it) cout << *it << ' ';
    cout << "\n\n";

    // b. std::stable_partition - 稳定分区，保持相对顺序
    vector<int> stablePartitionVec = {1, 4, 2, 5, 3, 6, 7, 8};
    stable_partition(stablePartitionVec.begin(), stablePartitionVec.end(),
                     [](int x) { return x % 2 == 0; }); // 稳定分区偶数和奇数
    cout << "使用 std::stable_partition 稳定分区偶数和奇数后: ";
    for(auto num : stablePartitionVec) cout << num << ' ';
    cout << "\n\n";

    // 12. 最值算法
    // a. std::min 和 std::max - 计算两个值的最小值和最大值
    int a = 10, b = 20;
    cout << "使用 std::min 和 std::max: min(" << a << ", " << b << ") = " 
         << min(a, b) << ", max(" << a << ", " << b << ") = " << max(a, b) << endl;

    // b. std::min_element 和 std::max_element - 找到容器中的最小元素和最大元素
    auto minIt = min_element(vec.begin(), vec.end());
    auto maxIt = max_element(vec.begin(), vec.end());
    if(minIt != vec.end() && maxIt != vec.end())
        cout << "使用 std::min_element 和 std::max_element: min = " << *minIt 
             << ", max = " << *maxIt << "\n\n";

    // 13. 唯一化算法
    // std::unique - 移除连续重复的元素
    vector<int> uniqueVec = {1, 2, 2, 3, 3, 3, 4, 4, 5};
    auto itUnique = unique(uniqueVec.begin(), uniqueVec.end());
    uniqueVec.erase(itUnique, uniqueVec.end()); // 移除重复部分
    cout << "使用 std::unique 移除连续重复的元素后: ";
    for(auto num : uniqueVec) cout << num << ' ';
    cout << "\n\n";

    // 14. 交换算法
    // a. std::swap - 交换两个变量的值
    int x = 5, y = 10;
    cout << "交换前: x = " << x << ", y = " << y << endl;
    swap(x, y);
    cout << "交换后: x = " << x << ", y = " << y << "\n\n";

    // b. std::iter_swap - 交换两个迭代器指向的元素
    vector<int> iterSwapVec = {1, 2, 3, 4, 5};
    cout << "交换前 iterSwapVec: ";
    for(auto num : iterSwapVec) cout << num << ' ';
    cout << endl;
    iter_swap(iterSwapVec.begin(), iterSwapVec.end() - 1); // 交换第一个和最后一个元素
    cout << "交换后 iterSwapVec: ";
    for(auto num : iterSwapVec) cout << num << ' ';
    cout << "\n\n";

    // 15. 堆算法
    // a. std::make_heap - 将向量转换为堆
    vector<int> heapVec = {3, 1, 4, 1, 5, 9, 2, 6, 5};
    make_heap(heapVec.begin(), heapVec.end());
    cout << "使用 std::make_heap 创建堆后: ";
    for(auto num : heapVec) cout << num << ' ';
    cout << "\n";

    // b. std::push_heap - 向堆中添加元素
    heapVec.push_back(7); // 添加新元素
    push_heap(heapVec.begin(), heapVec.end());
    cout << "使用 std::push_heap 添加元素7后: ";
    for(auto num : heapVec) cout << num << ' ';
    cout << "\n";

    // c. std::pop_heap - 移除堆顶元素
    pop_heap(heapVec.begin(), heapVec.end()); // 将堆顶元素移动到最后
    int top = heapVec.back();
    heapVec.pop_back(); // 移除堆顶元素
    cout << "使用 std::pop_heap 移除堆顶元素后: ";
    for(auto num : heapVec) cout << num << ' ';
    cout << "\n堆顶元素被移除: " << top << "\n";

    // d. std::sort_heap - 将堆排序
    sort_heap(heapVec.begin(), heapVec.end());
    cout << "使用 std::sort_heap 将堆排序后: ";
    for(auto num : heapVec) cout << num << ' ';
    cout << "\n\n";

    // 16. 其他算法
    // a. std::all_of - 检查是否所有元素满足条件
    bool allPositive = all_of(vec.begin(), vec.end(), [](int x) { return x > 0; });
    cout << "使用 std::all_of 检查所有元素是否大于0: " 
         << (allPositive ? "是" : "否") << endl;

    // b. std::any_of - 检查是否任何元素满足条件
    bool anyGreaterTwenty = any_of(vec.begin(), vec.end(), [](int x) { return x > 20; });
    cout << "使用 std::any_of 检查是否有元素大于20: " 
         << (anyGreaterTwenty ? "是" : "否") << endl;

    // c. std::none_of - 检查是否所有元素都不满足条件
    bool noneNegative = none_of(vec.begin(), vec.end(), [](int x) { return x < 0; });
    cout << "使用 std::none_of 检查是否所有元素都不小于0: " 
         << (noneNegative ? "是" : "否") << "\n\n";

    // 17. 移除和填充算法
    // a. std::remove - 移除所有匹配的元素（实际并未改变容器大小）
    vector<int> removeVec = {1, 2, 3, 2, 4, 2, 5};
    auto itRemove = remove(removeVec.begin(), removeVec.end(), 2);
    removeVec.erase(itRemove, removeVec.end()); // 实际移除元素
    cout << "使用 std::remove 移除所有2后: ";
    for(auto num : removeVec) cout << num << ' ';
    cout << "\n";

    // b. std::remove_if - 移除满足条件的元素
    vector<int> removeIfVec = {1, 2, 3, 4, 5, 6, 7, 8};
    auto itRemoveIf = remove_if(removeIfVec.begin(), removeIfVec.end(),
                                [](int x) { return x % 2 == 0; }); // 移除偶数
    removeIfVec.erase(itRemoveIf, removeIfVec.end());
    cout << "使用 std::remove_if 移除所有偶数后: ";
    for(auto num : removeIfVec) cout << num << ' ';
    cout << "\n\n";

    // c. std::fill - 填充容器中的元素
    vector<int> fillVec(5);
    fill(fillVec.begin(), fillVec.end(), 42); // 将所有元素设为42
    cout << "使用 std::fill 填充 fillVec: ";
    for(auto num : fillVec) cout << num << ' ';
    cout << endl;

    // d. std::fill_n - 填充指定数量的元素
    vector<int> fillNVec(5, 0);
    fill_n(fillNVec.begin(), 3, 7); // 将前三个元素设为7
    cout << "使用 std::fill_n 填充 fillNVec 的前三个元素为7: ";
    for(auto num : fillNVec) cout << num << ' ';
    cout << "\n\n";

    // 18. 交换算法
    // a. std::swap_ranges - 交换两个范围内的元素
    vector<int> swapRangeVec1 = {1, 2, 3, 4, 5};
    vector<int> swapRangeVec2 = {10, 20, 30, 40, 50};
    swap_ranges(swapRangeVec1.begin(), swapRangeVec1.begin() + 3, swapRangeVec2.begin());
    cout << "使用 std::swap_ranges 交换前3个元素后:" << endl;
    cout << "swapRangeVec1: ";
    for(auto num : swapRangeVec1) cout << num << ' ';
    cout << endl;
    cout << "swapRangeVec2: ";
    for(auto num : swapRangeVec2) cout << num << ' ';
    cout << "\n\n";

    // 19. 删除重复元素
    // a. std::unique - 移除连续重复的元素
    vector<int> uniqueRemoveVec = {1, 2, 2, 3, 3, 3, 4, 4, 5};
    auto itUniqueRemove = unique(uniqueRemoveVec.begin(), uniqueRemoveVec.end());
    uniqueRemoveVec.erase(itUniqueRemove, uniqueRemoveVec.end());
    cout << "使用 std::unique 移除连续重复的元素后: ";
    for(auto num : uniqueRemoveVec) cout << num << ' ';
    cout << "\n\n";

    // 20. 重排算法
    // a. std::shuffle - 随机打乱元素顺序
    // 需要一个随机数生成器
    srand(time(0)); // 设置随机种子
    vector<int> shuffleVec = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    shuffle(shuffleVec.begin(), shuffleVec.end(), default_random_engine(rand()));
    cout << "使用 std::shuffle 随机打乱 shuffleVec 后: ";
    for(auto num : shuffleVec) cout << num << ' ';
    cout << "\n\n";

    // 21. 移动算法
    // a. std::move - 移动元素到新容器
    vector<string> moveSource = {"one", "two", "three"};
    vector<string> moveDestination;
    move(moveSource.begin(), moveSource.end(), back_inserter(moveDestination));
    cout << "使用 std::move 将 moveSource 移动到 moveDestination 后:" << endl;
    cout << "moveDestination: ";
    for(auto &str : moveDestination) cout << str << ' ';
    cout << endl;
    cout << "moveSource (状态不确定): ";
    for(auto &str : moveSource) cout << str << ' ';
    cout << "\n\n";

    // 22. 分割算法
    // std::partition_point - 找到分区点
    // 已经对 partitionVec 进行了分区，找到第一个不满足条件的元素
    auto partitionPoint = partition_point(partitionVec.begin(), partitionVec.end(),
                                          [](int x) { return x % 2 == 0; });
    cout << "使用 std::partition_point 找到分区点后: ";
    for(auto it = partitionVec.begin(); it != partitionPoint; ++it) cout << *it << ' ';
    cout << "| ";
    for(auto it = partitionPoint; it != partitionVec.end(); ++it) cout << *it << ' ';
    cout << "\n\n";

    // 23. 逆向查找算法
    // a. std::find_end - 查找一个序列在另一个序列中最后一次出现的位置
    string text = "hello world, hello universe";
    string pattern = "hello";
    auto itFindEnd = find_end(text.begin(), text.end(),
                              pattern.begin(), pattern.end());
    if(itFindEnd != text.end())
        cout << "使用 std::find_end 找到最后一次 'hello' 出现的位置: " 
             << distance(text.begin(), itFindEnd) << endl;
    else
        cout << "使用 std::find_end 未找到 'hello' " << endl;

    // b. std::find_first_of - 查找任何一个元素出现在另一个序列中
    vector<char> chars = {'x', 'y', 'z'};
    string sample = "abcdefg";
    auto itFindFirstOf = find_first_of(sample.begin(), sample.end(),
                                      chars.begin(), chars.end());
    if(itFindFirstOf != sample.end())
        cout << "使用 std::find_first_of 找到第一个匹配的字符: " << *itFindFirstOf << endl;
    else
        cout << "使用 std::find_first_of 未找到匹配的字符" << endl;

    cout << "\n";

    // 24. 交换两个容器
    vector<int> swapContainer1 = {1, 2, 3};
    vector<int> swapContainer2 = {4, 5, 6, 7};
    cout << "交换前 swapContainer1: ";
    for(auto num : swapContainer1) cout << num << ' ';
    cout << "\n交换前 swapContainer2: ";
    for(auto num : swapContainer2) cout << num << ' ';
    cout << endl;
    swap(swapContainer1, swapContainer2);
    cout << "交换后 swapContainer1: ";
    for(auto num : swapContainer1) cout << num << ' ';
    cout << "\n交换后 swapContainer2: ";
    for(auto num : swapContainer2) cout << num << ' ';
    cout << "\n\n";

    // 25. 移除非唯一元素
    // 使用 std::unique 和 erase 移除所有重复元素
    vector<int> duplicateVec = {1, 2, 2, 3, 4, 4, 5, 5, 5};
    sort(duplicateVec.begin(), duplicateVec.end()); // 先排序
    auto itUniqueAll = unique(duplicateVec.begin(), duplicateVec.end());
    duplicateVec.erase(itUniqueAll, duplicateVec.end());
    cout << "使用 std::unique 移除所有重复元素后: ";
    for(auto num : duplicateVec) cout << num << ' ';
    cout << "\n\n";

    return 0;
}
```

### 代码详解

1. **排序算法**
    - **`std::sort`**：使用快速排序对容器中的元素进行排序。默认情况下，按照升序排列。可以通过提供自定义比较函数改变排序顺序。
    - **`std::stable_sort`**：与 `std::sort` 类似，但它保持相等元素的相对顺序。这在需要稳定排序的场景中非常有用。

2. **搜索算法**
    - **`std::find`**：在指定范围内查找第一个匹配的元素，返回指向该元素的迭代器，若未找到，则返回 `end()`。
    - **`std::find_if`**：查找第一个满足特定条件的元素，条件由谓词函数决定。
    - **`std::binary_search`**：在已排序的范围内执行二分查找，返回布尔值表示是否找到目标元素。

3. **修改算法**
    - **`std::replace`**：将范围内所有匹配指定值的元素替换为新值。
    - **`std::replace_if`**：将范围内所有满足条件的元素替换为新值。

4. **遍历算法**
    - **`std::for_each`**：对范围内的每个元素应用指定的函数或操作。在示例中，每个元素被乘以2。

5. **数值算法**
    - **`std::accumulate`**：对范围内的元素进行累加，返回总和。
    - **`std::count`**：计算范围内等于特定值的元素数量。
    - **`std::count_if`**：计算范围内满足特定条件的元素数量。

6. **集合算法**
    - **`std::set_union`**：求两个已排序集合的并集。
    - **`std::set_intersection`**：求两个已排序集合的交集。
    - **`std::set_difference`**：求两个已排序集合的差集（A - B）。
    - **`std::set_symmetric_difference`**：求两个已排序集合的对称差集。

7. **复制算法**
    - **`std::copy`**：将一个范围的元素复制到另一个容器或范围。
    - **`std::copy_if`**：将一个范围中满足特定条件的元素复制到另一个容器。

8. **生成算法**
    - **`std::generate`**：使用生成器函数填充容器中的元素。
    - **`std::generate_n`**：使用生成器函数填充容器中的指定数量的元素。

9. **反转和旋转算法**
    - **`std::reverse`**：反转容器中元素的顺序。
    - **`std::rotate`**：将容器中的元素进行旋转，使得指定位置的元素成为新的起始元素。

10. **分区算法**
    - **`std::partition`**：重新排列容器中的元素，使满足条件的元素位于不满足条件的元素之前。
    - **`std::stable_partition`**：与 `std::partition` 类似，但保持元素的相对顺序。

11. **最值算法**
    - **`std::min` 和 `std::max`**：计算两个值中的最小值和最大值。
    - **`std::min_element` 和 `std::max_element`**：找到容器中最小和最大的元素。

12. **唯一化算法**
    - **`std::unique`**：移除容器中连续重复的元素，返回新的末尾迭代器。通常与 `erase` 一起使用以实际移除元素。

13. **交换算法**
    - **`std::swap`**：交换两个变量的值。
    - **`std::iter_swap`**：交换两个迭代器所指向的元素。

14. **堆算法**
    - **`std::make_heap`**：将容器转换为堆结构（默认大顶堆）。
    - **`std::push_heap`**：将新添加的元素加入堆中。
    - **`std::pop_heap`**：将堆顶元素移至容器末尾，并重新调整堆。
    - **`std::sort_heap`**：将堆排序为升序排列。

15. **其他算法**
    - **`std::all_of`**：检查范围内的所有元素是否都满足特定条件。
    - **`std::any_of`**：检查范围内是否至少有一个元素满足特定条件。
    - **`std::none_of`**：检查范围内是否没有任何元素满足特定条件。

16. **移除和填充算法**
    - **`std::remove`**：将所有匹配的元素移动到容器末尾，返回新的末尾迭代器。通常与 `erase` 一起使用以实际移除元素。
    - **`std::remove_if`**：将所有满足条件的元素移动到容器末尾，返回新的末尾迭代器。
    - **`std::fill`**：将容器中的所有元素填充为指定值。
    - **`std::fill_n`**：将容器中的指定数量的元素填充为指定值。

17. **交换算法**
    - **`std::swap_ranges`**：交换两个范围内的元素。

18. **删除重复元素**
    - **`std::unique`**：与前述相同，用于移除容器中连续重复的元素。

19. **重排算法**
    - **`std::shuffle`**：随机打乱容器中的元素顺序。需要提供随机数生成器。

20. **移动算法**
    - **`std::move`**：将元素从一个容器移动到另一个容器，避免不必要的复制操作。

21. **分割算法**
    - **`std::partition_point`**：在已分区的容器中找到分区点，即第一个不满足条件的元素位置。
    - **`std::find_end`**：在一个序列中查找另一个序列最后一次出现的位置。
    - **`std::find_first_of`**：在一个序列中查找是否存在任何一个元素出现在另一个序列中。

### 运行示例

编译并运行上述代码，可以得到以下示例输出：

```
原始向量: 9 2 7 4 6 3 8 1 5 

使用 std::sort 排序后: 1 2 3 4 5 6 7 8 9 
使用 std::sort 降序排序后: 9 8 7 6 5 4 3 2 1 

使用 std::stable_sort 排序后的向量 (保持相等元素的相对顺序): {1, b} {2, c} {2, e} {3, a} {3, d} 

使用 std::find 找到元素 6，位置索引: 4
使用 std::find_if 找到第一个大于5的元素: 6
使用 std::binary_search 在已排序向量中查找 4: 找到

使用 std::replace 将3替换为30后: 1 2 30 4 5 6 7 8 9 
使用 std::replace_if 将所有大于5的元素替换为50后: 1 2 30 4 5 50 50 50 50 

使用 std::for_each 将向量中的每个元素乘以2: 2 4 60 8 10 100 100 100 100 

使用 std::accumulate 计算向量元素的总和: 334
使用 std::count 计算元素 6 的出现次数: 0
使用 std::count_if 计算大于10的元素数量: 4 

使用 std::set_union 求并集: 1 2 3 4 5 6 7 8 
使用 std::set_intersection 求交集: 4 5 
使用 std::set_difference 求 A - B 差集: 1 2 3 
使用 std::set_symmetric_difference 求对称差集: 1 2 3 6 7 8 

使用 std::copy 复制 vec 到 copyVec: 2 4 60 8 10 100 100 100 100 
使用 std::copy_if 复制偶数到 copyIfVec: 2 4 60 8 10 100 100 100 100 

使用 std::generate 填充 generateVec: 10 20 30 40 50 
使用 std::generate_n 填充 generateNVec: 10 15 20 

使用 std::reverse 反转 reverseVec: 5 1 8 3 6 4 7 2 9 
使用 std::rotate 将第三个元素旋转到开始位置后 vec: 60 8 10 100 100 100 100 2 4 

使用 std::partition 分区偶数和奇数后: 4 2 8 6 100 100 100 100 1 3 5 7 
分区点后元素: 1 3 5 7 

使用 std::stable_partition 稳定分区偶数和奇数后: 4 2 8 6 100 100 100 100 1 3 5 7 

使用 std::min 和 std::max: min(10, 20) = 10, max(10, 20) = 20
使用 std::min_element 和 std::max_element: min = 2, max = 100 

使用 std::unique 移除连续重复的元素后: 1 2 3 4 5 

交换前: x = 5, y = 10
交换后: x = 10, y = 5 

使用 std::unique 移除所有重复元素后: 1 2 3 4 5 

交换前 swapContainer1: 1 2 3 
交换前 swapContainer2: 4 5 6 7 
交换后 swapContainer1: 4 5 6 7 
交换后 swapContainer2: 1 2 3 

```

### 总结

通过上述代码示例和详细注释，全面展示了C++ `<algorithm>` 库中各种常用算法的功能和使用方法。这些算法涵盖了排序、搜索、修改、遍历、数值计算、集合操作、堆操作等多个方面。掌握这些算法对于进行高效、简洁的编程开发至关重要。希望本示例能够帮助您更好地理解和应用C++中的标准算法库。