# 13 | 五花八门的算法：不要再手写for循环了

    你好，我是Chrono。

上节课我提到了计算机界的经典公式“算法 + 数据结构 = 程序”，公式里的“数据结构”就是C++里的容器，容器我们已经学过了，今天就来学习下公式里的“算法”。

虽然算法是STL（标准库前身）的三大要件之一（容器、算法、迭代器），也是C++标准库里一个非常重要的部分，但它却没有像容器那样被大众广泛接受。

从我观察到的情况来看，很多人都会在代码里普遍应用vector、set、map，但几乎从来不用任何算法，聊起算法这个话题，也是“一问三不知”，这的确是一个比较奇怪的现象。而且，很多语言对算法也不太“上心”。

但是，在C++里，算法的地位非常高，甚至有一个专门的“算法库”。早期，它是泛型编程的示范和应用，而在C++引入lambda表达式后，它又成了函数式编程的具体实践，所以，**学习掌握算法能够很好地训练你的编程思维，帮你开辟出面向对象之外的新天地**。

## 认识算法

从纯理论上来说，算法就是一系列定义明确的操作步骤，并且会在有限次运算后得到结果。

计算机科学里有很多种算法，像排序算法、查找算法、遍历算法、加密算法，等等。但是在C++里，算法的含义就要狭窄很多了。

C++里的算法，指的是**工作在容器上的一些泛型函数**，会对容器内的元素实施的各种操作。

C++标准库目前提供了上百个算法，真的可以说是“五花八门”，涵盖了绝大部分的“日常工作”。比如：

*   remove，移除某个特定值；
*   sort，快速排序；
*   binary\_search，执行二分查找；
*   make\_heap，构造一个堆结构；
*   ……

不过要是“说白了”，算法其实并不神秘，因为所有的算法本质上都是for或者while，通过循环遍历来逐个处理容器里的元素。

比如说count算法，它的功能非常简单，就是统计某个元素的出现次数，完全可以用range-for来实现同样的功能：

```
vector<int> v = {1,3,1,7,5};    // vector容器

auto n1 = std::count(          // count算法计算元素的数量 
    begin(v), end(v), 1        // begin()、end()获取容器的范围
);  

int n2 = 0;
for(auto x : v) {              // 手写for循环
    if (x == 1) {              // 判断条件，然后统计
        n2++;
    }
}  

```

你可能会问，既然是这样，我们直接写for循环不就好了吗，为什么还要调用算法来“多此一举”呢？

在我看来，这应该是一种“境界”，**追求更高层次上的抽象和封装**，也是函数式编程的基本理念。

每个算法都有一个清晰、准确的命名，不需要额外的注释，让人一眼就可以知道操作的意图，而且，算法抽象和封装了反复出现的操作逻辑，也更有利于重用代码，减少手写的错误。

还有更重要的一点：和容器一样，算法是由那些“超级程序员”创造的，它的内部实现肯定要比你随手写出来的循环更高效，而且必然经过了良好的验证测试，绝无Bug，无论是功能还是性能，都是上乘之作。

如果在以前，你不使用算法还有一个勉强可以说的理由，就是很多算法必须要传入一个函数对象，写起来很麻烦。但是现在，因为有可以“**就地定义函数**”的lambda表达式，算法的形式就和普通循环非常接近了，所以刚刚说的也就不再是什么问题了。

用算法加上lambda表达式，你就可以初步体验函数式编程的感觉（即函数套函数）：

```
auto n = std::count_if(      // count_if算法计算元素的数量
    begin(v), end(v),       // begin()、end()获取容器的范围
    [](auto x) {            // 定义一个lambda表达式
        return x > 2;       // 判断条件
    }
);                          // 大函数里面套了三个小函数

```

## 认识迭代器

在详细介绍算法之前，还有一个必须要了解的概念，那就是迭代器（iterator），它相当于算法的“手脚”。

虽然刚才我说算法操作容器，但实际上它看到的并不是容器，而是指向起始位置和结束位置的迭代器，算法只能通过迭代器去“**间接**”访问容器以及元素，算法的能力是由迭代器决定的。

这种间接的方式有什么好处呢？

这就是泛型编程的理念，与面向对象正好相反，**分离了数据和操作**。算法可以不关心容器的内部结构，以一致的方式去操作元素，适用范围更广，用起来也更灵活。

当然万事无绝对，这种方式也有弊端。因为算法是通用的，免不了对有的数据结构虽然可行但效率比较低。所以，对于merge、sort、unique等一些特别的算法，容器就提供了专门的替代成员函数（相当于特化），这个稍后我会再提一下。

C++里的迭代器也有很多种，比如输入迭代器、输出迭代器、双向迭代器、随机访问迭代器，等等，概念解释起来不太容易。不过，你也没有必要把它们搞得太清楚，因为常用的迭代器用法都是差不多的。你可以把它简单地理解为另一种形式的“智能指针”，只是它**强调的是对数据的访问**，而不是生命周期管理。

容器一般都会提供begin()、end()成员函数，调用它们就可以得到表示两个端点的迭代器，具体类型最好用auto自动推导，不要过分关心：

```
vector<int> v = {1,2,3,4,5};    // vector容器

auto iter1 = v.begin();        // 成员函数获取迭代器，自动类型推导
auto iter2 = v.end();

```

不过，我建议你使用更加通用的全局函数begin()、end()，虽然效果是一样的，但写起来比较方便，看起来也更清楚（另外还有cbegin()、cend()函数，返回的是常量迭代器）：

```
auto iter3 = std::begin(v);   // 全局函数获取迭代器，自动类型推导
auto iter4 = std::end(v);

```

迭代器和指针类似，也可以前进和后退，但你不能假设它一定支持“`++`”“`--`”操作符，最好也要用函数来操作，常用的有这么几个：

*   distance()，计算两个迭代器之间的距离；
*   advance()，前进或者后退N步；
*   next()/prev()，计算迭代器前后的某个位置。

你可以参考下面的示例代码快速了解它们的作用：

```
array<int, 5> arr = {0,1,2,3,4};  // array静态数组容器

auto b = begin(arr);          // 全局函数获取迭代器，首端
auto e = end(arr);            // 全局函数获取迭代器，末端

assert(distance(b, e) == 5);  // 迭代器的距离

auto p = next(b);              // 获取“下一个”位置
assert(distance(b, p) == 1);    // 迭代器的距离
assert(distance(p, b) == -1);  // 反向计算迭代器的距离

advance(p, 2);                // 迭代器前进两个位置，指向元素'3'
assert(*p == 3);
assert(p == prev(e, 2));     // 是末端迭代器的前两个位置

```

## 最有用的算法

接下来我们就要大量使用各种函数，进入算法的函数式编程领域了。

#### 手写循环的替代品

首先，我带你来认识一个最基本的算法for\_each，它是手写for循环的真正替代品。

for\_each在逻辑和形式上与for循环几乎完全相同：

```
vector<int> v = {3,5,1,7,10};   // vector容器

for(const auto& x : v) {        // range for循环
    cout << x << ",";
}

auto print = [](const auto& x)  // 定义一个lambda表达式
{
    cout << x << ",";
};
for_each(cbegin(v), cend(v), print);// for_each算法

for_each(                      // for_each算法，内部定义lambda表达式
    cbegin(v), cend(v),        // 获取常量迭代器
    [](const auto& x)          // 匿名lambda表达式
    {
        cout << x << ",";
    }
);

```

初看上去for\_each算法显得有些累赘，既要指定容器的范围，又要写lambda表达式，没有range-for那么简单明了。

对于很简单的for循环来说，确实是如此，我也不建议你对这么简单的事情用for\_each算法。

但更多的时候，for循环体里会做很多事情，会由if-else、break、continue等语句组成很复杂的逻辑。而单纯的for是“无意义”的，你必须去查看注释或者代码，才能知道它到底做了什么，回想一下曾经被巨大的for循环支配的“恐惧”吧。

for\_each算法的价值就体现在这里，它把要做的事情分成了两部分，也就是两个函数：一个**遍历容器元素**，另一个**操纵容器元素**，而且名字的含义更明确，代码也有更好的封装。

我自己是很喜欢用for\_each算法的，我也建议你尽量多用for\_each来替代for，因为它能够促使我们更多地以“函数式编程”来思考，使用lambda来封装逻辑，得到更干净、更安全的代码。

#### 排序算法

for\_each是for的等价替代，还不能完全体现出算法的优越性。但对于“排序”这个计算机科学里的经典问题，你是绝对没有必要自己写for循环的，必须坚决地选择标准算法。

在求职面试的时候，你也许手写过不少排序算法吧，像选择排序、插入排序、冒泡排序，等等，但标准库里的算法绝对要比你所能写出的任何实现都要好。

说到排序，你脑海里跳出的第一个词可能就是sort()，它是经典的快排算法，通常用它准没错。

```
auto print = [](const auto& x)  // lambda表达式输出元素
{
    cout << x << ",";
};

std::sort(begin(v), end(v));         // 快速排序
for_each(cbegin(v), cend(v), print); // for_each算法

```

不过，排序也有多种不同的应用场景，sort()虽然快，但它是不稳定的，而且是全排所有元素。

很多时候，这样做的成本比较高，比如TopN、中位数、最大最小值等，我们只关心一部分数据，如果你用sort()，就相当于“杀鸡用牛刀”，是一种浪费。

C++为此准备了多种不同的算法，不过它们的名字不全叫sort，所以你要认真理解它们的含义。

我来介绍一些常见问题对应的算法：

*   要求排序后仍然保持元素的相对顺序，应该用stable\_sort，它是稳定的；
*   选出前几名（TopN），应该用partial\_sort；
*   选出前几名，但不要求再排出名次（BestN），应该用nth\_element；
*   中位数（Median）、百分位数（Percentile），还是用nth\_element；
*   按照某种规则把元素划分成两组，用partition；
*   第一名和最后一名，用minmax\_element。

下面的代码使用vector容器示范了这些算法，注意它们“函数套函数”的形式：

```
// top3
std::partial_sort(
    begin(v), next(begin(v), 3), end(v));  // 取前3名

// best3
std::nth_element(
    begin(v), next(begin(v), 3), end(v));  // 最好的3个

// Median
auto mid_iter =                            // 中位数的位置
    next(begin(v), v.size()/2);
std::nth_element( begin(v), mid_iter, end(v));// 排序得到中位数
cout << "median is " << *mid_iter << endl;
    
// partition
auto pos = std::partition(                // 找出所有大于9的数
    begin(v), end(v),
    [](const auto& x)                    // 定义一个lambda表达式
    {
        return x > 9;
    }
); 
for_each(begin(v), pos, print);         // 输出分组后的数据  

// min/max
auto value = std::minmax_element(        //找出第一名和倒数第一
    cbegin(v), cend(v)
);

```

在使用这些排序算法时，还要注意一点，它们对迭代器要求比较高，通常都是随机访问迭代器（minmax\_element除外），所以**最好在顺序容器array/vector上调用**。

如果是list容器，应该调用成员函数sort()，它对链表结构做了特别的优化。有序容器set/map本身就已经排好序了，直接对迭代器做运算就可以得到结果。而对无序容器，则不要调用排序算法，原因你应该不难想到（散列表结构的特殊性质，导致迭代器不满足要求、元素无法交换位置）。

#### 查找算法

排序算法的目标是让元素有序，这样就可以快速查找，节约时间。

算法binary\_search，顾名思义，就是在已经排好序的区间里执行二分查找。但糟糕的是，它只返回一个bool值，告知元素是否存在，而更多的时候，我们是想定位到那个元素，所以binary\_search几乎没什么用。

```
vector<int> v = {3,5,1,7,10,99,42};  // vector容器
std::sort(begin(v), end(v));        // 快速排序

auto found = binary_search(         // 二分查找，只能确定元素在不在
    cbegin(v), cend(v), 7
); 

```

想要在已序容器上执行二分查找，要用到一个名字比较怪的算法：lower\_bound，它返回第一个“**大于或等于**”值的位置：

```
decltype(cend(v)) pos;            // 声明一个迭代器，使用decltype

pos = std::lower_bound(          // 找到第一个>=7的位置
    cbegin(v), cend(v), 7
);  
found = (pos != cend(v)) && (*pos == 7); // 可能找不到，所以必须要判断
assert(found);                          // 7在容器里

pos = std::lower_bound(               // 找到第一个>=9的位置
    cbegin(v), cend(v), 9
);  
found = (pos != cend(v)) && (*pos == 9); // 可能找不到，所以必须要判断
assert(!found);                          // 9不在容器里

```

lower\_bound的返回值是一个迭代器，所以就要做一点判断工作，才能知道是否真的找到了。判断的条件有两个，一个是迭代器是否有效，另一个是迭代器的值是不是要找的值。

注意lower\_bound的查找条件是“**大于等于**”，而不是“等于”，所以它的真正含义是“大于等于值的第一个位置”。相应的也就有“大于等于值的最后一个位置”，算法叫upper\_bound，返回的是第一个“**大于**”值的元素。

```
pos = std::upper_bound(             // 找到第一个>9的位置
    cbegin(v), cend(v), 9
);

```

因为这两个算法不是简单的判断相等，作用有点“绕”，不太好掌握，我来给你解释一下。

它俩的返回值构成一个区间，这个区间往前就是所有比被查找值小的元素，往后就是所有比被查找值大的元素，可以写成一个简单的不等式：

```
begin <    x <= lower_bound < upper_bound     < end

```

比如，在刚才的这个例子里，对数字9执行lower\_bound和upper\_bound，就会返回\[10,10\]这样的区间。

对于有序容器set/map，就不需要调用这三个算法了，它们有等价的成员函数find/lower\_bound/upper\_bound，效果是一样的。

不过，你要注意find与binary\_search不同，它的返回值不是bool而是迭代器，可以参考下面的示例代码：

```
multiset<int> s = {3,5,1,7,7,7,10,99,42};  // multiset，允许重复

auto pos = s.find(7);                      // 二分查找，返回迭代器
assert(pos != s.end());                   // 与end()比较才能知道是否找到

auto lower_pos = s.lower_bound(7);       // 获取区间的左端点
auto upper_pos = s.upper_bound(7);       // 获取区间的右端点

for_each(                                // for_each算法
    lower_pos, upper_pos, print          // 输出7,7,7
);

```

除了binary\_search、lower\_bound和upper\_bound，标准库里还有一些查找算法可以用于未排序的容器，虽然肯定没有排序后的二分查找速度快，但也正因为不需要排序，所以适应范围更广。

这些算法以find和search命名，不过可能是当时制定标准时的疏忽，名称有点混乱，其中用于查找区间的find\_first\_of/find\_end，或许更应该叫作search\_first/search\_last。

这几个算法调用形式都是差不多的，用起来也很简单：

```
vector<int> v = {1,9,11,3,5,7};  // vector容器

decltype(v.end()) pos;          // 声明一个迭代器，使用decltype

pos = std::find(                 // 查找算法，找到第一个出现的位置
    begin(v), end(v), 3
);  
assert(pos != end(v));         // 与end()比较才能知道是否找到

pos = std::find_if(            // 查找算法，用lambda判断条件
    begin(v), end(v),
    [](auto x) {              // 定义一个lambda表达式
        return x % 2 == 0;    // 判断是否偶数
    }
);  
assert(pos == end(v));        // 与end()比较才能知道是否找到

array<int, 2> arr = {3,5};    // array容器
pos = std::find_first_of(      // 查找一个子区间
    begin(v), end(v),
    begin(arr), end(arr)
);  
assert(pos != end(v));       // 与end()比较才能知道是否找到

```

## 小结

C++里有上百个算法，我们不可能也没办法在一节课的时间里全部搞懂，所以我就精挑细选了一些我个人认为最有用的for\_each、排序和查找算法，把它们介绍给你。

在我看来，C++里的算法像是一个大宝库，非常值得你去发掘。比如类似memcpy的copy/move算法（搭配插入迭代器）、检查元素的all\_of/any\_of算法，用好了都可以替代很多手写for循环。

你可以课后仔细阅读[标准文档](https://en.cppreference.com/w/cpp/algorithm)，对照自己的现有代码，看看哪些能用得上，再试着用算法来改写实现，体会一下算法的简洁和高效。

简单小结一下这次的内容：

1.  算法是专门操作容器的函数，是一种“智能for循环”，它的最佳搭档是lambda表达式；
2.  算法通过迭代器来间接操作容器，使用两个端点指定操作范围，迭代器决定了算法的能力；
3.  for\_each算法是for的替代品，以函数式编程替代了面向过程编程；
4.  有多种排序算法，最基本的是sort，但应该根据实际情况选择其他更合适的算法，避免浪费；
5.  在已序容器上可以执行二分查找，应该使用的算法是lower\_bound；
6.  list/set/map提供了等价的排序、查找函数，更适应自己的数据结构；
7.  find/search是通用的查找算法，效率不高，但不必排序也能使用。

和上节课一样，我再附送一个小技巧。

因为标准算法的名字实在是太普通、太常见了，所以建议你一定要显式写出“std::”名字空间限定，这样看起来更加醒目，也避免了无意的名字冲突。

## 课下作业

最后是课下作业时间，给你留两个思考题：

1.  你觉得for\_each算法能完全替代for循环吗？
2.  试着自己总结归纳一下，这些排序和查找算法在实际开发中应该如何使用。

欢迎你在留言区写下你的思考和答案，如果觉得今天的内容对你有所帮助，也欢迎分享给你的朋友。我们下节课见。

![](https://static001.geekbang.org/resource/image/77/d4/77cbcdf7cf05fe7c6fac877649d627d4.jpg)