//  第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 + 3class 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 本章小结// 这就是小结***********************************************************************************************************/