STL算法_数值算法篇

STL算法_数值算法篇

1）accumulate算法：用来计算初始值init和[first,last)内所有元素的总和。

// 计算init和[first,last)内所有元素的总和
// 版本1
template <class _InputIterator, class _Tp>
_Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
{
  __STL_REQUIRES(_InputIterator, _InputIterator);
  for ( ; __first != __last; ++__first)
    __init = __init + *__first;     // 将每个元素值累加到初始init身上
  return __init;
}
// 版本2
template <class _InputIterator, class _Tp, class _BinaryOperation>
_Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
               _BinaryOperation __binary_op)
{
  __STL_REQUIRES(_InputIterator, _InputIterator);
  for ( ; __first != __last; ++__first)
    __init = __binary_op(__init, *__first);    // 对每个元素执行二元操作
  return __init;
}

2）adjacent_difference算法：用来计算[first,last)中相邻元素的差额。

// adjacent_difference算法用来计算[first,last)中相邻元素的差额。
// 版本1
template <class _InputIterator, class _OutputIterator, class _Tp>
_OutputIterator 
__adjacent_difference(_InputIterator __first, _InputIterator __last,
                      _OutputIterator __result, _Tp*)
{
  _Tp __value = *__first;
  while (++__first != __last) {      // 走过整个区间
    _Tp __tmp = *__first;
    *++__result = __tmp - __value;   // 将相邻两元素的差额（后-前），赋值给目的端
    __value = __tmp;
  }
  return ++__result;
}

template <class _InputIterator, class _OutputIterator>
_OutputIterator
adjacent_difference(_InputIterator __first,
                    _InputIterator __last, _OutputIterator __result)
{
  __STL_REQUIRES(_InputIterator, _InputIterator);
  __STL_REQUIRES(_OutputIterator, _OutputIterator);
  if (__first == __last) return __result;
  *__result = *__first;   // 首先记录第一个元素
  return __adjacent_difference(__first, __last, __result,
                               __VALUE_TYPE(__first));
}
// 版本2
template <class _InputIterator, class _OutputIterator, class _Tp, 
          class _BinaryOperation>
_OutputIterator
__adjacent_difference(_InputIterator __first, _InputIterator __last, 
                      _OutputIterator __result, _Tp*,
                      _BinaryOperation __binary_op) {
  _Tp __value = *__first;
  while (++__first != __last) {                 // 走过整个区间
    _Tp __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)
{
  __STL_REQUIRES(_InputIterator, _InputIterator);
  __STL_REQUIRES(_OutputIterator, _OutputIterator);
  if (__first == __last) return __result;
  *__result = *__first;
  return __adjacent_difference(__first, __last, __result,
                               __VALUE_TYPE(__first),
                               __binary_op);
}

3）inner_product算法：计算[frist1,last1)和[first2,first2+(last1-first1))的一般内积。

// inner_product算法用来计算[first2,last1)和[first2,first2+(last1-first1))的一般内积
// 版本1
template <class _InputIterator1, class _InputIterator2, class _Tp>
_Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
                  _InputIterator2 __first2, _Tp __init)
{
  __STL_REQUIRES(_InputIterator2, _InputIterator);
  __STL_REQUIRES(_InputIterator2, _InputIterator);
  // 以第一个序列之元素个数为据，将两个序列都走一遍
  for ( ; __first1 != __last1; ++__first1, ++__first2)   
    __init = __init + (*__first1 * *__first2);           // 执行两个序列的一般内积
  return __init;
}
// 版本2
template <class _InputIterator1, class _InputIterator2, class _Tp,
          class _BinaryOperation1, class _BinaryOperation2>
_Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
                  _InputIterator2 __first2, _Tp __init, 
                  _BinaryOperation1 __binary_op1,
                  _BinaryOperation2 __binary_op2)
{
  __STL_REQUIRES(_InputIterator2, _InputIterator);
  __STL_REQUIRES(_InputIterator2, _InputIterator);
  // 以第一个序列之元素个数为据，将两个序列都走一遍
  for ( ; __first1 != __last1; ++__first1, ++__first2) 
    // 以外界提供的仿函数来取代第一版本中的operator*和operator+                  
    __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));   
  return __init;
}

4）partial_sum算法：用来计算局部求和。

// partial_sum算法用来计算局部总和
// 版本1
template <class _InputIterator, class _OutputIterator, class _Tp>
_OutputIterator 
__partial_sum(_InputIterator __first, _InputIterator __last,
              _OutputIterator __result, _Tp*)
{
  _Tp __value = *__first;
  while (++__first != __last) {
    __value = __value + *__first;    // 前n个元素的总和
    *++__result = __value;           // 指定给目的端
  }
  return ++__result;
}
template <class _InputIterator, class _OutputIterator>
_OutputIterator 
partial_sum(_InputIterator __first, _InputIterator __last,
            _OutputIterator __result)
{
  __STL_REQUIRES(_InputIterator, _InputIterator);
  __STL_REQUIRES(_OutputIterator, _OutputIterator);
  if (__first == __last) return __result;
  *__result = *__first;
  return __partial_sum(__first, __last, __result, __VALUE_TYPE(__first));
}
// 版本2
template <class _InputIterator, class _OutputIterator, class _Tp,
          class _BinaryOperation>
_OutputIterator 
__partial_sum(_InputIterator __first, _InputIterator __last, 
              _OutputIterator __result, _Tp*, _BinaryOperation __binary_op)
{
  _Tp __value = *__first;
  while (++__first != __last) {
    __value = __binary_op(__value, *__first);    // 前n个元素的总和
    *++__result = __value;                       // 指定给目的端
  }
  return ++__result;
}
template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
_OutputIterator 
partial_sum(_InputIterator __first, _InputIterator __last,
            _OutputIterator __result, _BinaryOperation __binary_op)
{
  __STL_REQUIRES(_InputIterator, _InputIterator);
  __STL_REQUIRES(_OutputIterator, _OutputIterator);
  if (__first == __last) return __result;
  *__result = *__first;
  return __partial_sum(__first, __last, __result, __VALUE_TYPE(__first), 
                       __binary_op);
}

5）power算法：用来计算某数的n幂次方。这里n幂次是指对自己进行某种运算，达n次。

// power算法用来计算某数的n幂次方。n幂次是指自己对自己进行某种运算，达n次。
// 幂次方。如果指定为乘法运算，则当n>=0时，返回x^n
// 注意：MonoidOperation必须满足结合律，但不需满足交换律
// 版本2
template <class _Tp, class _Integer, class _MonoidOperation>
_Tp __power(_Tp __x, _Integer __n, _MonoidOperation __opr)
{
  if (__n == 0)
    return identity_element(__opr);       // 取出“证同元素"identity element"
  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;
  }
}
// power算法用来计算某数的n幂次方。n幂次是指自己对自己进行某种运算，达n次。
// 版本1
template <class _Tp, class _Integer>
inline _Tp __power(_Tp __x, _Integer __n)
{
  return __power(__x, __n, multiplies<_Tp>());   // 指定运算形式为乘法
}

// Alias for the internal name __power.  Note that power is an extension,
// not part of the C++ standard.

template <class _Tp, class _Integer, class _MonoidOperation>
inline _Tp power(_Tp __x, _Integer __n, _MonoidOperation __opr)
{
  return __power(__x, __n, __opr);
}

template <class _Tp, class _Integer>
inline _Tp power(_Tp __x, _Integer __n)
{
  return __power(__x, __n);
}

6）iota算法：用来设定某个区间的内容，使其内的每一个元素从指定的value值开始，呈现递增状态。它改变了区间的内容，所以是一种质变算法。

// iota算法用来设定某个区间的内容，使其内的每个元素从指定的value值开始，呈现递增状态。他改变了区间内容，所以是一种质变算法
template <class _ForwardIter, class _Tp>
void 
iota(_ForwardIter __first, _ForwardIter __last, _Tp __value)
{
  __STL_REQUIRES(_ForwardIter, _Mutable_ForwardIterator);
  __STL_CONVERTIBLE(_Tp, typename iterator_traits<_ForwardIter>::value_type);
  while (__first != __last)
    *__first++ = __value++;   // 在[first,last)区间内填入value,value+1,...
}

• 参考文献

  STL源码剖析——侯捷

  STL源码程序