C++ 算法库(2) 修改内容的序列操作

于 2014-01-22 19:35:25 发布
阅读量2.3k 收藏 2
点赞数
分类专栏： 1.3 数据结构和算法 文章标签： c++11
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/akof1314/article/details/18669963
版权
修改内容的序列操作：
copy 将一个范围中的元素拷贝到新的位置处
copy_backward 将一个范围中的元素按逆序拷贝到新的位置处
copy_if C++11 将一个范围中满足给定条件的元素拷贝到新的位置处
copy_n C++11 拷贝 n 个元素到新的位置处
fill 将一个范围的元素赋值为给定值
fill_n 将某个位置开始的 n 个元素赋值为给定值
generate 将一个函数的执行结果保存到指定范围的元素中，用于批量赋值范围中的元素
generate_n 将一个函数的执行结果保存到指定位置开始的 n 个元素中
iter_swap 交换两个迭代器指向的元素
move C++11 将一个范围中的元素移动到新的位置处
move_backward C++11 将一个范围中的元素按逆序移动到新的位置处
random_shuffle 随机打乱指定范围中的元素的位置
remove 将一个范围中值等价于给定值的元素删除
remove_if 将一个范围中值满足给定条件的元素删除
remove_copy 拷贝一个范围的元素，将其中值等价于给定值的元素删除
remove_copy_if 拷贝一个范围的元素，将其中值满足给定条件的元素删除
replace 将一个范围中值等价于给定值的元素赋值为新的值
replace_copy 拷贝一个范围的元素，将其中值等价于给定值的元素赋值为新的值
replace_copy_if 拷贝一个范围的元素，将其中值满足给定条件的元素赋值为新的值
replace_if 将一个范围中值满足给定条件的元素赋值为新的值
reverse 反转排序指定范围中的元素
reverse_copy 拷贝指定范围的反转排序结果
rotate 循环移动指定范围中的元素
rotate_copy 拷贝指定范围的循环移动结果
shuff​le C++11 用指定的随机数引擎随机打乱指定范围中的元素的位置
swap 交换两个对象的值
swap_ranges 交换两个范围的元素
transform 对指定范围中的每个元素调用某个函数以改变元素的值
unique 删除指定范围中的所有连续重复元素，仅仅留下每组等值元素中的第一个元素
unique_copy 拷贝指定范围的唯一化（参考上述的 unique）结果

copy

将一个范围中的元素拷贝到新的位置处

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// copy algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::copy
 #include <vector>        // std::vector
int main () {
   int myints[]={ 10, 20, 30, 40, 50, 60, 70};
  std::vector< int> myvector ( 7);

  std::copy ( myints, myints+ 7, myvector.begin() );

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

  std::cout <<  '\n';

   return  0;
}

输出：

1
myvector contains: 10 20 30 40 50 60 70

copy_backward

将一个范围中的元素按逆序拷贝到新的位置处

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// copy_backward example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::copy_backward
 #include <vector>        // std::vector
int main () {
  std::vector< int> myvector;

   // 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
  std::copy_backward ( myvector.begin(), myvector.begin()+ 5, myvector.end() );

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

   return  0;
}

输出：

1
myvector contains: 10 20 30 10 20 30 40 50

copy_if

将一个范围中满足给定条件的元素拷贝到新的位置处

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// copy_if example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::copy_if, std::distance
 #include <vector>        // std::vector
int main () {
  std::vector< int> foo = { 25, 15, 5,- 5,- 15};
  std::vector< int> bar (foo.size());

   // copy only positive numbers:
   auto it = std::copy_if (foo.begin(), foo.end(), bar.begin(), []( int i){ return !(i< 0);} );
  bar.resize(std::distance(bar.begin(),it));   // shrink container to new size
  std::cout <<  "bar contains:";
   for ( int& x: bar) std::cout <<  ' ' << x;
  std::cout <<  '\n';

   return  0;
}

输出：

1
bar contains: 25 15 5

copy_n

拷贝 n 个元素到新的位置处

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// copy_n algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::copy
 #include <vector>        // std::vector
int main () {
   int myints[]={ 10, 20, 30, 40, 50, 60, 70};
  std::vector< int> myvector;

  myvector.resize( 7);    // allocate space for 7 elements
  std::copy_n ( myints,  7, myvector.begin() );

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

  std::cout <<  '\n';

   return  0;
}

输出：

1
myvector contains: 10 20 30 40 50 60 70

fill

将一个范围的元素赋值为给定值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// fill algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::fill
 #include <vector>        // std::vector
int main () {
  std::vector< int> myvector ( 8);                        // myvector: 0 0 0 0 0 0 0 0
  std::fill (myvector.begin(),myvector.begin()+ 4, 5);    // myvector: 5 5 5 5 0 0 0 0
  std::fill (myvector.begin()+ 3,myvector.end()- 2, 8);    // myvector: 5 5 5 8 8 8 0 0
  std::cout <<  "myvector contains:";
   for (std::vector< int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

   return  0;
}

输出：

1
myvector contains: 5 5 5 8 8 8 0 0

fill_n

将某个位置开始的 n 个元素赋值为给定值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// fill_n example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::fill_n
 #include <vector>        // std::vector
int main () {
  std::vector< int> myvector ( 8, 10);         // myvector: 10 10 10 10 10 10 10 10
  std::fill_n (myvector.begin(), 4, 20);      // myvector: 20 20 20 20 10 10 10 10
  std::fill_n (myvector.begin()+ 3, 3, 33);    // myvector: 20 20 20 33 33 33 10 10
  std::cout <<  "myvector contains:";
   for (std::vector< int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

   return  0;
}

输出：

1
myvector contains: 20 20 20 33 33 33 10 10

generate

将一个函数的执行结果保存到指定范围的元素中，用于批量赋值范围中的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// generate algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::generate
 #include <vector>        // std::vector
 #include <ctime>         // std::time
 #include <cstdlib>       // std::rand, std::srand
// function generator:
 int RandomNumber () {  return (std::rand()% 100); }

// class generator:
 struct c_unique {
   int current;
  c_unique() {current= 0;}
   int  operator()() { return ++current;}
} UniqueNumber;

int main () {
  std::srand (  unsigned ( std::time( 0) ) );

  std::vector< int> myvector ( 8);

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

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

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

  std::cout <<  "myvector contains:";
   for (std::vector< int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';
 
   return  0;
}

输出：

1
2
myvector contains: 57 87 76 66 85 54 17 15
myvector contains: 1 2 3 4 5 6 7 8

generate_n

将一个函数的执行结果保存到指定位置开始的 n 个元素中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// generate_n example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::generate_n
int current =  0;
int UniqueNumber () {  return ++current; }

int main () {
   int myarray[ 9];

  std::generate_n (myarray,  9, UniqueNumber);

  std::cout <<  "myarray contains:";
   for ( int i= 0; i< 9; ++i)
    std::cout <<  ' ' << myarray[i];
  std::cout <<  '\n';

   return  0;
}

输出：

1
myarray contains: 1 2 3 4 5 6 7 8 9

iter_swap

交换两个迭代器指向的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// iter_swap example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::iter_swap
 #include <vector>        // std::vector
int main () {

   int myints[]={ 10, 20, 30, 40, 50 };               //   myints:  10  20  30  40  50
  std::vector< int> myvector ( 4, 99);             // myvector:  99  99  99  99
  std::iter_swap(myints,myvector.begin());      //   myints: [99] 20  30  40  50
                                                // myvector: [10] 99  99  99
  std::iter_swap(myints+ 3,myvector.begin()+ 2);  //   myints:  99  20  30 [99]
                                                // myvector:  10  99 [40] 99
  std::cout <<  "myvector contains:";
   for (std::vector< int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

   return  0;
}

输出：

1
myvector contains: 10 99 40 99

move

将一个范围中的元素移动到新的位置处

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// move algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::move (ranges)
 #include <utility>       // std::move (objects)
 #include <vector>        // std::vector
 #include <string>        // std::string
int main () {
  std::vector<std::string> foo = { "air", "water", "fire", "earth"};
  std::vector<std::string> bar ( 4);

   // moving ranges:
  std::cout <<  "Moving ranges...\n";
  std::move ( foo.begin(), foo.begin()+ 4, bar.begin() );

  std::cout <<  "foo contains " << foo.size() <<  " elements:";
  std::cout <<  " (each in an unspecified but valid state)";
  std::cout <<  '\n';

  std::cout <<  "bar contains " << bar.size() <<  " elements:";
   for (std::string& x: bar) std::cout <<  " [" << x <<  "]";
  std::cout <<  '\n';

   // moving container:
  std::cout <<  "Moving container...\n";
  foo = std::move (bar);

  std::cout <<  "foo contains " << foo.size() <<  " elements:";
   for (std::string& x: foo) std::cout <<  " [" << x <<  "]";
  std::cout <<  '\n';

  std::cout <<  "bar is in an unspecified but valid state";
  std::cout <<  '\n';

   return  0;
}

输出：

1
2
3
4
5
6
Moving ranges...
foo contains 4 elements: (each in an unspecified but valid state)
bar contains 4 elements: [air] [water] [fire] [earth]
Moving container...
foo contains 4 elements: [air] [water] [fire] [earth]
bar is in an unspecified but valid state

move_backward

将一个范围中的元素按逆序移动到新的位置处

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// move_backward example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::move_backward
 #include <string>        // std::string
int main () {
  std::string elems[ 10] = { "air", "water", "fire", "earth"};

   // insert new element at the beginning:
  std::move_backward (elems,elems+ 4,elems+ 5);
  elems[ 0]= "ether";

  std::cout <<  "elems contains:";
   for ( int i= 0; i< 10; ++i)
    std::cout <<  " [" << elems[i] <<  "]";
  std::cout <<  '\n';

   return  0;
}

输出：

1
elems contains: [ether] [air] [water] [fire] [earth] [] [] [] [] []

random_shuffle

随机打乱指定范围中的元素的位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// random_shuffle example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::random_shuffle
 #include <vector>        // std::vector
 #include <ctime>         // std::time
 #include <cstdlib>       // std::rand, std::srand
// random generator function:
 int myrandom ( int i) {  return std::rand()%i;}

int main () {
  std::srand (  unsigned ( std::time( 0) ) );
  std::vector< int> myvector;

   // 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:
  std::random_shuffle ( myvector.begin(), myvector.end() );

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

   // print out content:
  std::cout <<  "myvector contains:";
   for (std::vector< int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout <<  ' ' << *it;

  std::cout <<  '\n';

   return  0;
}

输出：

1
myvector contains: 3 4 1 6 8 9 2 7 5

remove

将一个范围中值等价于给定值的元素删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// remove algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::remove
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 = std::remove (pbegin, pend,  20);          // 10 30 30 10 10 ?  ?  ?
                                                  // ^              ^
  std::cout <<  "range contains:";
   for ( int* p=pbegin; p!=pend; ++p)
    std::cout <<  ' ' << *p;
  std::cout <<  '\n';

   return  0;
}

输出：

1
range contains: 10 30 30 10 10

remove_if

将一个范围中值满足给定条件的元素删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// remove_if example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::remove_if
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 = std::remove_if (pbegin, pend, IsOdd);    // 2 4 6 8 ? ? ? ? ?
                                                  // ^       ^
  std::cout <<  "the range contains:";
   for ( int* p=pbegin; p!=pend; ++p)
    std::cout <<  ' ' << *p;
  std::cout <<  '\n';

   return  0;
}

输出：

1
the range contains: 2 4 6 8

remove_copy

拷贝一个范围的元素，将其中值等价于给定值的元素删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// remove_copy example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::remove_copy
 #include <vector>        // std::vector
int main () {
   int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20};                // 10 20 30 30 20 10 10 20
  std::vector< int> myvector ( 8);

  std::remove_copy (myints,myints+ 8,myvector.begin(), 20);  // 10 30 30 10 10 0 0 0
  std::cout <<  "myvector contains:";
   for (std::vector< int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

   return  0;
}

输出：

1
myvector contains: 10 30 30 10 10 0 0 0

remove_copy_if

拷贝一个范围的元素，将其中值满足给定条件的元素删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// remove_copy_if example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::remove_copy_if
 #include <vector>        // std::vector
bool IsOdd ( int i) {  return ((i% 2)== 1); }

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

  std::remove_copy_if (myints,myints+ 9,myvector.begin(),IsOdd);

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

   return  0;
}

输出：

1
myvector contains: 2 4 6 8 0 0 0 0 0

replace

将一个范围中值等价于给定值的元素赋值为新的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// replace algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::replace
 #include <vector>        // std::vector
int main () {
   int myints[] = {  10,  20,  30,  30,  20,  10,  10,  20 };
  std::vector< int> myvector (myints, myints+ 8);             // 10 20 30 30 20 10 10 20
  std::replace (myvector.begin(), myvector.end(),  20,  99);  // 10 99 30 30 99 10 10 99
  std::cout <<  "myvector contains:";
   for (std::vector< int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

   return  0;
}

输出：

1
myvector contains: 10 99 30 30 99 10 10 99

replace_copy

拷贝一个范围的元素，将其中值等价于给定值的元素赋值为新的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// replace_copy example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::replace_copy
 #include <vector>        // std::vector
int main () {
   int myints[] = {  10,  20,  30,  30,  20,  10,  10,  20 };

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

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

   return  0;
}

输出：

1
myvector contains: 10 99 30 30 99 10 10 99

replace_copy_if

拷贝一个范围的元素，将其中值满足给定条件的元素删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// replace_copy_if example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::replace_copy_if
 #include <vector>        // std::vector
bool IsOdd ( int i) {  return ((i% 2)== 1); }

int main () {
  std::vector< int> foo,bar;

   // set some values:
   for ( int i= 1; i< 10; i++) foo.push_back(i);           // 1 2 3 4 5 6 7 8 9
  bar.resize(foo.size());    // allocate space
  std::replace_copy_if (foo.begin(), foo.end(), bar.begin(), IsOdd,  0);
                                                         // 0 2 0 4 0 6 0 8 0
  std::cout <<  "bar contains:";
   for (std::vector< int>::iterator it=bar.begin(); it!=bar.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

   return  0;
}

输出：

1
second contains: 0 2 0 4 0 6 0 8 0

replace_if

将一个范围中值满足给定条件的元素赋值为新的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// replace_if example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::replace_if
 #include <vector>        // std::vector
bool IsOdd ( int i) {  return ((i% 2)== 1); }

int main () {
  std::vector< int> myvector;

   // set some values:
   for ( int i= 1; i< 10; i++) myvector.push_back(i);                // 1 2 3 4 5 6 7 8 9
  std::replace_if (myvector.begin(), myvector.end(), IsOdd,  0);  // 0 2 0 4 0 6 0 8 0
  std::cout <<  "myvector contains:";
   for (std::vector< int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

   return  0;
}

输出：

1
myvector contains: 0 2 0 4 0 6 0 8 0

reverse

反转排序指定范围中的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// reverse algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::reverse
 #include <vector>        // std::vector
int main () {
  std::vector< int> myvector;

   // set some values:
   for ( int i= 1; i< 10; ++i) myvector.push_back(i);    // 1 2 3 4 5 6 7 8 9
  std::reverse(myvector.begin(),myvector.end());     // 9 8 7 6 5 4 3 2 1
   // print out content:
  std::cout <<  "myvector contains:";
   for (std::vector< int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

   return  0;
}

输出：

1
myvector contains: 9 8 7 6 5 4 3 2 1

reverse_copy

拷贝指定范围的反转排序结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// reverse_copy example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::reverse_copy
 #include <vector>        // std::vector
int main () {
   int myints[] ={ 1, 2, 3, 4, 5, 6, 7, 8, 9};
  std::vector< int> myvector;

  myvector.resize( 9);     // allocate space
  std::reverse_copy (myints, myints+ 9, myvector.begin());

   // print out content:
  std::cout <<  "myvector contains:";
   for (std::vector< int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout <<  ' ' << *it;

  std::cout <<  '\n';

   return  0;
}

输出：

1
myvector contains: 9 8 7 6 5 4 3 2 1

rotate

循环移动指定范围中的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// rotate algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::rotate
 #include <vector>        // std::vector
int main () {
  std::vector< int> myvector;

   // set some values:
   for ( int i= 1; i< 10; ++i) myvector.push_back(i);  // 1 2 3 4 5 6 7 8 9
  std::rotate(myvector.begin(),myvector.begin()+ 3,myvector.end());
                                                   // 4 5 6 7 8 9 1 2 3
   // print out content:
  std::cout <<  "myvector contains:";
   for (std::vector< int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

   return  0;
}

输出：

1
myvector contains: 4 5 6 7 8 9 1 2 3

rotate_copy

拷贝指定范围的循环移动结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// rotate_copy algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::rotate_copy
 #include <vector>        // std::vector
int main () {
   int myints[] = { 10, 20, 30, 40, 50, 60, 70};

  std::vector< int> myvector ( 7);

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

   // print out content:
  std::cout <<  "myvector contains:";
   for (std::vector< int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

   return  0;
}

输出：

1
myvector contains: 40 50 60 70 10 20 30

shuffle

用指定的随机数引擎随机打乱指定范围中的元素的位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// shuffle algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::move_backward
 #include <array>         // std::array
 #include <random>        // std::default_random_engine
 #include <chrono>        // std::chrono::system_clock
int main () {
  std::array< int, 5> foo { 1, 2, 3, 4, 5};

   // obtain a time-based seed:
   unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();

  shuffle (foo.begin(), foo.end(), std::default_random_engine(seed));

  std::cout <<  "shuffled elements:";
   for ( int& x: foo) std::cout <<  ' ' << x;
  std::cout <<  '\n';

   return  0;
}

输出：

1
shuffled elements: 3 1 4 2 5

swap

交换两个对象的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// swap algorithm example (C++98)
 #include <iostream>      // std::cout
 #include <algorithm>     // std::swap
 #include <vector>        // std::vector
int main () {

   int x= 10, y= 20;                               // x:10 y:20
  std::swap(x,y);                               // x:20 y:10
  std::vector< int> foo ( 4,x), bar ( 6,y);        // foo:4x20 bar:6x10
  std::swap(foo,bar);                           // foo:6x10 bar:4x20
  std::cout <<  "foo contains:";
   for (std::vector< int>::iterator it=foo.begin(); it!=foo.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

   return  0;
}

输出：

1
foo contains: 10 10 10 10 10 10

swap_ranges

交换两个范围的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// swap_ranges example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::swap_ranges
 #include <vector>        // std::vector
int main () {
  std::vector< int> foo ( 5, 10);         // foo: 10 10 10 10 10
  std::vector< int> bar ( 5, 33);         // bar: 33 33 33 33 33
  std::swap_ranges(foo.begin()+ 1, foo.end()- 1, bar.begin());

   // print out results of swap:
  std::cout <<  "foo contains:";
   for (std::vector< int>::iterator it=foo.begin(); it!=foo.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

  std::cout <<  "bar contains:";
   for (std::vector< int>::iterator it=bar.begin(); it!=bar.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

   return  0;
}

输出：

1
2
foo contains: 10 33 33 33 10
bar contains: 10 10 10 33 33

transform

对指定范围中的每个元素调用某个函数以改变元素的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// transform algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::transform
 #include <vector>        // std::vector
 #include <functional>    // std::plus
int op_increase ( int i) {  return ++i; }

int main () {
  std::vector< int> foo;
  std::vector< int> bar;

   // set some values:
   for ( int i= 1; i< 6; i++)
    foo.push_back (i* 10);                          // foo: 10 20 30 40 50
  bar.resize(foo.size());                          // allocate space
  std::transform (foo.begin(), foo.end(), bar.begin(), op_increase);
                                                   // bar: 11 21 31 41 51
   // std::plus adds together its two arguments:
  std::transform (foo.begin(), foo.end(), bar.begin(), foo.begin(), std::plus< int>());
                                                   // foo: 21 41 61 81 101
  std::cout <<  "foo contains:";
   for (std::vector< int>::iterator it=foo.begin(); it!=foo.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

   return  0;
}

输出：

1
foo contains: 21 41 61 81 101

unique

删除指定范围中的所有连续重复元素，仅仅留下每组等值元素中的第一个元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// unique algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::unique, std::distance
 #include <vector>        // std::vector
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
  std::vector< int> myvector (myints,myints+ 9);

   // using default comparison:
  std::vector< int>::iterator it;
  it = std::unique (myvector.begin(), myvector.end());    // 10 20 30 20 10 ?  ?  ?  ?
                                                          //                ^
  myvector.resize( std::distance(myvector.begin(),it) );  // 10 20 30 20 10
   // using predicate comparison:
  std::unique (myvector.begin(), myvector.end(), myfunction);    // (no changes)
   // print out content:
  std::cout <<  "myvector contains:";
   for (it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

   return  0;
}

输出：

1
myvector contains: 10 20 30 20 10

unique_copy

拷贝指定范围的唯一化（参考上述的 unique）结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// unique_copy example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::unique_copy, std::sort, std::distance
 #include <vector>        // std::vector
bool myfunction ( int i,  int j) {
   return (i==j);
}

int main () {
   int myints[] = { 10, 20, 20, 20, 30, 30, 20, 20, 10};
  std::vector< int> myvector ( 9);                             // 0  0  0  0  0  0  0  0  0
   // using default comparison:
  std::vector< int>::iterator it;
  it=std::unique_copy (myints,myints+ 9,myvector.begin());    // 10 20 30 20 10 0  0  0  0
                                                             //                ^
  std::sort (myvector.begin(),it);                           // 10 10 20 20 30 0  0  0  0
                                                             //                ^
   // using predicate comparison:
  it=std::unique_copy (myvector.begin(), it, myvector.begin(), myfunction);
                                                             // 10 20 30 20 30 0  0  0  0
                                                             //          ^
  myvector.resize( std::distance(myvector.begin(),it) );     // 10 20 30
   // print out content:
  std::cout <<  "myvector contains:";
   for (it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout <<  ' ' << *it;
  std::cout <<  '\n';

   return  0;
}

输出：

1
myvector contains: 10 20 30


特别说明：函数的中文释义来自：http://classfoo.cn/cpp/head/76573_319/，例子来自：http://www.cplusplus.com/reference/algorithm/


无幻
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值