C++之C++算法

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

认识迭代器

在详细介绍算法之前，还有一个必须要了解的概念，那就是迭代器（iterator），它相当于算法的“手脚”。虽然刚才我说算法操作容器，但实际上它看到的并不是容器，而是指向起始位置和结束位置的迭代器，算法只能通过迭代器去“间接”访问容器以及元素，算法的能力是由迭代器决定的。

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

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

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

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

1. distance()，计算两个迭代器之间的距离；
2. advance()，前进或者后退 N 步；
3. 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，所以你要认真理解它们的含义。我来介绍一些常见问题对应的算法：

1. 要求排序后仍然保持元素的相对顺序，应该用 stable_sort，它是稳定的；
2. 选出前几名（TopN），应该用 partial_sort；
3. 选出前几名，但不要求再排出名次（BestN），应该用 nth_element；
4. 中位数（Median）、百分位数（Percentile），还是用 nth_element；
5. 按照某种规则把元素划分成两组，用 partition；
6. 第一名和最后一名，用 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()比较才能知道是否找到