STL源码分析--algorithm
更多精彩内容，请关注微信公众号：后端技术小屋c++
STL中实现了一些跟容器相关的一些算法。这里介绍algorithm头文件中一些有意思的算法实现。算法
1 相关头文件
stl_algo.h stl_algobase.h stl_numeric.h
2 find
algorithm头文件中定义的find函数可适用于全部定义了迭代器的STL容器。可是一些经常使用的容器如map/unordered_map/set/unordered_set也定义了类内方法find。当须要搜索元素时，咱们应当选择类内find方法仍是类外find函数呢？后端
当须要搜索容器内某个元素时，应当优先使用类内find方法, 由于其性能不低于类外函数find。举例来在unordered_map中类内find的时间复杂度为O(1)，而类外函数find的时间复杂度为O(n)。微信
如下为类外find的实现。首先经过iterator_traits获取迭代器的类型(可参考STL源码分析--iterator)。判断其为通常的input iterator仍是random access iterator。而后针对这两种状况对find进行了重载。dom
- 若是是通常的input iterator：顺序遍历迭代器的区间，返回与目标值相等的第一个迭代器.
- 若是是random access iterator：首先计算区间长度，而后在遍历时对for循环作展开，展开系数为4。这样作的目的有二，一是为了减小循环次数，减小CPU分支预测的开销；二是提升循环内代码并行化执行的可能性，充分利用现代CPU的SIMD提升吞吐量。
template <class _InputIter, class _Tp>
inline _InputIter find(_InputIter __first, _InputIter __last,
const _Tp& __val)
{
__STL_REQUIRES(_InputIter, _InputIterator);
__STL_REQUIRES_BINARY_OP(_OP_EQUAL, bool,
typename iterator_traits<_InputIter>::value_type, _Tp);
return find(__first, __last, __val, __ITERATOR_CATEGORY(__first));
}
template <class _InputIter, class _Tp>
inline _InputIter find(_InputIter __first, _InputIter __last,
const _Tp& __val,
input_iterator_tag)
{
while (__first != __last && !(*__first == __val))
++__first;
return __first;
}
template <class _RandomAccessIter, class _Tp>
_RandomAccessIter find(_RandomAccessIter __first, _RandomAccessIter __last,
const _Tp& __val,
random_access_iterator_tag)
{
typename iterator_traits<_RandomAccessIter>::difference_type __trip_count
= (__last - __first) >> 2;
for ( ; __trip_count > 0 ; --__trip_count) {
if (*__first == __val) return __first;
++__first;
if (*__first == __val) return __first;
++__first;
if (*__first == __val) return __first;
++__first;
if (*__first == __val) return __first;
++__first;
}
switch(__last - __first) {
case 3:
if (*__first == __val) return __first;
++__first;
case 2:
if (*__first == __val) return __first;
++__first;
case 1:
if (*__first == __val) return __first;
++__first;
case 0:
default:
return __last;
}
}
3 find_if
find_if与find类似，只不过遍历区间时，判断条件变了，判断元素值与目标值相等 --> 判断元素值知足给定的判断条件ide
template <class _InputIter, class _Predicate>
inline _InputIter find_if(_InputIter __first, _InputIter __last,
_Predicate __pred,
input_iterator_tag)
{
while (__first != __last && !__pred(*__first))
++__first;
return __first;
}
4 power
power用于计算一个数的指数，在实现中使用了快速幂算法，时间复杂度为O(log n)，其中n为power的幂次。函数
举例说明快速幂算法：
计算: 3^7 = 3^(1+2+4) = (3^1) * (3^2) * (3*4) = 3 * (3^2) * (3^2)^2源码分析
很容易看出规律，用伪代码表示：性能
result = 1
curr = x
while (x)
{
if (x%2) {
result *= curr
}
curr *= curr
x >>= 1
}
return result
在STL中实现：__opr为函数对象，用它可定义两个_Tp对象的乘法操做，缺省为multiplies<_Tp>，对应的identity_element结果为1，由于任何数字乘1都等于其自己。指针
template <class _Tp, class _Integer>
inline _Tp __power(_Tp __x, _Integer __n)
{
return __power(__x, __n, multiplies<_Tp>());
}
template <class _Tp> inline _Tp identity_element(multiplies<_Tp>) {
return _Tp(1);
}
template <class _Tp, class _Integer, class _MonoidOperation>
_Tp __power(_Tp __x, _Integer __n, _MonoidOperation __opr)
{
if (__n == 0)
return identity_element(__opr);
else {
while ((__n & 1) == 0) {
__n >>= 1;
__x = __opr(__x, __x);
}
_Tp __result = __x;
__n >>= 1;
while (__n != 0) {
__x = __opr(__x, __x);
if ((__n & 1) != 0)
__result = __opr(__result, __x);
__n >>= 1;
}
return __result;
}
}
5 swap
交换两个同类型对象的值。
注意，当对两个容器进行交换时，应当尽可能使用容器类内swap方法，由于algorithm中的swap函数会生成临时变量，执行额外的复制构造函数和析构函数，开销较大。而类内swap方法会尽可能避免这些开销。两者之因此会有这种差异是由于类外swap函数没法访问容器的private/protect成员，没法以最小代价实现交换。
template <class _Tp>
inline void swap(_Tp& __a, _Tp& __b) {
__STL_REQUIRES(_Tp, _Assignable);
_Tp __tmp = __a;
__a = __b;
__b = __tmp;
}
以vector为例，其类内swap以下：
void swap(vector<_Tp, _Alloc>& __x) {
__STD::swap(_M_start, __x._M_start);
__STD::swap(_M_finish, __x._M_finish);
__STD::swap(_M_end_of_storage, __x._M_end_of_storage);
}
若是想交换两个vector的值，使用algorithm中的swap函数意味着生成一个临时vector，以及由此带来的内存分配释放、容器内元素构造/析构的开销。而使用vector类内swap方法只须要交换三个指针便可，开销相比类外swap可忽略不计。
6 rotate
rotate操做：对于容器区间[first, last), 给定旋转点mid, rotate以后，区间将会变成[mid, last)+[first, mid)。
相信刷过leetcode这道题的同窗对roate必定不会陌生：https://leetcode.com/problems/rotate-array/
STL中针对正向迭代器(forward iterator)，双向迭代器(bidirectional iterator)和随机迭代器(random access iterator)的特性重载了rotate算法。虽然实现不一样，可是对用户暴露了一样的接口，用户不用care迭代器类型，由于STL中会经过萃取技术作类型推导。所以在性能和通用性获得了很好的均衡。
6.1 正向迭代器版本
假设容器区间左右两个部分为A B, 且len(A) < len(B)。又假设B可拆分红B1 B2 B3 B4, 且len(B1) = len(B2) = len(B3) = len(A), len(B4) < len(A)
所以A B = A B1 B2 B3 B4, rotate以后的结果： B A = B1 B2 B3 B4 A
算法描述：
第一步：
从作到右不断交换相邻的相同长度区间的值
A B1 B2 B3 B4 -->
B1 A B2 B3 B4 -->
B1 B2 A B3 B4 -->
B1 B2 B3 A B4
第二步：
注意，第一步的最终结果只须要对A B4 进行roate操做, 便可变成B1 B2 B3 B4 A，也就是rotate最终要达到的效果。
- 由于
len(A) > len(B4), 设A = A1 A2, len(A1) = len(B4), 所以A B4 = A1 A2 B4,B4 A = B4 A1 A2。交换A1和B4, 获得B4 A2 A1, 此时问题转化为交换A1和A2 - 不断重复1.中的过程，直到参与交换的两个区间分界线处于右边界位置
算法时间复杂度：n次swap操做，也就是3n次赋值操做
template <class _ForwardIter, class _Distance>
_ForwardIter __rotate(_ForwardIter __first,
_ForwardIter __middle,
_ForwardIter __last,
_Distance*,
forward_iterator_tag) {
if (__first == __middle)
return __last;
if (__last == __middle)
return __first;
_ForwardIter __first2 = __middle;
do {
swap(*__first++, *__first2++);
if (__first == __middle)
__middle = __first2;
} while (__first2 != __last);
_ForwardIter __new_middle = __first;
__first2 = __middle;
while (__first2 != __last) {
swap (*__first++, *__first2++);
if (__first == __middle)
__middle = __first2;
else if (__first2 == __last)
__first2 = __middle;
}
return __new_middle;
}
6.2 双向迭代器版本
原理：
由于双向迭代器既可前进，有可后退，所以rotate的实现比正向迭代器简单的多。设A B, roate以后为B A
第一轮：
翻转A => reverse(A) B
第二轮
翻转B => reverse(A) reverse(B)
第三轮
翻转整个区间 => reverse(reverse(A) reverse(B)) => B A
时间复杂度：交换n次，也就是赋值3n次
template <class _BidirectionalIter, class _Distance>
_BidirectionalIter __rotate(_BidirectionalIter __first,
_BidirectionalIter __middle,
_BidirectionalIter __last,
_Distance*,
bidirectional_iterator_tag) {
__STL_REQUIRES(_BidirectionalIter, _Mutable_BidirectionalIterator);
if (__first == __middle)
return __last;
if (__last == __middle)
return __first;
__reverse(__first, __middle, bidirectional_iterator_tag());
__reverse(__middle, __last, bidirectional_iterator_tag());
while (__first != __middle && __middle != __last)
swap (*__first++, *--__last);
if (__first == __middle) {
__reverse(__middle, __last, bidirectional_iterator_tag());
return __last;
}
else {
__reverse(__first, __middle, bidirectional_iterator_tag());
return __first;
}
}
6.3 随机迭代器版本
这个实现其实涉及到一个群论中定理：
设区间由A B 组成，len(A) = m, len(B) = n, gcd(m, m+n)= s(gcd表示两个整数的最大公约数)
那么分别以0, 1, 2, ..., s-1位置为初始点，经过x(n) = [x(n-1) + m] % (m+n)的规则迭代（终止条件：再次回到初始点），正好能够惟一遍历区间上的全部位置
证实:
-
首先证实以不一样初始点迭代时，遍历的点中没有交集，使用反证法：
假设0<= a < s, 0<= b < s, a < b, 以a, b为初始点迭代时，遍历的点中有交集。
=> 存在k1, k2, 使得(a + k1 * m) % (m+n) = (b + k2 * m) % (m+n)
=>(b - a) % (m+n) = [(k2 - k1) * m] % (m+n)
=>b-a = (m * k3) % (m+n)
由于s = gcd(m, m+n)=>b-a = k4 * s, k4 * s < m + n
由于0 < b-a < s=>k4 = 0 => b = a
获得矛盾，所以得证。 -
再证实以
a, 0 <= a <s为起始点迭代，可以刚好遍历(m+n)/s个点
=> 若是不考虑终止条件，迭代必然陷入死循环，死循环的周期（单位：迭代次数）为(m+n)/s
=> 对于任意a, 存在0 <= k1 < k2, 使得(a + k1 * m) % (m+n) = (a + k2 * m) % (m+n)
=>(k2 - k1)m = k3 * (m+n)
=>k2 - k1 = k3 * (m+n) / m
=>k2 - k1 = k3 * x / y, 其中x与y互质
=> 为使k2-k1最小，k3 = y = m/s
=>k2 - k1 = m/s * (m+n)/m = (m+n)/s
=> 迭代周期为(m+n)/s
=> 得证
综合第一和第二结论，上述定理得证。
在证实了上述结论以后，再回到rotate话题:
- 首先计算
s = gcd(m, m+n) - 以[0, s)区间内的元素为起始点，以
x(n) = [x(n-1) + m] % (m+n)的规则计算下一个点，直到回到起始点，这些点组成一个环，对这个环内全部位置的元素逆时针移动 - 最终获得rotate以后的容器区间。由于第2步中全部元素都向逆时针方向移动了m个位置(把区间想象成顺时针方向索引递增的环形)，这正好符合rotate的定义。
时间复杂度：赋值n次，说明在容器可随机访问的状况下，时间复杂度是其余状况的1/3
template <class _RandomAccessIter, class _Distance, class _Tp>
_RandomAccessIter __rotate(_RandomAccessIter __first,
_RandomAccessIter __middle,
_RandomAccessIter __last,
_Distance *, _Tp *) {
__STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator);
_Distance __n = __last - __first;
_Distance __k = __middle - __first;
_Distance __l = __n - __k;
_RandomAccessIter __result = __first + (__last - __middle);
if (__k == 0)
return __last;
else if (__k == __l) {
swap_ranges(__first, __middle, __middle);
return __result;
}
_Distance __d = __gcd(__n, __k);
for (_Distance __i = 0; __i < __d; __i++) {
_Tp __tmp = *__first;
_RandomAccessIter __p = __first;
if (__k < __l) {
for (_Distance __j = 0; __j < __l/__d; __j++) {
if (__p > __first + __l) {
*__p = *(__p - __l);
__p -= __l;
}
*__p = *(__p + __k);
__p += __k;
}
}
else {
for (_Distance __j = 0; __j < __k/__d - 1; __j ++) {
if (__p < __last - __k) {
*__p = *(__p + __k);
__p += __k;
}
*__p = * (__p - __l);
__p -= __l;
}
}
*__p = __tmp;
++__first;
}
return __result;
}
7 for_each
对于区间内每一个元素执行__f。注意，这里__f既能够是函数对象，也能够是函数指针或std::function类型，__first和__last指定了执行__f的容器区间。
// for_each. Apply a function to every element of a range.
template <class _InputIter, class _Function>
_Function for_each(_InputIter __first, _InputIter __last, _Function __f) {
__STL_REQUIRES(_InputIter, _InputIterator);
for ( ; __first != __last; ++__first)
__f(*__first);
return __f;
}
推荐阅读
- STL源码分析--内存分配器
- STL源码分析--vector
- STL源码分析--string
- STL源码分析--list
- STL源码分析--hashtable
- STL源码分析--deque
- STL源码分析--iterator
- STL源码分析--traits
- STL源码分析--rbtree
- STL源码分析--bitset
- STL源码分析--algorithm
- STL源码分析--functional
更多精彩内容，请扫码关注微信公众号：后端技术小屋。若是以为文章对你有帮助的话，请多多分享、转发、在看。
- 1. STL源码分析--vector
- 2. STL源码分析：Containers
- 3. STL源码分析之list
- 4. STL源码分析--list
- 5. STL源码分析--deque
- 6. STL源码分析之vector
- 7. STL源码分析--iterator
- 8. STL源码分析--bitset
- 9. STL源码分析--traits
- 10. STL源码分析--rbtree
- 更多相关文章...
- • Docker 资源汇总 - Docker教程
- • Java操作Neo4j数据库（附带源码） - NoSQL教程
- • 互联网组织的未来：剖析GitHub员工的任性之源
- • Java Agent入门实战（二）-Instrumentation源码概述
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 安装cuda+cuDNN
- 2. GitHub的使用说明
- 3. phpDocumentor使用教程【安装PHPDocumentor】
- 4. yarn run build报错Component is not found in path “npm/taro-ui/dist/weapp/components/rate/index“
- 5. 精讲Haproxy搭建Web集群
- 6. 安全测试基础之MySQL
- 7. C/C++编程笔记：C语言中的复杂声明分析，用实例带你完全读懂
- 8. Python3教程(1)----搭建Python环境
- 9. 李宏毅机器学习课程笔记2：Classification、Logistic Regression、Brief Introduction of Deep Learning
- 10. 阿里云ECS配置速记
- 1. STL源码分析--vector
- 2. STL源码分析：Containers
- 3. STL源码分析之list
- 4. STL源码分析--list
- 5. STL源码分析--deque
- 6. STL源码分析之vector
- 7. STL源码分析--iterator
- 8. STL源码分析--bitset
- 9. STL源码分析--traits
- 10. STL源码分析--rbtree