1、算法概述
算法,问题之解法也。再好的编程技巧,也无法让一个笨拙的算法起死回生。选择了错误的算法,便注定了失败的命运。
STL中极具复用价值的70余个STL算法,包括赫赫有名的排序、查找、排列组合算法,以及用于数据移动、复制、删除、比较、组合、运算等算法。
(1)质变算法——会改变操作对象的值
质变算法是指运算过程中会更改区间内迭代器所指的元素内容。例如拷贝(copy)、互换(swap)、替换(replace)、填写(fill)、删除(remove)、排列组合(permutation)、分割(partition)、随机重排(random shuffling)、排序(sort)等算法。
(2)非质变算法——不会改变操作对象的值
非质变算法是指运算过程中不会更改区间内迭代器所指的元素内容。例如查找(find)、匹配(search)、计数(count)、巡防(for_each)、比较(equal,mismatch)、寻找极值(max,min)等算法。
2、数值算法
欲使用数值算法,客户端必须包含表头<numeric>,SGI将数值算法实现于<stl_numeric.h>文件中。常见的数值算法有accumulate、adjacent_difference、inner_product、partial_sum、power、iota等。
3、accumulate
算法accumulate用来计算init和[first,last)内所有元素的总和。注意:一定要提供一个初始值init,这么做是当[first,last)区间为空时仍能获得一个明确定义的值。
template <class InputIterator, class T>
T accumulate(InputIterator first, InputIterator last, T init) {
for ( ; first != last; ++first)
init = init + *first;
return init;
}
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;
}
4、adjacent_difference
算法adjacent_difference用来计算[first,last)中相邻元素的差额。它会将*first赋值给result,并针对[first+1,last)内的每个迭代器i,将*i-*(i-1)之值赋值给*(result+(i-first))。如果采用就地(in place)运算方式,也就是令result等于first,在这种情况下它是一个质变算法。
第一个版本使用operator-来计算差额,第二版本采用外界提供的二元仿函数。第一版本针对[first+1,last)中的每个迭代器i,将*i-*(i-1)之值赋值给*(result+(i-first)),第二个版本则是将binary_op(*i,*(i-1))的运算结果赋值给*(result+(i-first))。
template <class InputIterator, class OutputIterator, class T>
OutputIterator __adjacent_difference(InputIterator first, InputIterator last,
OutputIterator result, T*) {
T value = *first;
while (++first != last) {
T tmp = *first;
*++result = tmp - value;
value = tmp;
}
return ++result;
}
template <class InputIterator, class OutputIterator>
OutputIterator adjacent_difference(InputIterator first, InputIterator last,
OutputIterator result) {
if (first == last) return result;
*result = *first;
return __adjacent_difference(first, last, result, value_type(first));
}
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);
}
5、inner_product
算法inner_product能够计算[first1,last1)和[first2,first2+(last1-first1))的一般内积。注意:一定要提供一个初始值init,这么做是当[first,last)区间为空时仍能获得一个明确定义的值。
第一个版本会将两个区间的内积结果加上init,先将结果初始化为init,然后针对[first1,last1)的每个迭代器i,由头至尾依序执行result=result+(*i)*(*(first2+(i-first1)))。第二版本是以外界提供的仿函数来取代operator+和operator*,先将结果初始化为init,然后针对[first1,last1)的每个迭代器i,由头至尾依序执行result=binary_op1(result,binary_op2(*i,*(first2+(i-first1)))。
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;
}
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;
}
6、partial_sum
算法partial_sum用来计算局部总和。如果采用就地(in place)运算方式,也就是令result等于first,在这种情况下它是一个质变算法。运算中的总和首先初始化为*first,然后赋值给*result。对于[first+1,last)中的每个迭代器i,从头至尾依序执行sum=sum+*i或sum=binary_op(sum,*i),然后再将sum赋值给*(result+(i-first))。本算法返回输出区间的最尾端位置:result+(last-first)。
template <class InputIterator, class OutputIterator, class T>
OutputIterator __partial_sum(InputIterator first, InputIterator last,
OutputIterator result, T*) {
T value = *first;
while (++first != last) {
value = value + *first;
*++result = value;
}
return ++result;
}
template <class InputIterator, class OutputIterator>
OutputIterator partial_sum(InputIterator first, InputIterator last,
OutputIterator result) {
if (first == last) return result;
*result = *first;
return __partial_sum(first, last, result, value_type(first));
}
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);
}
7、power
power算法由SGI专属,并不在STL标准之列。它是用来计算某数的n幂次方。运算类型可由外界指定,如果指定为乘法,那就是乘幂,当n>=0时返回x^n。
这里使用了快速幂算法,简化后算法:
template <class T, class Integer, class MonoidOperation>
T power(T x, Integer n, MonoidOperation op) {
if (n == 0)
return identity_element(op);
else {
T result = 1;
while (n != 0) {
if ((n & 1) != 0)
result = op(result, x);
x = op(x, x);
n >>= 1;
}
return result;
}
}
template <class T, class Integer, class MonoidOperation>
T power(T x, Integer n, MonoidOperation op) {
if (n == 0)
return identity_element(op);
else {
while ((n & 1) == 0) {
n >>= 1;
x = op(x, x);
}
T result = x;
n >>= 1;
while (n != 0) {
x = op(x, x);
if ((n & 1) != 0)
result = op(result, x);
n >>= 1;
}
return result;
}
}
template <class T, class Integer>
inline T power(T x, Integer n) {
return power(x, n, multiplies<T>());
}
8、iota
iota算法由SGI专属,并不在STL标准之列。它用来设定某个区间的内容,使其内的每个元素从指定的value值开始,呈现递增状态。
template <class ForwardIterator, class T>
void iota(ForwardIterator first, ForwardIterator last, T value) {
while (first != last) *first++ = value++;
}