整理下STL algorithms（4）

merge：

template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator merge ( InputIterator1 first1, InputIterator1 last1,
                         InputIterator2 first2, InputIterator2 last2,
                         OutputIterator result );

template <class InputIterator1, class InputIterator2,
          class OutputIterator, class Compare>
  OutputIterator merge ( InputIterator1 first1, InputIterator1 last1,
                         InputIterator2 first2, InputIterator2 last2,
                         OutputIterator result, Compare comp );

合并两个有序序列，添加到result中~~注意两个序列要都是有序的

相当于如下代码的工作：

template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator merge ( InputIterator1 first1, InputIterator1 last1,
                         InputIterator2 first2, InputIterator2 last2,
                         OutputIterator result )
{
  while (true) {
    *result++ = (*first2<*first1)? *first2++ : *first1++;
    if (first1==last1) return copy(first2,last2,result);
    if (first2==last2) return copy(first1,last1,result);
  }
}

与之相似的是inplace_merge:

template <class BidirectionalIterator>
  void inplace_merge ( BidirectionalIterator first, BidirectionalIterator middle,
                       BidirectionalIterator last );

template <class BidirectionalIterator, class Compare>
  void inplace_merge ( BidirectionalIterator first, BidirectionalIterator middle,
                       BidirectionalIterator last, Compare comp );

inplace_merge合并一个中前后两段分别有序的序列，即[first,middle)与[middle,last)分别有序，合并这两个子序列，并把结果保存在[first,last）中。

includes:

template <class InputIterator1, class InputIterator2>
  bool includes ( InputIterator1 first1, InputIterator1 last1,
                  InputIterator2 first2, InputIterator2 last2 );

template <class InputIterator1, class InputIterator2, class Compare>
  bool includes ( InputIterator1 first1, InputIterator1 last1,
                  InputIterator2 first2, InputIterator2 last2, Compare comp );
测试[first2,last2)是否是[first1,last1)的子序列，注意这两个序列都是有序的~~

set_union:

<algorithm>

template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_union ( InputIterator1 first1, InputIterator1 last1,
                             InputIterator2 first2, InputIterator2 last2,
                            OutputIterator result );

template <class InputIterator1, class InputIterator2,
          class OutputIterator, class Compare>
  OutputIterator set_union ( InputIterator1 first1, InputIterator1 last1,
                             InputIterator2 first2, InputIterator2 last2,
                             OutputIterator result, Compare comp );
将两个有序序列去并集，将结果存放在result中，返回值是result的end~

相应的取交集的算法是set_intersection:


// set_intersection example
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int main () {
  int first[] = {5,10,15,20,25};
  int second[] = {50,40,30,20,10};
  vector<int> v(10);                           // 0  0  0  0  0  0  0  0  0  0
  vector<int>::iterator it;

  sort (first,first+5);     //  5 10 15 20 25
  sort (second,second+5);   // 10 20 30 40 50

  it=set_intersection (first, first+5, second, second+5, v.begin());
                                               // 10 20 0  0  0  0  0  0  0  0

  cout << "intersection has " << int(it - v.begin()) << " elements.\n";

  return 0;
}

结果：intersection has 2 elements


set_difference:

template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_difference ( InputIterator1 first1, InputIterator1 last1,
                                  InputIterator2 first2, InputIterator2 last2,
                                  OutputIterator result );

template <class InputIterator1, class InputIterator2,
          class OutputIterator, class Compare>
  OutputIterator set_difference ( InputIterator1 first1, InputIterator1 last1,
                                  InputIterator2 first2, InputIterator2 last2,
                                  OutputIterator result, Compare comp );

set_difference()算法计算两个集合[start1, end1)和[start2, end2)的差集, 并将差集存放到result.
两个集合以序列的形式给出, 且必须先按升序排好位置.
set_difference()是一个指向result序列末尾的迭代器.




template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator
    set_symmetric_difference ( InputIterator1 first1, InputIterator1 last1,
                               InputIterator2 first2, InputIterator2 last2,
                               OutputIterator result );

template <class InputIterator1, class InputIterator2,
          class OutputIterator, class Compare>
  OutputIterator
    set_symmetric_difference ( InputIterator1 first1, InputIterator1 last1,
                               InputIterator2 first2, InputIterator2 last2,
                               OutputIterator result, Compare comp );


set_symmetric_difference()算法计算两个集合[start1, end1)和[start2, end2)的对称差, 并将差集储存到result中.
两个集合以序列形式给出, 而且必须按升序排好位置.
set_symmetric_difference()的返回值为指向result末尾的迭代器.

make_heap:

template <class RandomAccessIterator>
  void make_heap ( RandomAccessIterator first, RandomAccessIterator last );

template <class RandomAccessIterator, class Compare>
  void make_heap ( RandomAccessIterator first, RandomAccessIterator last,
                   Compare comp );
函数make_heap()将给定的序列[start, end)转换成堆.
如果严格弱排序函数对象cmp被指定, 则在比较元素时应用此函数替代<操作符.

push_heap:

template <class RandomAccessIterator>
  void push_heap ( RandomAccessIterator first, RandomAccessIterator last );

template <class RandomAccessIterator, class Compare>
  void push_heap ( RandomAccessIterator first, RandomAccessIterator last,
                   Compare comp );
函数push_heap()将插入一个元素(被放置在end之前的最后一个元素)到堆中(定义在区间[start,''end-1)中).

pop_heap:

template <class RandomAccessIterator>
  void pop_heap ( RandomAccessIterator first, RandomAccessIterator last );

template <class RandomAccessIterator, class Compare>
  void pop_heap ( RandomAccessIterator first, RandomAccessIterator last,
                   Compare comp );
pop_heap:

template <class RandomAccessIterator>
  void pop_heap ( RandomAccessIterator first, RandomAccessIterator last );

template <class RandomAccessIterator, class Compare>
  void pop_heap ( RandomAccessIterator first, RandomAccessIterator last,
                   Compare comp );
该算法将第一个元素（堆最大元素）放到last-1的位置，并对[first,last-1)之间的元素进行重新调整，成堆序列

sort_heap:

template <class RandomAccessIterator>
  void sort_heap ( RandomAccessIterator first, RandomAccessIterator last );

template <class RandomAccessIterator, class Compare>
  void sort_heap ( RandomAccessIterator first, RandomAccessIterator last,
                   Compare comp );
将堆转换为有序队列~~

另外还有几个：

lexicographical_compare	按字典顺序检查一个序列是否小于另外一个序列

min	返回两个元素间的较小者

max	返回两个元素间的较大者

max_element	返回序列中的最大者

min_element	返回序列中的最小者

next_permutation	依照字典顺序生成序列的下一个稍大的排列

prev_permutation	依照字典顺序生成序列的下一个稍小的排列