STL学习笔记变易算法
STL学习笔记--变易算法
变易算法
C++ STL 的变易算法 (Mutating algorithms) 是一组能够修改容器元素数据的模板函数，可进行序列数据的复制、交换、替换、填充、移除、旋转、随机抖动和分割。这些算法对迭代器有较高的要求，具体的迭代器类型随各个算法而定，或前向迭代器、或双向迭代器、又或者是随机迭代器，以提供算法所需要的迭代器操作。应用变易算法时，先要检查容器的迭代器是否符合要求，防止产生编译错误。
目录：
元素复制 copy 反向复制 copy_backward 元素交换 swap
迭代器交换 iter_swap 区间元素交换 swap_ranges 元素变换 transform
替换 replace 条件替换 replace_if 替换和复制 replace_copy
条件替换和复制 replace_copy_if 填充 fill n次填充 fill_n
随机生成元素 generate 随机生成n个元素 generate_n 移除复制 remove_copy
条件移除复制 remove_copy_if 移除 remove 条件移除 remove_if
不连续重复元素复制 unique_copy 剔除连续重复元素 unique 元素反向 reverse
反向复制 reverse_copy 旋转 rotate 旋转复制 rotate_copy
随机抖动 random_shuffle 容器分割 partition 容器稳定分割 stable_partition
应用 copy 算法复制向量vector元素链表到链表 list
1 /* 下面示例程序将向量{1 3 5}，拷贝到链表{2 4 6 8 10}的首元素开始位置，结果链表的前3个元素被拷贝覆盖掉，打印输出为“1 3 5 8 10”
2 */
3 ----------------------------------------------- 应用 copy 算法复制向量vector元素链表到链表 list
4 #include <algorithm>
5 #include <vector>
6 #include <list>
7 #include <iostream>
8 using namespace std;
9
10 void print( int x)
11 {
12 cout << x << " " ;
13 }
14
15 int main()
16 {
17 // 初始化向量v
18 vector< int > v;
19 v.push_back( 1 );
20 v.push_back( 3 );
21 v.push_back( 5 );
22
23 // 初始化双向链表l
24 list< int > l;
25 l.push_back( 2 );
26 l.push_back( 4 );
27 l.push_back( 6 );
28 l.push_back( 8 );
29 l.push_back( 10 );
30
31 // 复制v到l
32 copy(v.begin(), v.end(), l.begin());
33
34 // 打印链表l中的元素
35 for_each(l.begin(), l.end(), print);
36 cout << endl;
37
38 return 0 ;
39 }
应用 copy_backward 算法在同一个向量vector中进行复制
1 /* 下面示例程序将{1 2 3 4 5 6 7 8 9 10}向量的前3个元素复制到后面3个元素中，打印输出为“1 2 3 4 5 6 7 1 2 3 ”，与采用 copy 算法复制的打印输出完全相同，只是元素的复制顺序不同
2 */
3 ----------------------------------------------- 应用 copy_backward 算法在同一个向量vector中进行复制
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << ' ' ;
12 }
13
14 int main()
15 {
16 vector< int > v( 10 );
17 // 初始化复制
18 for (unsigned int i= 0 ; i<v.size(); i++ )
19 v[i] = i+ 1 ;
20 // 将v向量的前3个元素复制到后面3个元素中
21 copy_backward(v.begin(), v.begin()+ 3 , v.end());
22
23 for_each(v.begin(), v.end(), print);
24 cout << endl;
25
26 return 0 ;
27 }
应用 swap 算法交换两个整型变量
1 /* 下面示例程序将整数 a=5 和 b=26 交换，结果当然为 a=26 和 b=5
2 */
3 ----------------------------------------------- 应用 swap 算法交换两个整型变量
4 #include <algorithm>
5 #include <iostream>
6 using namespace std;
7 int main()
8 {
9 int a = 5 ;
10 int b = 26 ;
11 cout << " 交换前 " << " a = " << a << " b = " << b << endl << endl;
12 // 交换
13 swap(a,b);
14 cout << " 交换后 " << " a = " << a << " b = " << b << endl;
15
16 return 0 ;
17 }
应用 iter_swap 算法交换两个整型变量
1 /* 下面示例程序简单地讲标准整数类型的 a 和 b,调用 iter_swap 算法进行交换
2 */
3 -----------------------------------------------
4 #include <algorithm>
5 #include <iostream>
6 using namespace std;
7 int main()
8 {
9 int a = 5 ;
10 int b = 6 ;
11 cout << " 交换前 a= " << a << " , b= " << b << endl << endl;
12 // 交换
13 iter_swap(&a, & b);
14 cout << " 交换后 a= " << a << " , b= " << b << endl << endl;
15
16 return 0 ;
17 }
应用 swap_ranges 算法交换两个 vector 容器元素
1 /* 下面示例程序将两个向量容器 v1 和 v2 的元素交换，打印输出为“交换前，v1=1 3 5 v2=2 4 6交换后，v1=2 4 6 v2=1 3 5”
2 */
3 ----------------------------------------------- 应用 swap_ranges 算法交换两个 vector 容器元素
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << " " ;
12 }
13
14 int main()
15 {
16 vector< int > v1, v2;
17 v1.push_back( 1 );
18 v1.push_back( 3 );
19 v1.push_back( 5 );
20 v2.push_back( 2 );
21 v2.push_back( 4 );
22 v2.push_back( 6 );
23
24 // 打印v1, v2
25 cout << " 交换前， v1= " ;
26 for_each(v1.begin(), v1.end(), print);
27 cout << endl;
28
29 cout << " 交换前， v2= " ;
30 for_each(v2.begin(), v2.end(), print);
31 cout << endl;
32
33 // 交换 v1, v2
34 swap_ranges(v1.begin(), v1.end(), v2.begin());
35
36 // 打印 v1, v2
37 cout << endl;
38 cout << " 交换后， v1= " ;
39 for_each(v1.begin(), v1.end(), print);
40 cout << endl;
41
42 cout << " 交换后， v2= " ;
43 for_each(v2.begin(), v2.end(), print);
44 cout << endl;
45
46 return 0 ;
47 }
应用 transform 算法对 vector 容器元素进行平方计算
1 /* 下面示例程序将向量 v 的元素 5、15和25，执行平方变换，结果放入双向链表l 中，打印输出为“25 225 625”
2 */
3 ----------------------------------------------- 应用 transform 算法对 vector 容器元素进行平方计算
4 #include <algorithm>
5 #include <vector>
6 #include <list>
7 #include <iostream>
8 using namespace std;
9
10 int square( int x)
11 {
12 return x* x;
13 }
14
15 void print( int x)
16 {
17 cout << x << " " ;
18 }
19
20 int main()
21 {
22 // vector 初始化
23 vector< int > v;
24 v.push_back( 5 );
25 v.push_back( 15 );
26 v.push_back( 25 );
27
28 // list 初始化
29 list< int > l( 3 );
30
31 // 对vector容器元素执行平方运算，放入 list 容器
32 transform(v.begin(), v.end(), l.begin(), square);
33
34 // 打印链表元素
35 for_each(l.begin(), l.end(), print);
36 cout << endl;
37
38 return 0 ;
39 }
应用 replace 算法替换向量和数组元素
1 /* 下面示例程序先将变量 v={13, 25, 27, 25, 29} 的元素25替换为 100，然后，再将数组 iArray[]={3, 6, 5, 9, 5, 5, 10}的元素5替换为200，打印"v向量元素：13 100 27 100 29 数组iArray元素：3 6 200 9 200 200 10"
2 */
3 ----------------------------------------------- 应用 replace 算法替换向量和数组元素
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << " " ;
12 }
13
14 int main()
15 {
16 vector< int > v;
17 v.push_back( 13 );
18 v.push_back( 25 );
19 v.push_back( 27 );
20 v.push_back( 25 );
21 v.push_back( 29 );
22
23 // 将v的25全部替换为100
24 replace(v.begin(), v.end(), 25 , 100 );
25 cout << " v向量元素： " ;
26 for_each(v.begin(), v.end(), print);
27 cout << endl;
28
29 // 将iArray的5全部替换为200
30 int iArray[ 7 ] = { 3 , 6 , 5 , 9 , 5 , 5 , 10 };
31 replace(iArray, iArray+ 7 , 5 , 200 );
32 cout << " 数组iArray元素： " ;
33 for_each(iArray, iArray+ 7 , print);
34 cout << endl;
35
36 return 0 ;
37 }
应用 replace_if 算法替换向量中奇数值的元素
应用 replace_copy 算法将值为1的元素替换后拷贝到新容器
1 /* 下面示例程序将向量 v={0, 1, 2, 3, 4, 5, 6, 0, 1, 2}的奇数元素替换为新值38，打印输出为“0 38 2 38 4 38 6 0 38 2”
2 */
3 ----------------------------------------------- 应用 replace_if 算法替换向量中奇数值的元素
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 bool odd( int x)
10 {
11 return x % 2 ;
12 }
13
14 int main()
15 {
16 vector< int > v( 10 );
17 unsigned int i;
18 for (i= 0 ; i<v.size(); i++ )
19 {
20 v[i] = i % 7 ;
21 cout << v[i] << " " ;
22 }
23 cout << endl;
24
25 // 将奇数元素替换为38
26 replace_if(v.begin(), v.end(), odd, 38 );
27 for (i= 0 ; i<v.size(); i++ )
28 cout << v[i] << " " ;
29
30 cout << endl;
31
32 return 0 ;
33 }
应用 replace_copy_if 算法将奇数元素替换后拷贝到新容器
1 /* 下面的示例程序将链表l1={1, 3, 1, 6, 8}中值为1 的元素替换为100后，拷贝到链表l2中。打印输出为“l1保持不变：1 3 1 6 8 l2元素为:100 3 100 6 8”
2 */
3 ----------------------------------------------- 应用 replace_copy 算法将值为1的元素替换后拷贝到新容器
4 #include <algorithm>
5 #include <list>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << " " ;
12 }
13
14 int main()
15 {
16 list< int > l1;
17 l1.push_back( 1 );
18 l1.push_back( 3 );
19 l1.push_back( 1 );
20 l1.push_back( 6 );
21 l1.push_back( 8 );
22
23 // 将l1链表元素1替换为 100，然后拷贝到l2链表
24 list< int > l2( 5 );
25 replace_copy(l1.begin(), l1.end(), l2.begin(), 1 , 100 );
26 cout << " l1 保持不变： " ;
27 for_each(l1.begin(), l1.end(), print);
28 cout << endl;
29 cout << " l2 元素为： " ;
30 for_each(l2.begin(), l2.end(), print);
31 cout << endl;
32
33 return 0 ;
34 }
应用 fill 算法容器填充向量容器
1 /* 下面示例程序将向量 v={0, 1, 2, 3, 4, 5, 6, 0, 1, 2}中奇数值元素替换为38，然后拷贝到链表l中，链表的打印输出为“0 38 2 38 4 38 6 0 38 2”，向量v的元素不变
2 */
3 ----------------------------------------------- 应用 replace_copy_if 算法将奇数元素替换后拷贝到新容器
4 #include <algorithm>
5 #include <vector>
6 #include <list>
7 #include <iostream>
8 using namespace std;
9
10 bool odd( int x)
11 {
12 return x % 2 ;
13 }
14
15 int main()
16 {
17 vector< int > v( 10 );
18 unsigned int i;
19 for (i= 0 ; i<v.size(); i++ )
20 {
21 v[i] = i % 7 ;
22 cout << v[i] << " " ;
23 }
24 cout << endl;
25
26 // 将向量v中奇数元素替换为38后拷贝到链表l
27 list< int > l( 10 );
28 replace_copy_if(v.begin(), v.end(), l.begin(), odd, 388 );
29 list< int > ::iterator list_iter;
30 for (list_iter=l.begin(); list_iter!=l.end(); ++ list_iter)
31 cout << *list_iter << " " ;
32 cout << endl;
33
34 return 0 ;
35 }
应用 fill_n 算法填充向量容器
1 /* 下面示例程序将向量的5个元素的值全部填充为30，打印输出为“30 30 30 30 30 ”
2 */
3 ----------------------------------------------- 应用 fill 算法容器填充向量容器
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << " " ;
12 }
13
14 int main()
15 {
16 vector< int > v( 5 );
17 fill(v.begin(), v.end(), 30 );
18 for_each(v.begin(), v.end(), print);
19 cout << endl;
20
21 return 0 ;
22 }
应用 generate 算法将一个数列生成到向量容器
1 /* 下面示例程序将向量v的前5个元素填充为2，打印输出为“2 2 2 2 2 1 1 1 ”。然后再全部填充为3，打印输出“3 3 3 3 3 3 3 3 ”
2 */
3 ----------------------------------------------- 应用 fill_n 算法填充向量容器
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << " " ;
12 }
13
14 int main()
15 {
16 vector< int > v( 8 );
17 fill(v.begin(), v.end(), 1 );
18
19 // 前5个元素填充为2
20 fill_n(v.begin(), 5 , 2 );
21 for_each(v.begin(), v.end(), print);
22 cout << endl;
23
24 // 全部为3
25 fill_n(v.begin(), v.size(), 3 );
26 for_each(v.begin(), v.end(), print);
27 cout << endl;
28
29 return 0 ;
30 }
应用 generate_n 算法将3个伪随机数生成到向量容器
1 /* 下面示例程序定义了一个 sequence 类，构造出等差数列 ，然后调用generate算法，将等差数列写入向量容器V，打印输出为“3 6 9 12 15 18 21 24 27 30”
2 */
3 ----------------------------------------------- 应用 generate 算法将一个数列生成到向量容器
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 // 等差数列 an+1=an+3
10 class sequence
11 {
12 public :
13 int a;
14 sequence(){a= 0 ;}
15 inline int operator ()()
16 {
17 a = a + 3 ;
18 return a;
19 }
20 };
21
22 void print( int x)
23 {
24 cout << x << " " ;
25 }
26
27 int main()
28 {
29 vector< int > v( 10 );
30 sequence an;
31 generate(v.begin(), v.end(), an);
32 for_each(v.begin(), v.end(), print);
33 cout << endl;
34
35 return 0 ;
36 }
应用 remove_copy 算法将向量容器不包含4的元素拷贝到数组
1 /* 下面示例程序使用C标准函数 rand，将3个伪随机数生成到向量容器v中，打印输出。
2 */
3 ----------------------------------------------- 应用 generate_n 算法将3个伪随机数生成到向量容器
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 int main()
10 {
11 vector< int > v( 10 );
12 // 生成3个伪随机数
13 generate_n(v.begin(), 3 , rand);
14 for (unsigned int i= 0 ; i<v.size(); i++ )
15 cout << v[i] << " " ;
16
17 cout << endl;
18
19 return 0 ;
20 }
应用 remove_copy_if 算法将向量容器中奇数元素拷贝到数组
1 /* 下面示例程序将向量 v={2, 4, 3, 4, 8}中不等于4的元素复制到数组iArray，v的打印输出为“2, 4, 3, 4, 8”，维持不变；iArray数组的打印输出为"2 3 8 0 0 0"，已不包含值为4的元素
2 */
3 ----------------------------------------------- 应用 remove_copy 算法将向量容器不包含4的元素拷贝到数组
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << " " ;
12 }
13 int main()
14 {
15 vector< int > v;
16 v.push_back( 2 );
17 v.push_back( 4 );
18 v.push_back( 3 );
19 v.push_back( 4 );
20 v.push_back( 8 );
21
22 // 初始化数组
23 int iArray[ 6 ] = { 0 };
24
25 // 移|除 复制，v不变，
26 remove_copy(v.begin(), v.end(), iArray, 4 );
27 for_each(v.begin(), v.end(), print);
28 cout << endl;
29
30 // 打印数组
31 for_each(iArray, iArray+ 6 , print);
32 cout << endl;
33
34 return 0 ;
35 }
应用 remove 算法将向量容器中的某值元素移除
1 /* 下面示例程序将向量v={7, 2, 5, 4, 1}中不是偶数的元素复制到数组iArray，v 的打印输出为“7, 2, 5, 4, 1”维持不变；iArray数组的打印输出为"7 5 1 0 0 0"
2 */
3 ----------------------------------------------- 应用 remove_copy_if 算法将向量容器中奇数元素拷贝到数组
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << " " ;
12 }
13
14 bool even( int x)
15 {
16 return x % 2 ? 0 : 1 ;
17 }
18
19 int main()
20 {
21 vector< int > v;
22 v.push_back( 7 );
23 v.push_back( 2 );
24 v.push_back( 5 );
25 v.push_back( 4 );
26 v.push_back( 1 );
27
28 // 初始化数组
29 int iArray[ 6 ]={ 0 };
30
31 // 移除 v 中偶数，剩余元素
32 remove_copy_if(v.begin(), v.end(), iArray, even);
33
34 // 打印v, v 没有变
35 for_each(v.begin(), v.end(), print);
36 cout << endl << endl;
37
38 // 打印iArray
39 for_each(iArray, iArray+ 6 , print);
40 cout << endl;
41
42
43 return 0 ;
44 }
应用 remove_if 算法将向量容器中偶数移除
1 /* 下面示例程序将向量 v={7, 2, 5, 4, 1}中偶数移除，结果迭代器区间[first, result)的元素为{7, 5, 1}；而向量v={7, 5, 1, 4, 1}，后面两个元素{4, 1}是v保留下来的元素。
2 */
3 ----------------------------------------------- 应用 remove_if 算法将向量容器中偶数移除
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << " " ;
12 }
13
14 // 偶数
15 bool even( int x)
16 {
17 return x % 2 ? 0 : 1 ;
18 }
19
20 int main()
21 {
22 // 初始化向量v
23 vector< int > v;
24 v.push_back( 7 );
25 v.push_back( 2 );
26 v.push_back( 5 );
27 v.push_back( 4 );
28 v.push_back( 1 );
29
30 // 移除偶数
31 vector< int >::iterator result = remove_if(v.begin(), v.end(), even);
32
33 // 打印 7 5 1
34 for_each(v.begin(), result, print);
35 cout << endl << endl;
36
37 // 打印 7 5 1 4 1
38 for_each(v.begin(), v.end(), print);
39 cout << endl;
40
41 return 0 ;
42 }
1 /* 下面示例程序将向量容器v={2, 4, 3, 4, 8}中元素4全部移除掉，于是，迭代区间[first, result)的元素为{2, 3, 8}，没有元素等于4.而v变为{2, 3, 8, 4, 8}，前面3个元素就是复制过去的，后面的两个元素（包括4）是原向量中的元素(这里需要仔细思考了)
2 */
3 ----------------------------------------------- 应用 remove 算法将向量容器中的某值元素移除
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << " " ;
12 }
13
14 int main()
15 {
16 // 初始化向量 v
17 vector< int > v;
18 v.push_back( 2 );
19 v.push_back( 4 );
20 v.push_back( 3 );
21 v.push_back( 4 );
22 v.push_back( 8 );
23
24 // 移除4
25 vector< int >::iterator result = remove(v.begin(), v.end(), 4 );
26
27 // 打印 2 3 8
28 for_each(v.begin(), result, print);
29 cout << endl << endl;
30
31 // 打印 4 8
32 for_each(result, v.end(), print);
33 cout << endl << endl;
34
35 // 打印 2 3 8 4 8
36 for_each(v.begin(), v.end(), print);
37 cout << endl;
38
39 return 0 ;
40 }
应用 unique_copy 算法唯一复制向量容器元素
1 /* 下面示例程序将向量 v={2, 5, 5, 5, 6, 5, 2}中连续3个5的元素剔除两个，复制到iArray数组。打印输出为“2 5 6 5 2 0”
2 */
3 ----------------------------------------------- 应用 unique_copy 算法唯一复制向量容器元素
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << " " ;
12 }
13
14 int main()
15 {
16 vector< int > v;
17 v.push_back( 2 );
18 v.push_back( 5 );
19 v.push_back( 5 );
20 v.push_back( 5 );
21 v.push_back( 6 );
22 v.push_back( 5 );
23 v.push_back( 2 );
24
25 int iArray[ 6 ] = { 0 };
26 unique_copy(v.begin(), v.end(), iArray);
27
28 // 打印 2 5 6 5 2 0
29 for_each(iArray, iArray+ 6 , print);
30 cout << endl;
31
32 return 0 ;
33 }
应用 unique 算法剔除向量容器的连续重复元素
1 /* 下面示例程序将向量 v={2, 6, 6, 6, 9, 6, 3}的3个连续元素6剔除（仅保留1个），结果[first, result)元素为{2, 6, 9, 6, 3}，而向量v的元素变为{2, 6, 9, 6, 3, 6, 3}，最后的两个元素{6, 3}是原来向量容器保留下来的元素
2 */
3 ----------------------------------------------- 应用 unique 算法剔除向量容器的连续重复元素
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << " " ;
12 }
13
14 int main()
15 {
16 vector< int > v;
17 v.push_back( 2 );
18 v.push_back( 6 );
19 v.push_back( 6 );
20 v.push_back( 6 );
21 v.push_back( 9 );
22 v.push_back( 6 );
23 v.push_back( 3 );
24 vector< int >::iterator result = unique(v.begin(), v.end());
25
26 // 打印 2 6 9 6 3
27 for_each(v.begin(), result, print);
28 cout << endl << endl;
29
30 // 打印 2 6 9 6 3 6 3
31 for_each(v.begin(), v.end(), print);
32 cout << endl;
33
34 return 0 ;
35 }
应用 reverse 算法将向量容器的元素反向排列
1 /* 下面示例程序将向量 v={0, 1, 2, 3, 4, 5, 6, 7, 8, 9}，反向排列为 v={9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
2 */
3 ----------------------------------------------- 应用 reverse 算法将向量容器的元素反向排列
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << " " ;
12 }
13
14 int main()
15 {
16 vector< int > v( 10 );
17 for (size_t i= 0 ; i<v.size(); i++ )
18 v[i] = i;
19
20 for_each(v.begin(), v.end(), print);
21 cout << endl << endl;
22
23 reverse(v.begin(), v.end());
24 for_each(v.begin(), v.end(), print);
25 cout << endl;
26
27
28 return 0 ;
29 }
应用 reverse_copy 算法反向复制向量容器元素到数组
1 /* 下面示例程序将向量 v={0, 1, 2, 3, 4, 5, 6, 7, 8, 9}，反向复制到数组iArray，打印iArray为“9 8 7 6 5 4 3 2 1 0”
2 */
3 ----------------------------------------------- 应用 reverse_copy 算法反向复制向量容器元素到数组
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << " " ;
12 }
13
14 int main()
15 {
16 vector< int > v( 10 );
17 for (size_t i= 0 ; i<v.size(); i++ )
18 v[i] = i;
19
20 int iArray[ 10 ] = { 0 };
21 reverse_copy(v.begin(), v.end(), iArray);
22 for_each(iArray, iArray+ 10 , print);
23 cout << endl;
24
25 return 0 ;
26 }
应用 rotate 算法旋转向量容器元素
1 /* 下面示例程序旋转向量容器 v={1, 2, 3, 4, 5, 6, 7, 8, 9, 10}，middle支点选为整数8，旋转后打印输出为“8 9 10 1 2 3 4 5 6 7 ”
2 */
3 ----------------------------------------------- 应用 rotate 算法旋转向量容器元素
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << " " ;
12 }
13
14 int main()
15 {
16 vector< int > v( 10 );
17 for (size_t i= 0 ; i<v.size(); i++ )
18 v[i] = i+ 1 ;
19 for_each(v.begin(), v.end(), print);
20 cout << endl << endl;
21
22 // 旋转
23 cout << " 开始旋转，middle元素= " << *(v.begin() + 7 ) << endl;
24 rotate(v.begin(), v.begin()+ 7 , v.end());
25 for_each(v.begin(), v.end(), print);
26 cout << endl;
27
28 return 0 ;
29 }
应用 rotate_copy 算法旋转复制向量容器元素到数组
1 /* 下面示例程序旋转复制向量容器 v={1, 2, 3, 4, 5, 6, 7, 8, 9, 10}到数组iArray，middle支点选为整数8，iArray的打印输出为“8 9 10 1 2 3 4 5 6 7 ”
2 */
3 ----------------------------------------------- 应用 rotate_copy 算法旋转复制向量容器元素到数组
4 #include <algorithm>
5 #include <vector>
6 #include <iostream>
7 using namespace std;
8
9 void print( int x)
10 {
11 cout << x << " " ;
12 }
13
14 int main()
15 {
16 vector< int > v( 10 );
17 for (size_t i= 0 ; i<v.size(); i++ )
18 v[i] = i + 1 ;
19
20 int iArray[ 10 ] = { 0 };
21 cout << " 开始旋转复制，*middle 选为 " << *(v.begin()+ 7 ) << endl;
22 rotate_copy(v.begin(), v.begin()+ 7 , v.end(), iArray);
23 for_each(iArray, iArray+ 10 , print);
24 cout << endl;
25
26 return 0 ;
27 }
应用 random_shuffle 算法随机抖动向量容器的元素
1 /* 对容器内的元素进行随机的排序
2 */
3 ----------------------------------------------- 应用 random_shuffle 算法随机抖动向量容器的元素
4 #include <algorithm>
5 #include <iostream>
6 using namespace std;
7
8 void print( int x)
9 {
10 cout << x << " " ;
11 }
12
13 int main()
14 {
15 int iArray[ 10 ] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 };
16 cout << " 随机抖动iArray三次 " << endl;
17 for ( int i= 0 ; i< 3 ; i++ )
18 {
19 random_shuffle(iArray, iArray+ 10 );
20 for_each(iArray, iArray+ 10 , print);
21 cout << endl << endl;
22 }
23
24 return 0 ;
25 }
应用 partition 算法分割数组
1 /* 下面示例程序，将数组iArray 稳定分割为小于10 和不小于10两部分。
2 */
3 ----------------------------------------------- 应用 stable_partition 算法稳定分割数组
4 #include <algorithm>
5 #include <iostream>
6 using namespace std;
7
8 void print( int x)
9 {
10 cout << x << " " ;
11 }
12
13 bool less10( int x)
14 {
15 return x < 10 ? 1 : 0 ;
16 }
17
18 int main()
19 {
20 int iArray[ 10 ] = { 16 , - 1 , 3 , 11 , 2 , 5 , 8 , 20 , 9 , 3 };
21 for_each(iArray, iArray+ 10 , print);
22 cout << endl << endl;
23
24 // 进行稳定分割
25 int *result = stable_partition(iArray, iArray+ 10 , less10);
26 cout << " 按小于10稳定分割，iArray数组变为： " << endl;
27 for_each(iArray, iArray+ 10 , print);
28 cout << endl << endl;
29
30 cout << " iArray 数组有如下小于10 的整数: " << endl;
31 for_each(iArray, result, print);
32 cout << endl;
33
34 cout << " stable_partition算法返回的分界元素为： " << *result << endl;
35
36 return 0 ;
37 }
应用 stable_partition 算法稳定分割数组
1 /* 下面示例程序将数组 iArray={16, -1, 3, 11, 2, 5, 8, 20, 9, 3}，分割成小于10和不小于10两部分。
2 */
3 ----------------------------------------------- 应用 partition 算法分割数组
4 #include <algorithm>
5 #include <iostream>
6 using namespace std;
7
8 void print( int x)
9 {
10 cout << x << " " ;
11 }
12
13 // 小于10
14 bool less10( int x)
15 {
16 return x < 10 ? 1 : 0 ;
17 }
18
19 int main()
20 {
21 int iArray[ 10 ] = { 16 , - 1 , 3 , 11 , 2 , 5 , 8 , 20 , 9 , 3 };
22 int *result = partition(iArray, iArray+ 10 , less10);
23 cout << " 按小于10进行分割: " << endl;
24 for_each(iArray, iArray+ 10 , print);
25 cout << endl;
26 cout << " partition算法返回的分界元素为： " << *result << endl;
27
28 return 0 ;
29 }
------------------------- 变易算法小结
在C++ STL 算法库中，收集了一些会使操作数发生改变的常用算法，称为变易算法。
包括元素复制 copy/copy_backward 算法
两元素交换的 swap/iter_swap/swap_ranges 算法
进行元素变换的 transform 算法
元素替换处理的 replace/replace_if/replace_copy/replace_copy_if 算法
填充元素值的 fill/fill_n 算法
生成随机元素值的 generate/generate_n 算法
移除处理的 remove_copy/remove_copy_if/remove/remove_if 算法
剔除重复元素的 unique_copy/unique 算法
反向处理的 reverse/reverse_copy 算法
旋转处理的 rotate/totate_copy 算法
随机抖动的 random_shuffle 算法
容器分割的 partition/stable_partition 算法
===========================分享一个文件： STL帮助文档 ======================
作者： Music__Liang
出处： http://www.cnblogs.com/music-liang/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利.
作者： Leo_wl
出处： http://www.cnblogs.com/Leo_wl/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
版权信息声明：本文来自网络，不代表【好得很程序员自学网】立场，转载请注明出处：http://www.haodehen.cn/did46135