第22章 变易算法 Modifying sequence operations
22.1 元素复制copy
copy Copy range of elements (function template)
22.2 反向复制copy_backward
copy_backward Copy range of elements backwards (function template)
22.3 元素交换swap
swap Exchange values of two objects (function template)
22.4 迭代器交换iter_swap
iter_swap Exchange values of objects pointed by two iterators (function template)
22.5 区间元素交换swap_ranges
swap_ranges Exchange values of two ranges (function template)
22.6 元素变换transform
transform Apply function to range (function template)
22.7 替换Replace
replace Replace value in range (function template)
22.8 条件替换replace_if
replace_if Replace values in range (function template)
22.9 替换和复制replace_copy
replace_copy Copy range replacing value (function template)
22.10 条件替换和复制replace_copy_if
replace_copy_if Copy range replacing value (function template)
22.11 填充fill
fill Fill range with value (function template)
22.12 n次填充fill_n
fill_n Fill sequence with value (function template)
22.13 随机生成元素generate
generate Generate values for range with function (function template)
22.14 随机生成n个元素generate_n
generate_n Generate values for sequence with function (function template)
22.15 移除复制remove_copy
remove_copy Copy range removing value (function template)
22.16 条件移除复制remove_copy_if
remove_copy_if Copy range removing values (function template)
22.17 移除remove
remove Remove value from range (function template)
22.18 条件移除remove_if
remove_if Remove elements from range (function template)
22.19 不连续重复元素复制unique_copy
unique_copy Copy range removing duplicates (function template)
22.20 剔除连续重复元素unique
unique Remove consecutive duplicates in range (function template)
22.21 元素反向reverse
reverse Reverse range (function template)
22.22 反向复制reverse_copy
reverse_copy Copy range reversed (function template)
22.23 旋转rotate
rotate Rotate elements in range (function template)
22.24 旋转复制rotate_copy
rotate_copy Copy rotated range (function template)
22.25 随机抖动random_shuffle
random_shuffle Rearrangle elements in range randomly (function template)
22.26 随机采样random_sample
...
22.27 容器分割partition
partition Partition range in two (function template)
22.28 容器稳定分割stable_partition
stable_partition Divide range in two groups - stable ordering (function template)
22.29 本章小结
/* 第22章 变易算法 22.1 元素复制copy 22.2 反向复制copy_backward 22.3 元素交换swap 22.4 迭代器交换iter_swap 22.5 区间元素交换swap_ranges 22.6 元素变换transform 22.7 替换Replace 22.8 条件替换replace_if 22.9 替换和复制replace_copy 22.10 条件替换和复制replace_copy_if 22.11 填充fill 22.12 n次填充fill_n 22.13 随机生成元素generate 22.14 随机生成n个元素generate_n 22.15 移除复制remove_copy 22.16 条件移除复制remove_copy_if 22.17 移除remove 22.18 条件移除remove_if 22.19 不连续重复元素复制unique_copy 22.20 剔除连续重复元素unique 22.21 元素反向reverse 22.22 反向复制reverse_copy 22.23 旋转rotate 22.24 旋转复制rotate_copy 22.25 随机抖动random_shuffle 22.26 随机采样random_sample 22.27 容器分割partition 22.28 容器稳定分割stable_partition 22.29 本章小结 第22章 变易算法 Modifying sequence operations: 22.1 元素复制copy copy Copy range of elements (function template) 22.2 反向复制copy_backward copy_backward Copy range of elements backwards (function template) 22.3 元素交换swap swap Exchange values of two objects (function template) 22.4 迭代器交换iter_swap iter_swap Exchange values of objects pointed by two iterators (function template) 22.5 区间元素交换swap_ranges swap_ranges Exchange values of two ranges (function template) 22.6 元素变换transform transform Apply function to range (function template) 22.7 替换Replace replace Replace value in range (function template) 22.8 条件替换replace_if replace_if Replace values in range (function template) 22.9 替换和复制replace_copy replace_copy Copy range replacing value (function template) 22.10 条件替换和复制replace_copy_if replace_copy_if Copy range replacing value (function template) 22.11 填充fill fill Fill range with value (function template) 22.12 n次填充fill_n fill_n Fill sequence with value (function template) 22.13 随机生成元素generate generate Generate values for range with function (function template) 22.14 随机生成n个元素generate_n generate_n Generate values for sequence with function (function template) 22.15 移除复制remove_copy remove_copy Copy range removing value (function template) 22.16 条件移除复制remove_copy_if remove_copy_if Copy range removing values (function template) 22.17 移除remove remove Remove value from range (function template) 22.18 条件移除remove_if remove_if Remove elements from range (function template) 22.19 不连续重复元素复制unique_copy unique_copy Copy range removing duplicates (function template) 22.20 剔除连续重复元素unique unique Remove consecutive duplicates in range (function template) 22.21 元素反向reverse reverse Reverse range (function template) 22.22 反向复制reverse_copy reverse_copy Copy range reversed (function template) 22.23 旋转rotate rotate Rotate elements in range (function template) 22.24 旋转复制rotate_copy rotate_copy Copy rotated range (function template) 22.25 随机抖动random_shuffle random_shuffle Rearrangle elements in range randomly (function template) 22.26 随机采样random_sample ... 22.27 容器分割partition partition Partition range in two (function template) 22.28 容器稳定分割stable_partition stable_partition Divide range in two groups - stable ordering (function template) 22.29 本章小结 */
第22章 变易算法
Modifying sequence operations:
22.1 元素复制copy
copy Copy range of elements (function template)
// 第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
copy_backward Copy range of elements backwards (function template)
// 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
swap Exchange values of two objects (function template)
// 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
iter_swap Exchange values of objects pointed by two iterators (function template)
// 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
swap_ranges Exchange values of two ranges (function template)
// 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
transform Apply function to range (function template)
// 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 替换Replace
replace Replace value in range (function template)
// 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
replace_if Replace values in range (function template)
// 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
replace_copy Copy range replacing value (function template)
// 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
replace_copy_if Copy range replacing value (function template)
// 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
fill Fill range with value (function template)
// 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
fill_n Fill sequence with value (function template)
// 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
generate Generate values for range with function (function template)
// 22.13 随机生成元素generate ---------------------------------------------------
template <class ForwardIterator, class Generator>
void generate ( ForwardIterator first, ForwardIterator last, Generator gen )
{
while (first != last) *first++ = gen();
}
// 在指定范围内，填充上第三个参数gen产生的值。
// gen是个函数（对象），木有参数。所以产生的值，纯粹取决于gen，与容器原来的元素无关
// generate algorithm example
#include <iostream>
#include <algorithm>
#include <vector>
#include <ctime>
#include <cstdlib>
using namespace std;
// function generator:
int RandomNumber () { return (rand()%100); } // 产生一百以内的随机数
// class generator:
struct c_unique {
int current;
c_unique() {current=0;} // 构造函数，设成员current初始值为0
int operator()() {return ++current;} // 调用操作符()重载，使此类能产生函数对象
} UniqueNumber;
int main () {
srand ( unsigned ( time(NULL) ) );
vector<int> myvector (8);
vector<int>::iterator it;
generate (myvector.begin(), myvector.end(), RandomNumber);
cout << "myvector contains:";
for (it=myvector.begin(); it!=myvector.end(); ++it)
cout << " " << *it;
generate (myvector.begin(), myvector.end(), UniqueNumber);
cout << "\nmyvector contains:";
for (it=myvector.begin(); it!=myvector.end(); ++it)
cout << " " << *it;
cout << endl;
return 0;
}
//316
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
//等差数列an+1=an + 3
class sequence
{
public:
int a;
sequence(){ a = 0; } // 构造函数
inline int operator()() // 重载()
{
//a = a + 3;
//return a;
return a+=3;
}
};
void print(int x)
{
cout << x << endl;
}
int main(void)
{
vector < int > v(10);
sequence an;
generate(v.begin(), v.end(), an);
for_each(v.begin(), v.end(), print);
cout << endl;
return 0;
}
22.14 随机生成n个元素generate_n
generate_n Generate values for sequence with function (function template)
// 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
remove_copy Copy range removing value (function template)
// 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
remove_copy_if Copy range removing values (function template)
// 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
remove Remove value from range (function template)
// 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
remove_if Remove elements from range (function template)
// 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
unique_copy Copy range removing duplicates (function template)
// 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
unique Remove consecutive duplicates in range (function template)
// 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
reverse Reverse range (function template)
// 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
reverse_copy Copy range reversed (function template)
// 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
rotate Rotate elements in range (function template)
// 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
rotate_copy Copy rotated range (function template)
// 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
random_shuffle Rearrangle elements in range randomly (function template)
// 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
...
// 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
partition Partition range in two (function template)
// 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
stable_partition Divide range in two groups - stable ordering (function template)
// 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.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 本章小结 // 这就是小结 ***********************************************************************************************************/
00TOP00
时间： 2024-10-29 19:08:42