C++ STL算法库实战指南：从基础到高级应用

1. C++算法库深度解析：从基础到实战

作为C++开发者，算法库是我们日常开发中最常用的工具之一。STL（Standard Template Library）提供了丰富的算法，涵盖了从简单查找、排序到复杂数值计算的各种场景。本文将深入剖析这些算法的使用技巧和底层原理，帮助你在实际项目中更高效地运用它们。

1.1 非修改序列算法：安全的数据探查

非修改序列算法不会改变容器中的元素，主要用于数据查询和统计。这类算法包括查找、计数和条件判断等操作。

1.1.1 查找算法实战

find和find_if是最基础的查找算法，但它们的效率差异很大：

cpp复制vector<int> data = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};

// 线性查找 - O(n)
auto it = find(data.begin(), data.end(), 13);
if (it != data.end()) {
    cout << "Found: " << *it << " at position " << distance(data.begin(), it) << endl;
}

// 使用find_if查找第一个大于10的元素
auto it2 = find_if(data.begin(), data.end(), [](int x) {
    return x > 10;
});

提示：对于已排序的容器，应优先使用binary_search或lower_bound等二分查找算法，它们的时间复杂度是O(log n)。

1.1.2 计数与条件检查

count和count_if不仅用于简单计数，还可以结合谓词实现复杂统计：

cpp复制vector<Employee> employees = {
    {"Alice", 25, 50000},
    {"Bob", 30, 60000},
    {"Charlie", 35, 75000}
};

// 统计薪资超过55000的员工数量
int high_earners = count_if(employees.begin(), employees.end(), 
    [](const Employee& e) { return e.salary > 55000; });

// 检查是否所有员工年龄都大于20岁
bool all_adults = all_of(employees.begin(), employees.end(),
    [](const Employee& e) { return e.age > 20; });

1.2 修改序列算法：高效数据转换

这类算法会修改容器内容，包括复制、替换、删除和变换等操作。

1.2.1 安全复制技巧

copy和copy_if使用时需要注意目标容器的大小：

cpp复制vector<int> source = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 错误示范：目标容器空间不足会导致未定义行为
// vector<int> dest(5);
// copy(source.begin(), source.end(), dest.begin());

// 正确做法1：预先分配足够空间
vector<int> dest1(source.size());
copy(source.begin(), source.end(), dest1.begin());

// 正确做法2：使用back_inserter
vector<int> dest2;
copy_if(source.begin(), source.end(), back_inserter(dest2),
    [](int x) { return x % 2 == 0; });  // 只复制偶数

1.2.2 强大的transform

transform可以实现元素的一对一或一对多转换：

cpp复制// 温度转换：华氏度转摄氏度
vector<double> fahrenheit = {32.0, 68.0, 100.0, 212.0};
vector<double> celsius(fahrenheit.size());

transform(fahrenheit.begin(), fahrenheit.end(), celsius.begin(),
    [](double f) { return (f - 32) * 5/9; });

// 两个序列的合并计算
vector<double> prices = {10.5, 20.0, 15.75};
vector<int> quantities = {2, 3, 1};
vector<double> totals(3);

transform(prices.begin(), prices.end(), quantities.begin(), totals.begin(),
    [](double p, int q) { return p * q; });

1.3 排序与相关算法

排序是算法中最基础也最重要的操作之一，C++提供了多种排序算法适应不同场景。

1.3.1 排序算法选择

cpp复制vector<Student> students = {
    {"Alice", 85}, {"Bob", 72}, {"Charlie", 90}, {"David", 72}
};

// 普通排序（不稳定）
sort(students.begin(), students.end(), 
    [](const Student& a, const Student& b) { return a.score > b.score; });

// 稳定排序（保留相同分数的原始顺序）
stable_sort(students.begin(), students.end(),
    [](const Student& a, const Student& b) { return a.score > b.score; });

// 部分排序（只排序前N个元素）
partial_sort(students.begin(), students.begin() + 2, students.end(),
    [](const Student& a, const Student& b) { return a.score > b.score; });

1.3.2 二分查找优化

对于已排序的容器，二分查找可以大幅提高查询效率：

cpp复制vector<int> sorted_data = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};

// 检查元素是否存在
bool exists = binary_search(sorted_data.begin(), sorted_data.end(), 55);

// 查找插入位置
auto lower = lower_bound(sorted_data.begin(), sorted_data.end(), 55); // 第一个>=55的元素
auto upper = upper_bound(sorted_data.begin(), sorted_data.end(), 55); // 第一个>55的元素

// 计算范围内特定值的数量
int count = upper - lower;

1.4 数值算法：数学计算的利器

<numeric>头文件提供了一系列数值计算算法。

1.4.1 累加与内积

cpp复制vector<int> numbers = {1, 2, 3, 4, 5};

// 普通累加
int sum = accumulate(numbers.begin(), numbers.end(), 0);

// 带自定义操作的累加（计算乘积）
int product = accumulate(numbers.begin(), numbers.end(), 1, 
    [](int a, int b) { return a * b; });

// 计算两个向量的点积
vector<int> a = {1, 2, 3};
vector<int> b = {4, 5, 6};
int dot_product = inner_product(a.begin(), a.end(), b.begin(), 0);

1.4.2 差分与部分和

cpp复制// 计算相邻元素差值
vector<int> data = {2, 5, 9, 12, 16, 23};
vector<int> diffs(data.size());
adjacent_difference(data.begin(), data.end(), diffs.begin());

// 计算部分和
vector<int> partial_sums(data.size());
partial_sum(data.begin(), data.end(), partial_sums.begin());

1.5 高级算法技巧与应用

1.5.1 自定义算法谓词

通过自定义谓词，可以使算法适应更复杂的业务逻辑：

cpp复制struct Task {
    string name;
    int priority;
    time_t deadline;
};

vector<Task> tasks = {
    {"Fix bug", 3, 1635724800}, // 2021-11-01
    {"Write docs", 2, 1635811200}, // 2021-11-02
    {"Implement feature", 1, 1635638400} // 2021-10-31
};

// 按优先级排序
sort(tasks.begin(), tasks.end(), 
    [](const Task& a, const Task& b) { return a.priority < b.priority; });

// 查找截止日期在今天之后的任务
time_t now = time(nullptr);
auto it = find_if(tasks.begin(), tasks.end(),
    [now](const Task& t) { return t.deadline > now; });

1.5.2 算法性能优化

理解算法复杂度对性能优化至关重要：

cpp复制// O(n^2)的嵌套循环查找
for (auto it1 = data.begin(); it1 != data.end(); ++it1) {
    for (auto it2 = it1 + 1; it2 != data.end(); ++it2) {
        if (*it1 + *it2 == target) {
            // 找到匹配对
        }
    }
}

// 优化为O(n log n)的排序+双指针查找
sort(data.begin(), data.end());
auto left = data.begin();
auto right = data.end() - 1;
while (left < right) {
    int sum = *left + *right;
    if (sum == target) {
        // 找到匹配对
        ++left; --right;
    } else if (sum < target) {
        ++left;
    } else {
        --right;
    }
}

1.6 常见问题与解决方案

1.6.1 迭代器失效问题

在修改容器时，迭代器可能会失效：

cpp复制vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 错误示范：在遍历时删除元素会导致迭代器失效
/*
for (auto it = nums.begin(); it != nums.end(); ++it) {
    if (*it % 2 == 0) {
        nums.erase(it); // 危险！erase会使it失效
    }
}
*/

// 正确做法：使用erase-remove惯用法
nums.erase(remove_if(nums.begin(), nums.end(), 
    [](int x) { return x % 2 == 0; }), nums.end());

1.6.2 自定义类型的算法支持

要使自定义类型支持标准算法，需要提供适当的比较操作：

cpp复制struct Product {
    string name;
    double price;
    int stock;
    
    // 提供小于运算符，使类型支持默认排序
    bool operator<(const Product& other) const {
        return price < other.price;
    }
};

vector<Product> inventory = {
    {"Widget", 9.99, 50},
    {"Gadget", 14.99, 25},
    {"Thingy", 4.99, 100}
};

// 可以直接使用sort，因为Product提供了operator<
sort(inventory.begin(), inventory.end());

// 也可以提供自定义比较器
sort(inventory.begin(), inventory.end(),
    [](const Product& a, const Product& b) {
        return a.stock > b.stock; // 按库存降序
    });

1.7 现代C++中的算法增强

C++11/14/17/20为算法库带来了许多改进：

1.7.1 并行算法

C++17引入了并行执行策略：

cpp复制#include <execution>

vector<int> big_data(1000000);

// 并行排序
sort(std::execution::par, big_data.begin(), big_data.end());

// 并行transform
vector<int> result(big_data.size());
transform(std::execution::par, 
          big_data.begin(), big_data.end(), result.begin(),
          [](int x) { return x * x; });

1.7.2 范围算法

C++20引入了范围（Ranges）库，使算法使用更简洁：

cpp复制#include <ranges>

vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 使用范围视图过滤和转换
auto even_squares = data | 
                    views::filter([](int x) { return x % 2 == 0; }) |
                    views::transform([](int x) { return x * x; });

// 范围算法
sort(data); // 不再需要begin/end
bool has_even = any_of(data, [](int x) { return x % 2 == 0; });

1.8 算法性能实测比较

通过实际测试比较不同算法的性能差异：

cpp复制#include <chrono>

void test_sort_performance() {
    const int SIZE = 1000000;
    vector<int> data(SIZE);
    generate(data.begin(), data.end(), rand);
    
    auto test = [&](auto&& algo, const string& name) {
        vector<int> copy = data;
        auto start = chrono::high_resolution_clock::now();
        algo(copy.begin(), copy.end());
        auto end = chrono::high_resolution_clock::now();
        cout << name << ": " 
             << chrono::duration_cast<chrono::milliseconds>(end-start).count() 
             << " ms\n";
    };
    
    test(sort, "sort");
    test(stable_sort, "stable_sort");
    test([](auto b, auto e) { partial_sort(b, b+(e-b)/2, e); }, "partial_sort");
}

测试结果通常会显示：

• sort是最快的通用排序
• stable_sort稍慢但保持稳定性
• partial_sort在只需要部分排序时效率更高

1.9 算法在特定领域的应用

1.9.1 游戏开发中的算法应用

cpp复制// 使用partition将活跃游戏对象移到容器前端
vector<GameObject> objects;

auto is_active = [](const GameObject& obj) { return obj.isActive(); };

// 将活跃对象移到前面，返回分界点迭代器
auto middle = partition(objects.begin(), objects.end(), is_active);

// 只处理活跃对象
for_each(objects.begin(), middle, [](GameObject& obj) {
    obj.update();
});

// 使用remove_if清理待删除对象
objects.erase(remove_if(objects.begin(), objects.end(),
    [](const GameObject& obj) { return obj.shouldDelete(); }), objects.end());

1.9.2 数据分析中的算法应用

cpp复制vector<DataPoint> dataset;

// 计算统计量
auto [min_it, max_it] = minmax_element(dataset.begin(), dataset.end(),
    [](const DataPoint& a, const DataPoint& b) { return a.value < b.value; });

double sum = accumulate(dataset.begin(), dataset.end(), 0.0,
    [](double total, const DataPoint& dp) { return total + dp.value; });

double mean = sum / dataset.size();

// 计算方差
double variance = accumulate(dataset.begin(), dataset.end(), 0.0,
    [mean](double total, const DataPoint& dp) {
        double diff = dp.value - mean;
        return total + diff * diff;
    }) / dataset.size();

1.10 自定义算法实现

理解标准算法的最好方式是自己实现它们：

cpp复制template<typename Iterator, typename Predicate>
Iterator my_find_if(Iterator first, Iterator last, Predicate pred) {
    while (first != last) {
        if (pred(*first)) {
            return first;
        }
        ++first;
    }
    return last;
}

template<typename Iterator, typename T>
void my_fill(Iterator first, Iterator last, const T& value) {
    while (first != last) {
        *first = value;
        ++first;
    }
}

template<typename Iterator>
void my_reverse(Iterator first, Iterator last) {
    while ((first != last) && (first != --last)) {
        std::iter_swap(first++, last);
    }
}

通过自己实现这些算法，可以更深入地理解迭代器抽象和通用编程的思想。