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 算法替换向量中奇数值的元素
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 算法将值为1的元素替换后拷贝到新容器
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 }
应用 replace_copy_if 算法将奇数元素替换后拷贝到新容器
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 算法容器填充向量容器
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 }
应用 fill_n 算法填充向量容器
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 算法将一个数列生成到向量容器
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 }
应用 generate_n 算法将3个伪随机数生成到向量容器
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 算法将向量容器不包含4的元素拷贝到数组
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_copy_if 算法将向量容器中奇数元素拷贝到数组
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 算法将向量容器中的某值元素移除
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 }
应用 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 }
应用 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={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 }
应用 stable_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 }
------------------------- 变易算法小结
在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帮助文档======================
