第22章 变易算法

//  第22章 变易算法

//   22.1 元素复制copy ---------------------------------------------------

template<class InputIterator, class OutputIterator>
  OutputIterator copy ( InputIterator first, InputIterator last, OutputIterator result )
{
  while (first!=last) *result++ = *first++;
  return result;
}

// 把序列一中某范围内的元素，复制到序列二中去。前两个参数是序列一范围，第三个参数是序列二的开始位置
// 当序列二不够大时，不够装部分将复制不过去。


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

int main () {
  int myints[]={10,20,30,40,50,60,70};
  vector<int> myvector;
  vector<int>::iterator it;

  myvector.resize(7);   // allocate space for 7 elements
                        // 如7改成5，将只复制前5个元素
  copy ( myints, myints+7, myvector.begin() );

  cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}


// 304
#include <algorithm>
#include <vector>
#include <list>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << "  ";
}
int main(void)
{
  //初始化向量v
  vector < int > v;
  v.push_back(1);
  v.push_back(3);
  v.push_back(5);
  //初始化双向链表l
  list < int > l;
  l.push_back(2);
  l.push_back(4);
  l.push_back(6);
  l.push_back(8);
  l.push_back(10);
  //复制v到l
  copy(v.begin(), v.end(), l.begin());
  //链表l打印l 3 5 8 10
  for_each(l.begin(), l.end(), print);
  cout << endl;
  return 0;
}

//   22.2 反向复制copy_backward ---------------------------------------------------

template<class BidirectionalIterator1, class BidirectionalIterator2>
  BidirectionalIterator2 copy_backward ( BidirectionalIterator1 first,
                                         BidirectionalIterator1 last,
                                         BidirectionalIterator2 result )
{
  while (last!=first) *(--result) = *(--last);
  return result;
}

// 把序列一中某范围内的元素，复制到序列二中去。前两个参数是序列一范围，第三个参数是序列二的结束位置的下一个位置。
// 两序列可以是同一序列

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

int main () {
  vector<int> myvector;
  vector<int>::iterator it;

  // set some values:
  for (int i=1; i<=5; i++)
    myvector.push_back(i*10);          // myvector: 10 20 30 40 50

  myvector.resize(myvector.size()+3);  // allocate space for 3 more elements

  copy_backward ( myvector.begin(), myvector.begin()+5, myvector.end() );

  cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}


//306 始终是左闭右开区间操作
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;

void print(int x)
{
  cout << x << ‘ ‘;
}

int main(void)
{
  vector < int > v(10);
  for(unsigned int i = 0; i < v.size(); i++)
    v[i] = i + 1;  // 1 2 3 4 5 6 7 8 9 10
  copy_backward(v.begin(), v.begin() + 3, v.end());
  for_each(v.begin(), v.end(), print);
  cout << endl;    // 1 2 3 4 5 6 7 1 2 3
  return 0;
}

//   22.3 元素交换swap ---------------------------------------------------

template <class T> void swap ( T& a, T& b )
{
  T c(a); a=b; b=c;
}
// 不通过指针交换两个元素


// swap algorithm example。只要是同一类型的，统统交换
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int main () {

  int x=10, y=20;                         // x:10 y:20
  swap(x,y);                              // x:20 y:10

  vector<int> first (4,x), second (6,y);  // first:4x20 second:6x10
  swap(first,second);                     // first:6x10 second:4x20

  cout << "first contains:";
  for (vector<int>::iterator it=first.begin(); it!=first.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}



//307
#include <algorithm>
#include <iostream>
int main(void)
{
  using namespace std;
  int a = 5;
  int b = 26;
  cout << "交换前 " << "a = " << a << " b = " << b << endl;
  swap(a, b);
  cout << "交换后 " << "a = " << a << " b = " << b << endl;
  return 0;
}

//   22.4 迭代器交换iter_swap ---------------------------------------------------

template <class ForwardIterator1, class ForwardIterator2>
  void iter_swap ( ForwardIterator1 a, ForwardIterator2 b )
{
  swap (*a, *b);
}
// 利用指针（迭代器）交换值



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

int main () {

  int myints[]={10,20,30,40,50 };          //   myints:  10  20  30  40  50
  vector<int> myvector (4,99);             // myvector:  99  99  99  99

  iter_swap(myints,myvector.begin());      //   myints: [99] 20  30  40  50
                                           // myvector: [10] 99  99  99

  iter_swap(myints+3,myvector.begin()+2);  //   myints:  99  20  30 [99]
                                           // myvector:  10  99 [40] 99

  cout << "myvector contains:";
  for (vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}


// 307
#include <algorithm>
#include <iostream>
int main(void)
{
  using namespace std;
  int a = 5;
  int b = 26;
  cout << "交换前 " << "a = " << a << " b = " << b << endl;
  iter_swap(&a, &b);
  cout << "交换后 " << "a = " << a << " b = " << b << endl;
  return 0;
}

//   22.5 区间元素交换swap_ranges ---------------------------------------------------

template<class ForwardIterator1, class ForwardIterator2>
  ForwardIterator2 swap_ranges ( ForwardIterator1 first1, ForwardIterator1 last1,
                                 ForwardIterator2 first2 )
{
  while (first1!=last1) swap(*first1++, *first2++);
  return first2;
}
// 两个区间中的元素分别交换。只有三个参数，第四个参数又省了
// 注意：第二个序列要足够长，否则会出现异常，见下面第二个程序。


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

int main () {
  vector<int> first (5,10);        //  first: 10 10 10 10 10
  vector<int> second (5,33);       // second: 33 33 33 33 33
  vector<int>::iterator it;

  swap_ranges(first.begin()+1, first.end()-1, second.begin());

  // print out results of swap:
  cout << " first contains:";
  for (it=first.begin(); it!=first.end(); ++it)
    cout << " " << *it;

  cout << "\nsecond contains:";
  for (it=second.begin(); it!=second.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}



// swap_ranges example. my test：请观察输出结果，当第二个序列不够长时，交换到第一个序列的，不是希望的值！
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int main () {
  vector<int> first (5,10);        //  first: 10 10 10 10 10
  vector<int> second (2,33);       // second: 33 33
  vector<int>::iterator it;

  swap_ranges(first.begin()+1, first.end()-1, second.begin());

  // print out results of swap:
  cout << " first contains:";
  for (it=first.begin(); it!=first.end(); ++it)
    cout << " " << *it;

  cout << "\nsecond contains:";
  for (it=second.begin(); it!=second.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}


//308
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << " ";
}

int main(void)
{
  vector < int > v1, v2;
  v1.push_back(1);
  v1.push_back(3);
  v1.push_back(5);
  v2.push_back(2);
  v2.push_back(4);
  v2.push_back(6);
  //打印v1、v2
  cout << "交换前, v1=";
  for_each(v1.begin(), v1.end(), print);
  cout << "v2=";
  for_each(v2.begin(), v2.end(), print);
  cout << endl;
  //交换v1、v2
  swap_ranges(v1.begin(), v1.end(), v2.begin());
  //打印v1、v2
  cout << "交换后, v1=";
  for_each(v1.begin(), v1.end(), print);
  cout << "v2=";
  for_each(v2.begin(), v2.end(), print);
  cout << endl;
  return 0;
}

//   22.6 元素变换transform ---------------------------------------------------

template < class InputIterator, class OutputIterator, class UnaryOperator >
  OutputIterator transform ( InputIterator first1, InputIterator last1,
                             OutputIterator result, UnaryOperator op )
{
  while (first1 != last1)
    *result++ = op(*first1++);  // or: *result++=binary_op(*first1++,*first2++);
  return result;
}
// 加转换的copy。而且转换函数可以是一元的，也可以是二元的。
// 一元的参数有四个：开始两个表示第一序列范围，第三个是结果存放开始位置，第四个是一元函数（对象）
// 二元的参数有五个：开始两个表示第一序列范围，第三个是第二序列开始位置，第四个是结果存放开始位置，第五个是二元函数（对象）



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

int op_increase (int i) { return ++i; }
int op_sum (int i, int j) { return i+j; }

int main () {
  vector<int> first;
  vector<int> second;
  vector<int>::iterator it;

  // set some values:
  for (int i=1; i<6; i++) first.push_back (i*10); //  first: 10 20 30 40 50

  second.resize(first.size());     // allocate space
  transform (first.begin(), first.end(), second.begin(), op_increase); // 四个参数
                                                  // second: 11 21 31 41 51

  transform (first.begin(), first.end(), second.begin(), first.begin(), op_sum); // 五个参数
                                                  //  first: 21 41 61 81 101

  cout << "first contains:";
  for (it=first.begin(); it!=first.end(); ++it)
    cout << " " << *it;

  cout << endl;
  return 0;
}


// 309
#include <algorithm>
#include <vector>
#include <list>
#include <iostream>
using namespace std;
int square(int x)
{
  return x *x;
}
void print(int x)
{
  cout << x << "  ";
}
int main(void)
{
  //vector初始化    
  vector < int > v;
  v.push_back(5);
  v.push_back(15);
  v.push_back(25);
  //list初始化
  list < int > l(3);
  //对vector容器元素执行平方运算，放入list容器
  transform(v.begin(), v.end(), l.begin(), square);
  //打印链表元素
  for_each(l.begin(), l.end(), print);
  cout << endl;
  return 0;
}

//   22.7 替换 ---------------------------------------------------


template < class ForwardIterator, class T >
  void replace ( ForwardIterator first, ForwardIterator last,
                 const T& old_value, const T& new_value )
{
  for (; first != last; ++first)
    if (*first == old_value) *first=new_value;
}
// 在指定范围内旧值换新值




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

int main () {
  int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };
  vector<int> myvector (myints, myints+8);            // 10 20 30 30 20 10 10 20

  replace (myvector.begin(), myvector.end(), 20, 99); // 10 99 30 30 99 10 10 99

  cout << "myvector contains:";
  for (vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;
 
  return 0;
}


//311
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << "  ";
}
int main(void)
{
  vector < int > v;
  v.push_back(13);
  v.push_back(25);
  v.push_back(27);
  v.push_back(25);
  v.push_back(29);
  //将v的25全部替换为100
  replace(v.begin(), v.end(), 25, 100);
  cout << "v向量元素: ";
  for_each(v.begin(), v.end(), print);
  cout << endl;
  //将iArray的5全部替换为200
  int iArray[7] = {3, 6, 5, 9, 5, 5, 10};
  replace(iArray, iArray + 7, 5, 200);
  cout << "数组iArray元素: ";
  for_each(iArray, iArray + 7, print);
  cout << endl;
  return 0;
}

//   22.8 条件替换replace_if ---------------------------------------------------


template < class ForwardIterator, class Predicate, class T >
  void replace_if ( ForwardIterator first, ForwardIterator last,
                    Predicate pred, const T& new_value )
{
  for (; first != last; ++first)
    if (pred(*first)) *first=new_value;
}
// 当元素满足什么条件时，更新为新值



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

bool IsOdd (int i) { return ((i%2)==1); }

int main () {
  vector<int> myvector;
  vector<int>::iterator it;

  // set some values:
  for (int i=1; i<10; i++) myvector.push_back(i);          // 1 2 3 4 5 6 7 8 9
  
  replace_if (myvector.begin(), myvector.end(), IsOdd, 0); // 0 2 0 4 0 6 0 8 0
                                                           // 把奇数都替换为0
  cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;
 
  return 0;
}



// 312

#include <algorithm>
#include <vector>
#include <iostream>
bool odd(int x)
{
  return x % 2;
}
int main(void)
{
  using namespace std;
  vector < int > v(10);
  unsigned int i;
  for(i = 0; i < v.size(); i++)
  {
    v[i] = i % 7;
    cout << v[i] << ‘ ‘;
  }
  cout << endl;
  //将奇数元素替换为38
  replace_if(v.begin(), v.end(), odd, 38);
  for(i = 0; i < v.size(); i++)
    cout << v[i] << ‘ ‘;
  cout << endl;
  return 0;
}

//   22.9 替换和复制replace_copy ---------------------------------------------------


template < class InputIterator, class OutputIterator, class T >
  OutputIterator replace_copy ( InputIterator first, InputIterator last,
                                OutputIterator result, const T& old_value, const T& new_value )
{
  for (; first != last; ++first, ++result)
    *result = (*first==old_value)? new_value: *first;
  return result;
}
// 将第一序列某范围内的元素，复制到第二序列中去。在这个复制过程中，将旧值，替换为新值
// 前两个参数表示第一序列范围，第三个参数为第二序列开始位置（木有结束位置），第四、五个参数为旧、新值


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

int main () {
  int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };

  vector<int> myvector (8);
  replace_copy (myints, myints+8, myvector.begin(), 20, 99);

  cout << "myvector contains:";
  for (vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;
 
  return 0;
}


// 313
#include <algorithm>
#include <list>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << ‘ ‘;
}
int main(void)
{
  list < int > l1;
  l1.push_back(1);
  l1.push_back(3);
  l1.push_back(1);
  l1.push_back(6);
  l1.push_back(8);
  //将l1链表元素1替换为100，然后拷贝到l2链表
  list < int > l2(5);
  replace_copy(l1.begin(), l1.end(), l2.begin(), 1, 100);
  cout << "l1保持不变: ";
  for_each(l1.begin(), l1.end(), print);
  cout << "\nl2元素为: ";
  for_each(l2.begin(), l2.end(), print);
  cout << endl;
  return 0;
}

//   22.10 条件替换和复制replace_copy_if ---------------------------------------------------


template < class InputIterator, class OutputIterator, class Predicate, class T >
  OutputIterator replace_copy_if ( InputIterator first, InputIterator last,
                                   OutputIterator result, Predicate pred,
                                   const T& new_value )
{
  for (; first != last; ++first, ++result)
    *result = (pred(*first))? new_value: *first;
  return result;
}
// replace_copy的谓词判断版本。 木有旧值了，替换为一个谓词。这样应用范围更广



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

bool IsOdd (int i) { return ((i%2)==1); }

int main () {
  vector<int> first,second;
  vector<int>::iterator it;

  // set some values:
  for (int i=1; i<10; i++) first.push_back(i);          // 1 2 3 4 5 6 7 8 9

  second.resize(first.size());   // allocate space
  replace_copy_if (first.begin(), first.end(), second.begin(), IsOdd, 0);
                                                        // 0 2 0 4 0 6 0 8 0

  cout << "second contains:";
  for (it=second.begin(); it!=second.end(); ++it)
    cout << " " << *it;

  cout << endl;
 
  return 0;
}


// 314
#include <algorithm>
#include <vector>
#include <list>
#include <iostream>
using namespace std;

bool odd(int x)
{
  return x % 2;
}

int main(void)
{
  using namespace std;
  vector < int > v(10);
  unsigned int i;
  for(i = 0; i < v.size(); i++)
  {
    v[i] = i % 7;
    cout << v[i] << ‘ ‘;
  }
  cout << endl;
  //将向量v中奇数元素替换为38后,拷贝到链表l
  list < int > l(10);
  replace_copy_if(v.begin(), v.end(), l.begin(), odd, 38);
  list < int > ::iterator list_iter;
  for(list_iter = l.begin(); list_iter != l.end(); list_iter++)
    cout <<  *list_iter << ‘ ‘;
  cout << endl;
  return 0;
}

//   22.11 填充fill ---------------------------------------------------


template < class ForwardIterator, class T >
  void fill ( ForwardIterator first, ForwardIterator last, const T& value )
{
  while (first != last)  *first++ = value;
}
// 在序列范围内，均填充上某新值。


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

int main () {
  vector<int> myvector (8);                       // myvector: 0 0 0 0 0 0 0 0

  fill (myvector.begin(),myvector.begin()+4,5);   // myvector: 5 5 5 5 0 0 0 0
  fill (myvector.begin()+3,myvector.end()-2,8);   // myvector: 5 5 5 8 8 8 0 0

  cout << "myvector contains:";
  for (vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;
 
  return 0;
}


//315
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << ‘ ‘;
}
int main(void)
{
  vector < int > v(5);
  fill(v.begin(), v.end(), 30);
  for_each(v.begin(), v.end(), print);
  cout << endl;
  return 0;
}

//   22.12 n次填充fill_n ---------------------------------------------------


template < class OutputIterator, class Size, class T >
  void fill_n ( OutputIterator first, Size n, const T& value )
{
  for (; n>0; --n)  *first++ = value;
}
// 在起始位置开始，填充n个value。三个参数：起始位置、几个、新值。



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

int main () {
  vector<int> myvector (8,10);        // myvector: 10 10 10 10 10 10 10 10

  fill_n (myvector.begin(),4,20);     // myvector: 20 20 20 20 10 10 10 10
  fill_n (myvector.begin()+3,3,33);   // myvector: 20 20 20 33 33 33 10 10

  cout << "myvector contains:";
  for (vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;
 
  return 0;
}


//315
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << ‘ ‘;
}
int main(void)
{
  vector < int > v(8);
  fill(v.begin(), v.end(), 1);
  //前5个元素填充为2
  fill_n(v.begin(), 5, 2);
  for_each(v.begin(), v.end(), print);
  cout << endl;
  //全部填充为3
  fill_n(v.begin(), v.size(), 3);
  for_each(v.begin(), v.end(), print);
  cout << endl;
  return 0;
}

//   22.13 随机生成元素generate ---------------------------------------------------



template <class ForwardIterator, class Generator>
  void generate ( ForwardIterator first, ForwardIterator last, Generator gen )
{
  while (first != last)  *first++ = gen();
}
// 在指定范围内，填充上第三个参数gen产生的值。
// gen是个函数（对象），木有参数。所以产生的值，纯粹取决于gen，与容器原来的元素无关



// generate algorithm example
#include <iostream>
#include <algorithm>
#include <vector>
#include <ctime>
#include <cstdlib>
using namespace std;

// function generator:
int RandomNumber () { return (rand()%100); } // 产生一百以内的随机数

// class generator:
struct c_unique {
  int current;
  c_unique() {current=0;} // 构造函数，设成员current初始值为0
  int operator()() {return ++current;} // 调用操作符()重载，使此类能产生函数对象
} UniqueNumber;


int main () {
  srand ( unsigned ( time(NULL) ) );

  vector<int> myvector (8);
  vector<int>::iterator it;

  generate (myvector.begin(), myvector.end(), RandomNumber);

  cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  generate (myvector.begin(), myvector.end(), UniqueNumber);

  cout << "\nmyvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;
 
  return 0;
}


//316
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
//等差数列an+1=an + 3
class sequence
{
  public:
    int a;
    sequence(){ a = 0; } // 构造函数
    inline int operator()() // 重载()
    {
        //a = a + 3;
        //return a;
        return a+=3;
    }
};
void print(int x)
{
  cout << x << endl;
}

int main(void)
{
  vector < int > v(10);
  sequence an;
  generate(v.begin(), v.end(), an);
  for_each(v.begin(), v.end(), print);
  cout << endl;
  return 0;
}

//   22.14 随机生成n个元素generate_n ---------------------------------------------------


template <class OutputIterator, class Size, class Generator>
  void generate ( OutputIterator first, Size n, Generator gen )
{
  for (; n>0; --n)  *first++ = gen();
}
// 在开始位置之后，填充n个gen()产生的值。三个参数：起始位置、几个、gen产生的值。



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

int current(0);
int UniqueNumber () { return ++current; }

int main () {
  vector<int> myvector (9);
  vector<int>::iterator it;

  generate_n (myvector.begin(), 6, UniqueNumber); // 因为产生6个，后面几个仍是0

  cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;
 
  return 0;
}


//317
#include <algorithm>
#include <vector>
#include <iostream>
int main(void)
{
  using namespace std;
  vector < int > v(10);
  //生成3个伪随机数
  generate_n(v.begin(), 3, rand);
  for(unsigned int i = 0; i < v.size(); i++)
    cout << v[i] << ‘ ‘;
  cout << endl;
  return 0;
}

//   22.15 移除复制remove_copy ---------------------------------------------------

template <class InputIterator, class OutputIterator, class T>
  OutputIterator remove_copy ( InputIterator first, InputIterator last,
                               OutputIterator result, const T& value )
{
  for ( ; first != last; ++first)
    if (!(*first == value)) *result++ = *first;
  return result;
}
// 将容器中，不等于某值的元素，复制到另一容器中。
// 参数有四个：前两个表示范围，第三个是另一容器的起始位置，第四个是某值。
// 这样就产生了一个问题，另一容器，可以是同一容器么？可以的，请看下面第二个my test程序。



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

int main () {
  int myints[] = {10,20,30,30,20,10,10,20};          // 10 20 30 30 20 10 10 20
  vector<int> myvector (8);  // 如改成2，可以看到，容器不会自动扩充，只会复制进2个数。
  vector<int>::iterator it;

  remove_copy (myints,myints+8,myvector.begin(),20); // 10 30 30 10 10 0 0 0

  cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;
 
  return 0;
}



// remove_copy example。my test: 同一容器是可以的。
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int main () {
  int myints[] = {10,20,30,30,20,10,10,20};          // 10 20 30 30 20 10 10 20
  vector<int> myvector (myints,myints+8);
  vector<int>::iterator it;
                                                     // 10 30 30 10 10 [10 10 20
  remove_copy (myvector.begin(),myvector.end(),myvector.begin(),20); // 最后三个是原来的


  cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;
 
  return 0;
}


//318
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << "  ";
}
int main(void)
{
  vector < int > v;
  v.push_back(2);
  v.push_back(4);
  v.push_back(3);
  v.push_back(4);
  v.push_back(8);
  //
  int iArray[6]={0};
  //
  remove_copy(v.begin(), v.end(), iArray, 4);
  for_each(v.begin(), v.end(), print);
  cout << endl;
  //
  for_each(iArray, iArray + 6, print);
  cout << endl;
  return 0;
}

//   22.16 条件移除复制remove_copy_if ---------------------------------------------------


template <class InputIterator, class OutputIterator, class Predicate>
  OutputIterator remove_copy_if ( InputIterator first, InputIterator last,
                                  OutputIterator result, Predicate pred )
{
  for ( ; first != last; ++first)
    if (!pred(*first)) *result++ = *first;
  return result;
}
// remove_copy 的带谓词判断的版本。把第四个参数，改成了函数（对象）。



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

bool IsOdd (int i) { return ((i%2)==1); }

int main () {
  int myints[] = {1,2,3,4,5,6,7,8,9};          
  vector<int> myvector (9);
  vector<int>::iterator it;

  remove_copy_if (myints,myints+9,myvector.begin(),IsOdd); // 是奇数的，被删除

  cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;
 
  return 0;
}


// 319
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << "  ";
}
bool even(int x)
{
  //偶数
  return x % 2 ? 0 : 1;
}
int main(void)
{
  //初始化向量v
  vector < int > v;
  v.push_back(7);
  v.push_back(2);
  v.push_back(5);
  v.push_back(4);
  v.push_back(1);
  //初始化数组iArray
  int iArray[6] = {0};
  //移除v中偶数,剩余元素复制到iArray
  remove_copy_if(v.begin(), v.end(), iArray, even);
  //打印v,v没有改变
  for_each(v.begin(), v.end(), print);
  cout << endl;
  //打印iArray
  for_each(iArray, iArray + 6, print);
  cout << endl;
  return 0;
}

//   22.17 移除remove ---------------------------------------------------


template < class ForwardIterator, class T >
  ForwardIterator remove ( ForwardIterator first, ForwardIterator last, const T& value )
{
  ForwardIterator result = first;
  for ( ; first != last; ++first)
    if (!(*first == value)) *result++ = *first;
  return result;
}
// 将容器中等于某值的元素删除。
// 因为在同一容器中操作，所以返回值值得关注。返回排列完删除某些元素之后的序列的后一个位置。
// 如果要将数据复制到另一容器，可以考虑用remove_copy


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

int main () {
  int myints[] = {10,20,30,30,20,10,10,20};      // 10 20 30 30 20 10 10 20

  // bounds of range:
  int* pbegin = myints;                          // ^
  int* pend = myints+sizeof(myints)/sizeof(int); // ^                       ^

  pend = remove (pbegin, pend, 20);              // 10 30 30 10 10 10 10 20
                                                 // ^              ^
  cout << "range contains:";
  for (int* p=pbegin; p!=pend; ++p)
    cout << " " << *p;

  cout << endl;
 
  return 0;
}



// 321
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << "  ";
}
int main(void)
{
  //初始化向量v
  vector < int > v;
  v.push_back(2);
  v.push_back(4);
  v.push_back(3);
  v.push_back(4);
  v.push_back(8);
  //移除4
  vector < int > ::iterator result = remove(v.begin(), v.end(), 4);
  //打印2 3 8
  for_each(v.begin(), result, print);
  cout << endl;
  //打印2 3 8 4 8
  for_each(v.begin(), v.end(), print);
  cout << endl;
  return 0;
}

//   22.18 条件移除remove_if ---------------------------------------------------

template < class ForwardIterator, class Predicate >
  ForwardIterator remove_if ( ForwardIterator first, ForwardIterator last,
                              Predicate pred )
{
  ForwardIterator result = first;
  for ( ; first != last; ++first)
    if (!pred(*first)) *result++ = *first;
  return result;
}
// remove的谓词判断版本。 remove的第三个参数，改成了谓词判断。



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

bool IsOdd (int i) { return ((i%2)==1); }

int main () {
  int myints[] = {1,2,3,4,5,6,7,8,9};            // 1 2 3 4 5 6 7 8 9

  // bounds of range:
  int* pbegin = myints;                          // ^
  int* pend = myints+sizeof(myints)/sizeof(int); // ^                 ^

  pend = remove_if (pbegin, pend, IsOdd);        // 2 4 6 8 5 6 7 8 9
                                                 // ^       ^
  cout << "range contains:";
  for (int* p=pbegin; p!=pend; ++p)
    cout << " " << *p;

  cout << endl;
 
  return 0;
}



// 322
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << "  ";
}
bool even(int x)
{
  //偶数
  return x % 2 ? 0 : 1;
}
int main(void)
{
  //初始化向量v
  vector < int > v;
  v.push_back(7);
  v.push_back(2);
  v.push_back(5);
  v.push_back(4);
  v.push_back(1);
  //移除偶数
  vector < int > ::iterator result = remove_if(v.begin(), v.end(), even);
  //打印7 5 1
  for_each(v.begin(), result, print);
  cout << endl;
  //打印7 5 1 4 1
  for_each(v.begin(), v.end(), print);
  cout << endl;
  return 0;
}

//   22.19 不连续重复元素复制unique_copy ---------------------------------------------------


template <class InputIterator, class OutputIterator>
  OutputIterator unique_copy ( InputIterator first, InputIterator last,
                               OutputIterator result )
{
  *result=*first;
  while (++first != last)
  {
    if (!(*result == *first))  // or: if (!pred(*result,*first)) for the pred version
      *(++result)=*first; // 有点精巧，画图可明白。pred左参数，是左边那个与当前值不同那个元素，右参数是当前元素
  }
  return ++result; // 左闭右开原则，返回时要+1
}
// 将连续相等的元素过滤掉，只剩下一个
// 第四个参数可选，如有，是谓词判断的函数（对象）。这个谓词估计不常用。
// 第三个参数是输出的第一个位置。可以用同一容器，也可以用不同容器。

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

bool myfunction (int i, int j) {
  return (i==j);
}

int main () {
  int myints[] = {10,20,20,20,30,30,20,20,10};
  vector<int> myvector (9);                            // 0  0  0  0  0  0  0  0  0
  vector<int>::iterator it;

  // using default comparison:
  it=unique_copy (myints,myints+9,myvector.begin());   // 10 20 30 20 10 0  0  0  0
                                                       //                ^

  sort (myvector.begin(),it);                          // 10 10 20 20 30 0  0  0  0
                                                       //                ^

  // using predicate comparison:
  it=unique_copy (myvector.begin(), it, myvector.begin(), myfunction);
                                                       // 10 20 30 20 30 0  0  0  0
                                                       //          ^

  myvector.resize( it - myvector.begin() );            // 10 20 30

  // print out content:
  cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}


//323
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << ‘ ‘;
}
int main(void)
{
  vector < int > v;
  v.push_back(2);
  v.push_back(5);
  v.push_back(5);
  v.push_back(5);
  v.push_back(6);
  v.push_back(5);
  v.push_back(2);
  //
  int iArray[6] = { 0 };
  //
  unique_copy(v.begin(), v.end(), iArray);
  //打印2 5 6 5 2 0
  for_each(iArray, iArray + 6, print);
  cout << endl;
  return 0;
}

//   22.20 剔除连续重复元素unique ---------------------------------------------------


template <class ForwardIterator>
  ForwardIterator unique ( ForwardIterator first, ForwardIterator last )
{
  ForwardIterator result=first;
  while (++first != last)
  {
    if (!(*result == *first))  // or: if (!pred(*result,*first)) for the pred version
      *(++result)=*first;
  }
  return ++result;
}
// 将连续相等的元素过滤掉，只剩下一个。在同一容器操作。
// 第三个参数可无，如有是谓词判断函数（对象）



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

bool myfunction (int i, int j) {
  return (i==j);
}

int main () {
  int myints[] = {10,20,20,20,30,30,20,20,10};    // 10 20 20 20 30 30 20 20 10
  vector<int> myvector (myints,myints+9);
  vector<int>::iterator it;

  // using default comparison:
  it = unique (myvector.begin(), myvector.end()); // 10 20 30 20 10 30 20 20 10
                                                  //                ^

  myvector.resize( it - myvector.begin() );       // 10 20 30 20 10

  // using predicate comparison:
  unique (myvector.begin(), myvector.end(), myfunction);   // (no changes)

  // print out content:
  cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}


// 325
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << ‘ ‘;
}
int main(void)
{
  vector < int > v;
  v.push_back(2);
  v.push_back(6);
  v.push_back(6);
  v.push_back(6);
  v.push_back(9);
  v.push_back(6);
  v.push_back(3);
  //
  vector < int > ::iterator result = unique(v.begin(), v.end());
  //打印2 6 9 6 3
  for_each(v.begin(), result, print);
  cout << endl;
  //打印2 6 9 6 3 6 3
  for_each(v.begin(), v.end(), print);
  cout << endl;
  return 0;
}

//   22.21 元素反向reverse ---------------------------------------------------


template <class BidirectionalIterator>
  void reverse ( BidirectionalIterator first, BidirectionalIterator last)
{
  while ((first!=last)&&(first!=--last))
    swap (*first++,*last);
}
// 反转元素


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

int main () {
  vector<int> myvector;
  vector<int>::iterator it;

  // set some values:
  for (int i=1; i<10; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9

  reverse(myvector.begin(),myvector.end());       // 9 8 7 6 5 4 3 2 1

  // print out content:
  cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}


//326
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << ‘ ‘;
}

int main(void)
{
  vector < int > v(10);
  for(unsigned int i = 0; i < v.size(); i++)
    v[i] = i;
  for_each(v.begin(), v.end(), print);
  cout << endl;
  //
  reverse(v.begin(), v.end());
  for_each(v.begin(), v.end(), print);
  cout << endl;
  return 0;
}

//   22.22 反向复制reverse_copy ---------------------------------------------------


template <class BidirectionalIterator, class OutputIterator>
  OutputIterator reverse_copy ( BidirectionalIterator first,
                                BidirectionalIterator last, OutputIterator result )
{
  while (first!=last) *result++ = *--last;
  return result;
}

// 从后向前，复制到另一容器。
// 复制到同一容器，可以吗？ 请见以下第二个程序，my test。
// my test:复制到同一空间（范围），会产生冲突。复制到同一容器不同范围，木有关系。


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

int main () {
  int myints[] ={1,2,3,4,5,6,7,8,9};
  vector<int> myvector;
  vector<int>::iterator it;

  myvector.resize(9);

  reverse_copy (myints, myints+9, myvector.begin());

  // print out content:
  cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}



// reverse_copy example。 my test:复制到同一空间（范围），会产生冲突。复制到同一容器不同范围，木有关系。
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int main () {
  int myints[] ={1,2,3,4,5,6,7,8,9};
  vector<int> v(myints,myints+9);
  vector<int>::iterator it;
  
  reverse_copy(v.begin(),v.begin()+3,v.begin());

  // print out content:
  cout << "myvector contains:";
  for (it=v.begin(); it!=v.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}


// 327
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << ‘ ‘;
}
int main(void)
{
  vector < int > v(10);
  for(unsigned int i = 0; i < v.size(); i++)
    v[i] = i;
  //
  int iArray[10] = {0};
  //
  reverse_copy(v.begin(), v.end(), iArray);
  for_each(iArray, iArray + 10, print);
  cout << endl;
  return 0;
}

//   22.23 旋转rotate ---------------------------------------------------

template <class ForwardIterator>
  void rotate ( ForwardIterator first, ForwardIterator middle,
                ForwardIterator last )
{
  ForwardIterator next = middle;
  while (first!=next)
  {
    swap (*first++,*next++);
    if (next==last) next=middle;
    else if (first == middle) middle=next; // 这种交换方法，非常新颖。可以画图理解
  }
}
// 旋转交换。[first,middle) 与 [middle,last)，两区域的元素，进行交换。两区域的元素个数不一定要相等。
// 如 1,2,3,4,5 ，以4为middle，--> 4,5,1,2,3 。 三个参数：first, middle, last



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

int main () {
  vector<int> myvector;
  vector<int>::iterator it;

  // set some values:
  for (int i=1; i<10; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9

  rotate(myvector.begin(),myvector.begin()+3,myvector.end());
                                                  // 4 5 6 7 8 9 1 2 3

  // print out content:
  cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}


// 329
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << ‘ ‘;
}
int main(void)
{
  vector < int > v(10);
  unsigned int i;
  for(i = 0; i < v.size(); i++)
    v[i] = i + 1;
  for_each(v.begin(), v.end(), print);
  cout << endl;
  //
  cout << "开始旋转,middle元素=" << *(v.begin() + 7) << endl;
  rotate(v.begin(), v.begin() + 7, v.end());
  for_each(v.begin(), v.end(), print);
  return 0;
}

//   22.24 旋转复制rotate_copy ---------------------------------------------------


template <class ForwardIterator, class OutputIterator>
  OutputIterator rotate_copy ( ForwardIterator first, ForwardIterator middle,
                               ForwardIterator last, OutputIterator result )
{
  result=copy (middle,last,result);
  return copy (first,middle,result);
}
// 与rotate类似，无非是拷贝到了另一容器。四个参数：first, middle, last, result



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

int main () {
  int myints[] = {10,20,30,40,50,60,70};

  vector<int> myvector;
  vector<int>::iterator it;

  myvector.resize(7);

  rotate_copy(myints,myints+3,myints+7,myvector.begin());

  // print out content:
  cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}




// 329
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << ‘ ‘;
}
int main(void)
{
  vector < int > v(10);
  for(unsigned int i = 0; i < v.size(); i++)
    v[i] = i + 1;
  //
  int iArray[10] ={0};
  //
  cout << "开始旋转复制，*middle选为" << *(v.begin() + 7) << endl;
  rotate_copy(v.begin(), v.begin() + 7, v.end(), iArray);
  for_each(iArray, iArray + 10, print);
  cout << endl;
  return 0;
}

//   22.25 随机抖动random_shuffle ---------------------------------------------------


template <class RandomAccessIterator, class RandomNumberGenerator>
  void random_shuffle ( RandomAccessIterator first, RandomAccessIterator last,
                        RandomNumberGenerator& rand )
{
  iterator_traits<RandomAccessIterator>::difference_type i, n;
  n = (last-first);
  for (i=2; i<n; ++i) swap (first[i],first[rand(i)]);
}
// shuffle 洗牌。第三个参数可无，如有，是自定义的随机发生器。



// random_shuffle example
#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <ctime>
#include <cstdlib>
using namespace std;

// random generator function:
ptrdiff_t myrandom (ptrdiff_t i) { return rand()%i;}

// pointer object to it:
ptrdiff_t (*p_myrandom)(ptrdiff_t) = myrandom;

int main () {
  srand ( unsigned ( time (NULL) ) );
  vector<int> myvector;
  vector<int>::iterator it;

  // set some values:
  for (int i=1; i<10; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9

  // using built-in random generator:
  random_shuffle ( myvector.begin(), myvector.end() );

  // using myrandom:
  random_shuffle ( myvector.begin(), myvector.end(), p_myrandom);

  // print out content:
  cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}


//331
#include <algorithm>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << ‘ ‘;
}
int main(void)
{
  int iArray[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  cout << "随机抖动iArray三次" << endl;
  for(int i = 0; i < 3; i++)
  {
    random_shuffle(iArray, iArray + 10);
    for_each(iArray, iArray + 10, print);
    cout << endl;
  }
  return 0;
}

//   22.26 随机采样random_sample ---------------------------------------------------



// 333 。random_sample不是标准函数。我们可以采用另两个函数，来达到相同的目的：
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << ‘ ‘;
}
int main(void)
{
  vector < int > v(10);
  for(unsigned int i = 0; i < v.size(); i++)
    v[i] = i % 8;
  //
  cout << "v= ";
  for_each(v.begin(), v.end(), print);
  cout << endl;
  //
  const int n = 6; //采样个数
  int iArray[n];
  //random_sample(v.begin(), v.end(), iArray, iArray + n);
  random_shuffle(v.begin(),v.end());
  copy(v.begin(),v.begin()+n,iArray);
  //
  cout << n << "个采样元素为 ";
  for_each(iArray, iArray + n, print);
  cout << endl;
  return 0;
}

//   22.27 容器分割partition ---------------------------------------------------

template <class BidirectionalIterator, class Predicate>
  BidirectionalIterator partition ( BidirectionalIterator first,
                                    BidirectionalIterator last, Predicate pred )
{
  while (first!=last) // 可以看到快排的影子
  {
    --last;
    while (first!=last && pred(*first)) ++first;
    while (first!=last && !pred(*last)) --last;
    if (first!=last) swap (*first++,*last);
  }
  return first;
}
// 把序列分成两部分，前一部分满足条件，后一部分不满足条件。三个参数。



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

bool IsOdd (int i) { return (i%2)==1; }

int main () {
  vector<int> myvector;
  vector<int>::iterator it, bound;

  // set some values:
  for (int i=1; i<10; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9

  bound = partition (myvector.begin(), myvector.end(), IsOdd);

  // print out content:
  cout << "odd members:";
  for (it=myvector.begin(); it!=bound; ++it)
    cout << " " << *it;

  cout << "\neven members:";
  for (it=bound; it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}



// 334
#include <algorithm>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << ‘ ‘;
}
bool less10(int x)
{
  return x < 10;
}
int main(void)
{
  int iArray[10] = { 16,  - 1, 3, 11, 2, 5, 8, 20, 9, 3 };
  int *result = partition(iArray, iArray + 10, less10);
  cout << "按小于10进行分割" << endl;
  for_each(iArray, iArray + 10, print);
  cout << endl;
  //
  cout << "partition算法返回的分界元素为 " <<  *result << endl;
  return 0;
}

//   22.28 容器稳定分割stable_partition ---------------------------------------------------

// partition 的稳定版本

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

bool IsOdd (int i) { return (i%2)==1; }

int main () {
  vector<int> myvector;
  vector<int>::iterator it, bound;

  // set some values:
  for (int i=1; i<10; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9

  bound = stable_partition (myvector.begin(), myvector.end(), IsOdd);

  // print out content:
  cout << "odd members:";
  for (it=myvector.begin(); it!=bound; ++it)
    cout << " " << *it;

  cout << "\neven members:";
  for (it=bound; it!=myvector.end(); ++it)
    cout << " " << *it;

  cout << endl;

  return 0;
}


// 338
#include <algorithm>
#include <iostream>
using namespace std;
void print(int x)
{
  cout << x << ‘ ‘;
}
bool less10(int x)
{
  return x < 10 ? 1 : 0;
}
int main(void)
{
  int iArray[10] = { 16,  - 1, 3, 11, 2, 5, 8, 20, 9, 3 };
  for_each(iArray, iArray + 10, print);
  cout << endl;
  //进行稳定分割
  int *result = stable_partition(iArray, iArray + 10, less10);
  cout << "按小于10稳定分割,iArray数组变为" << endl;
  for_each(iArray, iArray + 10, print);
  cout << endl;
  //
  cout << "iArray数组有如下小于10的整数" << endl;
  for_each(iArray, result, print);
  cout << endl;
  //
  cout << "stable_partition算法返回的分界元素为 " <<  *result << endl;
  return 0;
}

/***************************************************************************************************************

//   22.29 本章小结 ---------------------------------------------------

   22.1 元素复制copy
// 把序列一中某范围内的元素，复制到序列二中去。前两个参数是序列一范围，第三个参数是序列二的开始位置
// 当序列二不够大时，不够装部分将复制不过去。

   22.2 反向复制copy_backward
// 把序列一中某范围内的元素，复制到序列二中去。前两个参数是序列一范围，第三个参数是序列二的结束位置的下一个位置。
// 两序列可以是同一序列

   22.3 元素交换swap
// 不通过指针交换两个元素

   22.4 迭代器交换iter_swap
// 利用指针（迭代器）交换值

   22.5 区间元素交换swap_ranges
// 两个区间中的元素分别交换。只有三个参数，第四个参数又省了
// 注意：第二个序列要足够长，否则会出现异常。

   22.6 元素变换transform
// 加转换的copy。而且转换函数可以是一元的，也可以是二元的。
// 一元的参数有四个：开始两个表示第一序列范围，第三个是结果存放开始位置，第四个是一元函数（对象）
// 二元的参数有五个：开始两个表示第一序列范围，第三个是第二序列开始位置，第四个是结果存放开始位置，第五个是二元函数（对象）

   22.7 替换Replace
// 在指定范围内旧值换新值

   22.8 条件替换replace_if
// 当元素满足什么条件时，更新为新值

   22.9 替换和复制replace_copy
// 将第一序列某范围内的元素，复制到第二序列中去。在这个复制过程中，将旧值，替换为新值
// 前两个参数表示第一序列范围，第三个参数为第二序列开始位置（木有结束位置），第四、五个参数为旧、新值

   22.10 条件替换和复制replace_copy_if
// replace_copy的谓词判断版本。 木有旧值了，替换为一个谓词。这样应用范围更广

   22.11 填充fill
// 在序列范围内，均填充上某新值。

   22.12 n次填充fill_n
// 在起始位置开始，填充n个value。三个参数：起始位置、几个、新值。

   22.13 随机生成元素generate
// 在指定范围内，填充上第三个参数gen产生的值。
// gen是个函数（对象），木有参数。所以产生的值，纯粹取决于gen，与容器原来的元素无关

   22.14 随机生成n个元素generate_n
// 在开始位置之后，填充n个gen()产生的值。三个参数：起始位置、几个、gen产生的值。

   22.15 移除复制remove_copy
// 将容器中，不等于某值的元素，复制到另一容器中。
// 参数有四个：前两个表示范围，第三个是另一容器的起始位置，第四个是某值。
// 这样就产生了一个问题，另一容器，可以是同一容器么？可以的。

   22.16 条件移除复制remove_copy_if
// remove_copy 的带谓词判断的版本。把第四个参数，改成了函数（对象）。

   22.17 移除remove
// 将容器中等于某值的元素删除。
// 因为在同一容器中操作，所以返回值值得关注。返回排列完删除某些元素之后的序列的后一个位置。
// 如果要将数据复制到另一容器，可以考虑用remove_copy

   22.18 条件移除remove_if
// remove的谓词判断版本。 remove的第三个参数，改成了谓词判断。

   22.19 不连续重复元素复制unique_copy
// 将连续相等的元素过滤掉，只剩下一个
// 第四个参数可选，如有，是谓词判断的函数（对象）。这个谓词估计不常用。
// 第三个参数是输出的第一个位置。可以用同一容器，也可以用不同容器。

   22.20 剔除连续重复元素unique
// 将连续相等的元素过滤掉，只剩下一个。在同一容器操作。
// 第三个参数可无，如有是谓词判断函数（对象）

   22.21 元素反向reverse
// 反转元素

   22.22 反向复制reverse_copy
// 从后向前，复制到另一容器。
// 复制到同一容器，可以吗？ 请见以下第二个程序，my test。
// my test:复制到同一空间（范围），会产生冲突。复制到同一容器不同范围，木有关系。

   22.23 旋转rotate
// 旋转交换。[first,middle) 与 [middle,last)，两区域的元素，进行交换。两区域的元素个数不一定要相等。
// 如 1,2,3,4,5 ，以4为middle，--> 4,5,1,2,3 。 三个参数：first, middle, last

   22.24 旋转复制rotate_copy
// 与rotate类似，无非是拷贝到了另一容器。四个参数：first, middle, last, result

   22.25 随机抖动random_shuffle
// shuffle 洗牌。第三个参数可无，如有，是自定义的随机发生器。

   22.26 随机采样random_sample
//random_sample不是标准函数。我们可以采用另两个函数，来达到相同的目的
  //random_sample(v.begin(), v.end(), iArray, iArray + n);
  random_shuffle(v.begin(),v.end());
  copy(v.begin(),v.begin()+n,iArray);

   22.27 容器分割partition
// 把序列分成两部分，前一部分满足条件，后一部分不满足条件。三个参数。

   22.28 容器稳定分割stable_partition
// partition 的稳定版本

   22.29 本章小结
// 这就是小结


***********************************************************************************************************/