更新一些 stl 算法

STL/README.md

@@ -150,23 +150,6 @@ equal_range|获取相同元素的范围，返回包含容器中所有具有与 k
 
 # 算法（algorithms）
 
-方法|含义
----|---
-all_of|返回容器范围 `[first,last)`（参数，迭代器（下同））内的所有元素是否都满足 pred（参数，如 `[](int i){return i%2;}`（下同））条件的布尔值
-any_of|返回容器范围 `[first,last)`（参数）内的任何元素是否存在满足 pred（参数）条件的布尔值
-none_of|返回容器范围 `[first,last)`（参数）内的所以元素是否都不满足 pred（参数）条件的布尔值
-for_each|对于容器范围 `[first,last)`（参数）内的所以元素都调用 fn（参数，一元函数的指针或函数对象）
-find|返回容器范围 `[first,last)`（参数）第一个等于 val（参数）的迭代器。如果没有找到这样的元素则返回 last（参数）
-find_if|返回容器范围 `[first,last)`（参数）内的第一个 pred（参数，一元布尔函数指针）为 true 的迭代器
-find_if_not|返回容器范围 `[first,last)`（参数）内的第一个 pred（参数，一元布尔函数指针）为 false 的迭代器
-find_end|返回容器范围 `[first1,last1)`（参数）内的最后一个完全匹配 `[first2,last2)`（参数）的 `first2`（参数）的迭代器，无法找到则返回 `last1`（参数）
-count|返回容器范围 `[first1,last1)`（参数）内等于 val（参数）的元素个数
-equal|返回容器范围 `[first1,last1)`（参数）与 `first2`开始的容器是否全部元素相等的布尔值
-search|返回容器范围 `[first1,last1)`（参数）内的第一个完全匹配 `[first2,last2)`（参数）的 `first2`（参数）的迭代器，无法找到则返回 `last1`（参数）
-copy|将范围 `[first1,last1)`（参数）内的元素复制到从 `result`（参数）迭代器开始的容器，返回 `result`（参数）指向的容器的范围 `[first1,last1)`（参数）的末尾
-move|将范围 `[first1,last1)`（参数）内的元素移动到从 `result`（参数）迭代器开始的容器，返回 `result`（参数）指向的容器的范围 `[first1,last1)`（参数）的末尾
-swap|交换 `a`、`b`（参数）两个对象的值
-
 ```cpp
 // 简单查找算法，要求输入迭代器（input iterator）
 find(beg, end, val); // 返回一个迭代器，指向输入序列中第一个等于 val 的元素，未找到返回 end
@@ -225,4 +208,83 @@ replace_copy_if(beg, end, dest, unaryPred, new_val); // 将每个元素拷贝到
 merge(beg1, end1, beg2, end2, dest); // 两个输入序列必须都是有序的，用 < 运算符将合并后的序列写入到 dest 中
 merge(beg1, end1, beg2, end2, dest, comp) // 两个输入序列必须都是有序的，使用给定的比较操作（comp）将合并后的序列写入到 dest 中
 
+// 使用前向迭代器的写算法，要求前向迭代器
+iter_swap(iter1, iter2); // 交换 iter1 和 iter2 所表示的元素，返回 void
+swap_ranges(beg1, end1, beg2); // 将输入范围中所有元素与 beg2 开始的第二个序列中所有元素进行交换。返回递增后的的 beg2，指向最后一个交换元素之后的位置。
+replace(beg, end, old_val, new_val); // 用 new_val 替换等于 old_val 的每个匹配元素
+replace_if(beg, end, unaryPred, new_val); // 用 new_val 替换满足 unaryPred 的每个匹配元素
+
+// 使用双向迭代器的写算法，要求双向选代器（bidirectional iterator）
+copy_backward(beg, end, dest); // 从输入范围中拷贝元素到指定目的位置。如果范围为空,则返回值为 dest；否则，返回值表示从 *beg 中拷贝或移动的元素。
+move_backward(beg, end, dest);  // 从输入范围中移动元素到指定目的位置。如果范围为空,则返回值为 dest；否则,返回值表示从 *beg 中拷贝或移动的元素。
+inplace_merge(beg, mid, end); // 将同一个序列中的两个有序子序列合并为单一的有序序列。beg 到 mid 间的子序列和 mid 到 end 间的子序列被合并，并被写入到原序列中。使用 < 比较元素。
+inplace_merge(beg, mid, end, comp) // 将同一个序列中的两个有序子序列合并为单一的有序序列。beg 到 mid 间的子序列和 mid 到 end 间的子序列被合并，并被写入到原序列中。使用给定的 comp 操作。
+
+// 划分算法，要求双向选代器（bidirectional iterator）
+is_partitioned(beg, end, unaryPred); // 如果所有满足谓词 unaryPred 的元素都在不满足 unarypred 的元素之前，则返回 true。若序列为空，也返回 true
+partition_copy(beg, end, dest1, dest2, unaryPred); // 将满足 unaryPred 的元素拷贝到到 dest1，并将不满足 unaryPred 的元素拷贝到到 dest2。返回一个迭代器 pair，其 first 成员表示拷贝到 dest1 的的元素的末尾，second 表示拷贝到 dest2 的元素的末尾。
+partitioned_point(beg, end, unaryPred); // 输入序列必须是已经用 unaryPred 划分过的。返回满足  unaryPred 的范围的尾后迭代器。如果返回的迭代器不是 end，则它指向的元素及其后的元素必须都不满足 unaryPred
+stable_partition(beg, end, unaryPred); // 使用 unaryPred 划分输入序列。满足 unaryPred 的元素放置在序列开始，不满足的元素放在序列尾部。返回一个迭代器，指向最后一个满足 unaryPred 的元素之后的位置如果所有元素都不满足 unaryPred，则返回 beg
+partition(beg, end, unaryPred); // 使用 unaryPred 划分输入序列。满足 unaryPred 的元素放置在序列开始，不满足的元素放在序列尾部。返回一个迭代器，指向最后一个满足 unaryPred 的元素之后的位置如果所有元素都不满足 unaryPred，则返回 beg
+
+// 排序算法，要求随机访问迭代器（random-access iterator）
+sort(beg, end); // 排序整个范围
+stable_sort(beg, end); // 排序整个范围（稳定排序）
+sort(beg, end, comp) // 排序整个范围
+stable_sort(beg, end, comp) // 排序整个范围（稳定排序）
+is_sorted(beg, end); // 返回一个 bool 值，指出整个输入序列是否有序
+is_sorted(beg, end, comp); // 返回一个 bool 值，指出整个输入序列是否有序
+is_sorted_until(beg, end); // 在输入序列中査找最长初始有序子序列，并返回子序列的尾后迭代器
+is_sorted_until(beg, end, comp); // 在输入序列中査找最长初始有序子序列，并返回子序列的尾后迭代器
+partial_sort(beg, mid, end); // 排序 mid-beg 个元素。即，如果 mid-beg 等于 42，则此函数将值最小的 42 个元素有序放在序列前 42 个位置
+partial_sort(beg, mid, end, comp); // 排序 mid-beg 个元素。即，如果 mid-beg 等于 42，则此函数将值最小的 42 个元素有序放在序列前 42 个位置
+partial_sort_copy(beg, end, destBeg, destEnd); // 排序输入范围中的元素，并将足够多的已排序元素放到 destBeg 和 destEnd 所指示的序列中
+partial_sort_copy(beg, end, destBeg, destEnd, comp); // 排序输入范围中的元素，并将足够多的已排序元素放到 destBeg 和 destEnd 所指示的序列中
+nth_element(beg, nth, end); // nth 是一个迭代器，指向输入序列中第 n 大的元素。nth 之前的元素都小于等于它，而之后的元素都大于等于它
+nth_element(beg, nth, end, comp); // nth 是一个迭代器，指向输入序列中第 n 大的元素。nth 之前的元素都小于等于它，而之后的元素都大于等于它
+
+// 使用前向迭代器的重排算法。普通版本在输入序列自身内部重拍元素，_copy 版本完成重拍后写入到指定目的序列中，而不改变输入序列
+remove(beg, end, val); // 通过用保留的元素覆盖要删除的元素实现删除 ==val 的元素，返回一个指向最后一个删除元素的尾后位置的迭代器
+remove_if(beg, end, unaryPred); // 通过用保留的元素覆盖要删除的元素实现删除满足 unaryPred 的元素，返回一个指向最后一个删除元素的尾后位置的迭代器
+remove_copy(beg, end, dest, val); // 通过用保留的元素覆盖要删除的元素实现删除 ==val 的元素，返回一个指向最后一个删除元素的尾后位置的迭代器
+remove_copy_if(beg, end, dest, unaryPred); // 通过用保留的元素覆盖要删除的元素实现删除满足 unaryPred 的元素，返回一个指向最后一个删除元素的尾后位置的迭代器
+unique(beg, end); // 通过对覆盖相邻的重复元素（用 == 确定是否相同）实现重排序列。返回一个迭代器，指向不重复元素的尾后位置
+unique (beg, end, binaryPred); // 通过对覆盖相邻的重复元素（用 binaryPred 确定是否相同）实现重排序列。返回一个迭代器，指向不重复元素的尾后位置
+unique_copy(beg, end, dest); // 通过对覆盖相邻的重复元素（用 == 确定是否相同）实现重排序列。返回一个迭代器，指向不重复元素的尾后位置
+unique_copy_if(beg, end, dest, binaryPred); // 通过对覆盖相邻的重复元素（用 binaryPred 确定是否相同）实现重排序列。返回一个迭代器，指向不重复元素的尾后位置
+rotate(beg, mid, end); // 围绕 mid 指向的元素进行元素转动。元素 mid 成为为首元素，随后是 mid+1 到到 end 之前的元素，再接着是 beg 到 mid 之前的元素。返回一个迭代器，指向原来在 beg 位置的元素
+rotate_copy(beg, mid, end, dest); // 围绕 mid 指向的元素进行元素转动。元素 mid 成为为首元素，随后是 mid+1 到到 end 之前的元素，再接着是 beg 到 mid 之前的元素。返回一个迭代器，指向原来在 beg 位置的元素
+
+// 使用双向迭代器的重排算法
+reverse(beg, end); // 翻转序列中的元素，返回 void
+reverse_copy(beg, end, dest);; // 翻转序列中的元素，返回一个迭代器，指向拷贝到目的序列的元素的尾后位置
+
+// 使用随机访问迭代器的重排算法
+random_shuffle(beg, end); // 混洗输入序列中的元素，返回 void
+random_shuffle(beg, end, rand); // 混洗输入序列中的元素，rand 接受一个正整数的随机对象，返回 void
+shuffle(beg, end, Uniform_rand); // 混洗输入序列中的元素，Uniform_rand 必须满足均匀分布随机数生成器的要求，返回 void
+
+// 最小值和最大值，使用 < 运算符或给定的比较操作 comp 进行比较
+min(val1, va12); // 返回 val1 和 val2 中的最小值，两个实参的类型必须完全一致。参数和返回类型都是 const的引引用，意味着对象不会被拷贝。下略
+min(val1, val2, comp);
+min(init_list);
+min(init_list, comp);
+max(val1, val2);
+max(val1, val2, comp);
+max(init_list);
+max(init_list, comp);
+minmax(val1, val2); // 返回一个 pair，其 first 成员为提供的值中的较小者，second 成员为较大者。下略
+minmax(vall, val2, comp);
+minmax(init_list);
+minmax(init_list, comp);
+min_element(beg, end); // 返回指向输入序列中最小元素的迭代器
+min_element(beg, end, comp); // 返回指向输入序列中最小元素的迭代器
+max_element(beg, end); // 返回指向输入序列中最大元素的迭代器
+max_element(beg, end, comp); // 返回指向输入序列中最大元素的迭代器
+minmax_element(beg, end); // 返回一个 pair，其中 first 成员为最小元素，second 成员为最大元素
+minmax_element(beg, end, comp); // 返回一个 pair，其中 first 成员为最小元素，second 成员为最大元素
+
+// 字典序比较，根据第一对不相等的元素的相对大小来返回结果。如果第一个序列在字典序中小于第二个序列，则返回 true。否则，返回 fa1se。如果个序列比另一个短，且所有元素都与较长序列的对应元素相等，则较短序列在字典序中更小。如果序列长度相等，且对应元素都相等，则在字典序中任何一个都不大于另外一个。
+lexicographical_compare(beg1, end1, beg2, end2);
+lexicographical_compare(beg1, end1, beg2, end2, comp)
 ```