SGISTL源码阅读二十六 数值算法 (stl_numeric.h)
前言
上一篇博客我们简要介绍了一下STL中的算法,所有的数值算法都是放在<stl_numeric.h
中的。
深入源码
accumulate
该算法是做累加操作,将指向范围的元素累加到init
上,并且将init
作为返回值返回,若init
为0,则是计算迭代器指定范围值的累加和。要求迭代器类型至少为InputIterator
//版本1
template <class InputIterator, class T>
T accumulate(InputIterator first, InputIterator last, T init) {
//将迭代器指定范围的元素值全部累加到init上
for ( ; first != last; ++first)
init = init + *first;
return init;
}
//版本2
template <class InputIterator, class T, class BinaryOperation>
T accumulate(InputIterator first, InputIterator last, T init,
BinaryOperation binary_op) {
for ( ; first != last; ++first)
//对每个元素进行二元操作(外界提供的仿函数)
init = binary_op(init, *first);
return init;
}
inner_product
该算法用于计算两个序列,[first1,last)和[first2, first2+(last1-first1))的一般内积,用init
暂存结果并返回,若init
为0,则是计算迭代器指定范围的两个序列的一般内积。
//版本1
template <class InputIterator1, class InputIterator2, class T>
T inner_product(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, T init) {
//做内积需要两个长度相同的序列,所以只需用迭代器指定一个序列的范围即可
for ( ; first1 != last1; ++first1, ++first2)
init = init + (*first1 * *first2);
return init;
}
//版本2
template <class InputIterator1, class InputIterator2, class T,
class BinaryOperation1, class BinaryOperation2>
T inner_product(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, T init, BinaryOperation1 binary_op1,
BinaryOperation2 binary_op2) {
for ( ; first1 != last1; ++first1, ++first2)
//指定二元操作,外界提供的仿函数
init = binary_op1(init, binary_op2(*first1, *first2));
return init;
}
partial_sum
该算法用于计算局部和,这样说可能会被误解,我们用图示来解释。
//版本1
template <class InputIterator, class OutputIterator, class T>
OutputIterator __partial_sum(InputIterator first, InputIterator last,
OutputIterator result, T*) {
//将value赋初值为*first
T value = *first;
//遍历[first, last)
while (++first != last) {
value = value + *first;
//给result赋值同时移动它
*++result = value;
}
return ++result;
}
template <class InputIterator, class OutputIterator>
OutputIterator partial_sum(InputIterator first, InputIterator last,
OutputIterator result) {
//如果first和last是同一个迭代器,则直接返回result
if (first == last) return result;
//让result位置直接等于first
*result = *first;
//调用__partial_sum进行后续计算
return __partial_sum(first, last, result, value_type(first));
}
//版本2
//核心思想与版本1类似,只是外界传入了指定的伪函数binary_op作为二元操作符
template <class InputIterator, class OutputIterator, class T,
class BinaryOperation>
OutputIterator __partial_sum(InputIterator first, InputIterator last,
OutputIterator result, T*,
BinaryOperation binary_op) {
T value = *first;
while (++first != last) {
value = binary_op(value, *first);
*++result = value;
}
return ++result;
}
template <class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator partial_sum(InputIterator first, InputIterator last,
OutputIterator result, BinaryOperation binary_op) {
if (first == last) return result;
*result = *first;
return __partial_sum(first, last, result, value_type(first), binary_op);
}
adjacent_difference
partial_sum
算法用于计算局部和,而adjacent_difference
用来计算[first, last)相邻元素的差,如图
//版本1
template <class InputIterator, class OutputIterator, class T>
OutputIterator __adjacent_difference(InputIterator first, InputIterator last,
OutputIterator result, T*) {
//将value赋初值为first
T value = *first;
//遍历[first, last)计算相邻元素的差
while (++first != last) {
//暂存当前元素的值
T tmp = *first;
//给result赋值为当前元素和前一个元素的差
//并将result移位
*++result = tmp - value;
value = tmp;
}
return ++result;
}
template <class InputIterator, class OutputIterator>
OutputIterator adjacent_difference(InputIterator first, InputIterator last,
OutputIterator result) {
//如果first和last是同一个迭代器,则直接返回result
if (first == last) return result;
//result序列的第一个值为first
*result = *first;
//调用__adjacent_difference进行后续计算
return __adjacent_difference(first, last, result, value_type(first));
}
//版本2
//核心思想与版本1类似,只是外界传入了指定的伪函数binary_op作为二元操作符
template <class InputIterator, class OutputIterator, class T,
class BinaryOperation>
OutputIterator __adjacent_difference(InputIterator first, InputIterator last,
OutputIterator result, T*,
BinaryOperation binary_op) {
T value = *first;
while (++first != last) {
T tmp = *first;
*++result = binary_op(tmp, value);
value = tmp;
}
return ++result;
}
template <class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator adjacent_difference(InputIterator first, InputIterator last,
OutputIterator result,
BinaryOperation binary_op) {
if (first == last) return result;
*result = *first;
return __adjacent_difference(first, last, result, value_type(first),
binary_op);
}
power
这个算法是SGI专属,不在STL标准之列。
这个算法并不陌生,用于计算某数的n次方,使用了快速幂算法,区分奇偶,计算x^n的值,只需要O(logn)的复杂度,而不是O(n)。
- b为偶数:a^b = (a2)b/2
- b为奇数:a^b = (a2)b/2*a
//版本1
//指定操作符op
template <class T, class Integer, class MonoidOperation>
T power(T x, Integer n, MonoidOperation op) {
if (n == 0)
return identity_element(op);
else {
//当n为偶数,不断的执行op,然后将n/2,直到n为奇数
while ((n & 1) == 0) {
n >>= 1;
x = op(x, x);
}
//对n为奇数时进行计算
T result = x;
n >>= 1;
while (n != 0) {
x = op(x, x);
if ((n & 1) != 0)
result = op(result, x);
n >>= 1;
}
return result;
}
}
//版本2,调用了版本1
//缺省为乘法运算
template <class T, class Integer>
inline T power(T x, Integer n) {
return power(x, n, multiplies<T>());
}
iota
这个算法是SGI专属,不在STL标准之列。
用来设定某个区间的内容,使其内的每一个元素从指定的value开始呈现递增状态
在[first, last)区间内将元素的值依次设置为value, value + 1, value + 2…
是一种质变算法。
template <class ForwardIterator, class T>
void iota(ForwardIterator first, ForwardIterator last, T value) {
while (first != last) *first++ = value++;
}
总结
我们可以看到以上的算法基本上都有两个版本,一个缺省操作符,另一个可由外界提供。
算法也并不难理解,值得学习的是power
中的快速幂算法。