STL常用算法（复制、交换、替换、填充、生成、删除、排序、集合操作）

//变异算法

#include"iostream"
using namespace std;
#include"vector"
#include"string"
#include"algorithm"
#include"functional"
#include"iterator"
#include"stdlib.h"
#include"time.h"
/*复制*/
//copy和copy_backward
void print(int &n)
{
cout << n << " ";
}

void main01()
{
int a[20];
for (int i = 0; i < 20; i++)
{
a[i] = rand() % 100;
}
vector<int>v1(a,a+sizeof(a)/sizeof(int));
cout << "V1的数值：";
for_each(v1.begin(), v1.end(), print);
cout << endl;

//copy:从序列的第一个元素起进行正向复制；
vector<int>v2;
v2.resize(v1.size());//先要给V2分配好内存；
cout << "copy后V2的数值：";
copy(v1.begin(),v1.end(),v2.begin());
for_each(v2.begin(),v2.end(),print);
cout << endl;

//copy:从序列的最后一个元素起进行反向复制；
vector<int>v3;
v3.resize(v1.size());
cout << "copy_backward后v3的数值：";
copy_backward(v1.begin(), v1.end(), v3.end());
for_each(v3.begin(), v3.end(), print);
cout << endl;

}
/*交换*/
//swap,swap_ranges,iter_swap
//对基本类型可用swap,iter_swap，对数组只能用swap_ranges,对基本序列容器三个函数均可；
void main02()
{
int a[20];
for (int i = 0; i < 20; i++)
{
a[i] = rand() % 100;
}
vector<int>v1(a, a + sizeof(a) / sizeof(int));
cout << "V1的数值：";
for_each(v1.begin(), v1.end(), print);
cout << endl;

/*swap:交换两个元素*/
/*void swap(vector<_Ty, _Alloc>& _Left, vector<_Ty, _Alloc>& _Right)*/
vector<int>v2(20);
swap(v1,v2);
cout << "V1的数值：";
for_each(v1.begin(), v1.end(), print);//V1=00000000000000000000;
cout << endl;

/*swap_ranges交换指定范围内元素*/
/*template<class _FwdIt1,
class _FwdIt2> inline
_FwdIt2 swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1,
_FwdIt2 _Dest)
{	// swap [_First1, _Last1) with [_Dest, ...)
_DEBUG_RANGE(_First1, _Last1);
_DEBUG_POINTER(_Dest);
return (_Swap_ranges(_Unchecked(_First1), _Unchecked(_Last1),
_Dest, _Is_checked(_Dest)));
}*/
swap_ranges(v1.begin(), v1.begin() + 10, v2.begin());
for_each(v1.begin(), v1.end(), print);
cout << endl;
swap_ranges(v1.begin()+10, v1.end(), v2.begin()+10);
for_each(v1.begin(), v1.end(), print);
cout << endl;

/*iter_swap交换由迭代器所指的两个元素*/
iter_swap(&v1,&v2);
for_each(v1.begin(), v1.end(), print);//V1=00000000000000000000;
}
/*变换*/
//transform

/*替换*/
//repalce、replace_if、replace_copy、replace_copy_if
bool replaceif1(int &n)
{
if (n > 50)
return true;
else
return false;
}
bool replaceif2(int &n)
{
if (n > 100)
return true;
else
return false;
}
void main03()
{
int a[20];
for (int i = 0; i < 20; i++)
{
a[i] = rand() % 100;
}
vector<int>v1(a, a + sizeof(a) / sizeof(int));
cout << "V1的数值：";
for_each(v1.begin(), v1.end(), print);//V1的数值：41 67 34 0 69 24 78 58 62 64 5 45 81 27 61 91 95 42 27 36
cout << endl;

//replace(): 用一个给定值替换一些值；
/*template<class _FwdIt,
class _Ty> inline
void replace(_FwdIt _First, _FwdIt _Last,
const _Ty& _Oldval, const _Ty& _Newval)
{	// replace each matching _Oldval with _Newval
_DEBUG_RANGE(_First, _Last);
_Replace(_Unchecked(_First), _Unchecked(_Last),
_Oldval, _Newval);
}*/
replace(v1.begin(),v1.end(),5,0); // 将所有的5变成0.
cout << "V1的数值：";
for_each(v1.begin(), v1.end(), print);//V1的数值：41 67 34 0 69 24 78 58 62 64 0 45 81 27 61 91 95 42 27 36
cout << endl;

//replace_if(),替换满足谓词的一些元素
/*template<class _FwdIt,
class _Pr,
class _Ty> inline
void replace_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty& _Val)
{	// replace each satisfying _Pred with _Val
_DEBUG_RANGE(_First, _Last);
_DEBUG_POINTER(_Pred);
_Replace_if(_Unchecked(_First), _Unchecked(_Last),
_Pred, _Val);
}*/
vector<int>v2 = v1;
replace_if(v2.begin(), v2.end(), replaceif1, 200);
cout << "V2的数值：";
for_each(v2.begin(), v2.end(), print);//V2的数值：41 200 34 0 200 24 200 200 200 200 0 45 200 27 200 200 200 42 27 36
cout << endl;

//replace_copy:复制序列时用一给定值替换元素；
/*template<class _InIt,
class _OutIt,
class _Ty> inline
_OutIt replace_copy(_InIt _First, _InIt _Last,
_OutIt _Dest, const _Ty& _Oldval, const _Ty& _Newval)
{	// copy replacing each matching _Oldval with _Newval
_DEBUG_RANGE(_First, _Last);
_DEBUG_POINTER(_Dest);
return (_Replace_copy(_Unchecked(_First), _Unchecked(_Last),
_Dest, _Oldval, _Newval,
_Is_checked(_Dest)));
}*/
vector<int>v3 = v2;
v3.resize(v2.size());
replace_copy(v2.begin(),v2.end(),v3.begin(),200,101);
cout << "V3的数值：";
for_each(v3.begin(), v3.end(), print);//V3的数值：41 101 34 0 101 24 101 101 101 101 0 45 101 27 101 101 101 42 27 36
cout << endl;

//replace_copy_if:复制序列时替换满足谓词de元素；
vector<int>v4 = v3;
v4.resize(v3.size());
replace_copy_if(v3.begin(), v3.end(), v4.begin(), replaceif2, 111);
cout << "V4的数值：";
for_each(v4.begin(), v4.end(), print);//V4的数值：41 111 34 0 111 24 111 111 111 111 0 45 111 27 111 111 111 42 27 36
cout << endl;
}

//*填充*
//fill(),fill_n();
void main04()
{
//fill():同一给定值填充所有元素
int a[20];
for (int i = 0; i < 20; i++)
{
a[i] = rand() % 100;
}
vector<int>v1(a, a + sizeof(a) / sizeof(int));
cout << "V1的数值：";
for_each(v1.begin(), v1.end(), print);//V1的数值：41 67 34 0 69 24 78 58 62 64 5 45 81 27 61 91 95 42 27 36
cout << endl;
fill(v1.begin(),v1.end(),1);
cout << "V1的数值：";
for_each(v1.begin(), v1.end(), print);//V1的数值：1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
cout << endl;

//fill_n():用一给定值填充前n个元素
fill_n(v1.begin()+5,10,0);
cout << "V1的数值：";
for_each(v1.begin(), v1.end(), print);//V1的数值：1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1
cout << endl;
}
/*生成*/
//generate、generate_n
int generate_print1()
{
return 100;

}
int generate_print2()
{
return 0;

}
void main05()
{
int a[20];
for (int i = 0; i < 20; i++)
{
a[i] = rand() % 100;
}
vector<int>v1(a, a + sizeof(a) / sizeof(int));
cout << "V1的数值：";
for_each(v1.begin(), v1.end(), print);//V1的数值：41 67 34 0 69 24 78 58 62 64 5 45 81 27 61 91 95 42 27 36
cout << endl;
//generate:返回一操作结果填充所有元素；
generate(v1.begin(), v1.end(), generate_print1);
cout << "V1的数值：";
for_each(v1.begin(), v1.end(), print);//V1的数值：100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100
cout << endl;
//generate_n:返回一操作结果填充前n个元素；
generate_n(v1.begin()+5, 10, generate_print2);
cout << "V1的数值：";
for_each(v1.begin(), v1.end(), print);//V1的数值：100 100 100 100 100 0 0 0 0 0 0 0 0 0 0 100 100 100 100 100
cout << endl;

}
/*删除*/
//remove、remove_if、remove_copy、remove_copy_if
bool remove_print(int n)
{
if (n > 50)
return true;
else
return false;

}
void main06()
{
int a[20];
//srand函数，产生不同的随机数组；
//srand(11);
for (int i = 0; i < 20; i++)
{
a[i] = rand() % 100;
}
vector<int>v1(a, a + sizeof(a) / sizeof(int));
cout << "V1的数值：";
for_each(v1.begin(), v1.end(), print);//V1的数值：41 67 34 0 69 24 78 58 62 64 5 45 81 27 61 91 95 42 27 36
cout << endl;
//remove:删除具有给定值的元素
/*remove删除原理：粗指针和细指针*/
remove(v1.begin(),v1.end(),0);
cout << "V1的数值：";
for_each(v1.begin(), v1.end(), print);//V1的数值：41 67 34 69 24 78 58 62 64 5 45 81 27 61 91 95 42 27 36    36(非有效)
cout << endl;

//remove_if：删除满足谓词的元素
remove_if(v1.begin(),v1.end(),remove_print);
cout << "V1的数值：";
for_each(v1.begin(), v1.end(), print);//V1的数值：41 34 24 5 45 27 42 27 36 36    45 81 27 61 91 95 42 27 36 36(非有效)
cout << endl;
//remove_copy:复制序列时删除具有给定值的元素
//remove_copy_if：复制序列时删除满足谓词的元素
}
/*排序*/
//merge、sort、random_shuffle、reverse
bool sort_print(int a,int b)
{
return (a>b);
}
void main07()
{
int a[10],b[10];
srand(0);
for (int i = 0; i < 10; i++)
{
a[i] = rand() % 100;

}
srand(1);
for (int i = 0; i < 10; i++)
{
b[i] = rand() % 100;
}
vector<int>v1(a, a + sizeof(a) / sizeof(int));
vector<int>v2(b, b + sizeof(b) / sizeof(int));
cout << "V1的数值：";
for_each(v1.begin(), v1.end(), print);
cout << endl;
cout << "V2的数值：";
for_each(v2.begin(), v2.end(), print);
cout << endl;

//merge：归并：合并两个有序序列， 存放到另一个序列。
vector<int> v3(20);
sort(v1.begin(),v1.end());
sort(v2.begin(), v2.end());
merge(v1.begin(),v1.end(),v2.begin(),v2.end(),v3.begin());//V3的数值：0 12 19 24 34 37 38 38 41 50 55 58 62 64 65 67 69 78 85 97
cout << "V3的数值：";
for_each(v3.begin(), v3.end(), print);
cout << endl;

//sort: sort: 以默认升序的方式重新排列指定范围内的元素。 若要改排序规则， 可以输入比较函数。
sort(v3.begin(), v3.end(), sort_print);
cout << "V3的数值：";
for_each(v3.begin(), v3.end(), print);//V3的数值：97 85 78 69 67 65 64 62 58 55 50 41 38 38 37 34 24 19 12 0
cout << endl;

//reverse:反转
reverse(v3.begin(), v3.end());
cout << "V3的数值：";
for_each(v3.begin(), v3.end(), print);//V3的数值：0 12 19 24 34 37 38 38 41 50 55 58 62 64 65 67 69 78 85 97
cout << endl;

//random_shuffle:对指定范围内的元素随机调整次序。
random_shuffle(v3.begin(), v3.end());
cout << "V3的数值：";
for_each(v3.begin(), v3.end(), print);//V3的数值：0 85 55 65 67 62 69 50 41 12 64 38 24 34 58 78 37 19 97 38
cout << endl;

}
/*集合
20000
操作*/
//include、set_union、set_difference、set_intersection
void main08()
{//include：一个序列为另一个序列的子序列时为真；
int a[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int b[5] = {1,2,3,4,5};
vector<int>v1(a, a + sizeof(a) / sizeof(int));
vector<int>v2(b, b + sizeof(b) / sizeof(int));
bool c1 = includes(v1.begin(),v1.end(),v2.begin(),v2.end());//测试 v1是否包含v2
cout << "c1= " << c1 << endl;//1

//set_union：构造两个集合的有序并集
vector<int>v3(15);
set_union(v1.begin(),v1.end(),v2.begin(),v2.end(),v3.begin());
cout << "V3的数值：";
for_each(v3.begin(), v3.end(), print);//V3的数值：0 1 2 3 4 5 6 7 8 9 0 0 0 0 0
cout << endl;

//set_intersection:构造两个集合的有序交集
vector<int>v4(15);
set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), v4.begin());
cout << "V4的数值：";
for_each(v4.begin(), v4.end(), print);//V4的数值：1 2 3 4 5 0 0 0 0 0 0 0 0 0 0
cout << endl;

//set_difference:构造两个集合的有序差集，构造一个有序序列，
//该序列保留第一个有序序列中存在而第二个有序序列中不存在的元素。
vector<int>v5(15);
set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), v5.begin());
cout << "V5的数值：";
for_each(v5.begin(), v5.end(), print);//V5的数值：0 6 7 8 9 0 0 0 0 0 0 0 0 0 0
cout << endl;
}
int main()
{
//main01();//复制：copy和copy_backward
//main02();//交换：swap,swap_ranges,iter_swap
//main03();//替换：repalce、replace_if（一元）、replace_copy、replace_copy_if（一元）
//main04();//填充：fill、fill_n;
//main05();//生成：generate、generate_n
//main06();//删除：remove、remove_if、remove_copy、remove_copy_if
//main07();//排序：merge、sort、random_shuffle、reverse
main08();//集合操作：include、set_union、set_difference、set_intersection
system("pause");
return 0;
}

综合案例：

1） 某市举行一场演讲比赛（speech_contest ）， 共有 24 个人参加。 比赛共三轮， 前两轮为淘汰赛， 第三轮为决赛。
2） 比赛方式： 分组比赛， 每组 6 个人； 选手每次要随机分组， 进行比赛；
//第一轮分为 4 个小组， 每组 6 个人。 比如 100 - 105 为一组， 106 - 111 为第二组， 依次类推，每人分别按照抽签（draw） 顺序演讲。 当小组演讲完后， 淘汰组内排名最后的三个选手，然后继续下一个小组的比赛。
//第二轮分为 2 个小组， 每组 6 人。 比赛完毕， 淘汰组内排名最后的三个选手， 然后继续下一个小组的比赛。
//第三轮只剩下 6 个人， 本轮为决赛， 选出前三名。
3） 比赛评分： 10 个评委打分， 去除最低、 最高分， 求平均分
//每个选手演讲完由 10 个评委分别打分。 该选手的最终得分是去掉一个最高分和一个最
//低分， 求得剩下的 8 个成绩的平均分。
//选手的名次按得分降序排列， 若得分一样， 按参赛号升序排名。
用 STL 编程， 求解这个问题
//1） 请打印出所有选手的名字与参赛号， 并以参赛号的升序排列。
//2） 打印每一轮比赛后， 小组比赛成绩和小组晋级名单

//3） 打印决赛前三名， 选手名称、 成绩。

需求分析
//产生选手 （ABCDEFGHIJKLMNOPQRSTUVWXYZ ） 姓名、 得分； 选手编号
//第 1 轮 选手抽签 选手比赛 查看比赛结果
//第 2 轮 选手抽签 选手比赛 查看比赛结果
//第 3 轮 选手抽签 选手比赛 查看比赛结果


实现思路
//需要把选手信息、 选手得分信息、 选手比赛抽签信息、 选手的晋级信息保存在容器中， 需要涉及到各个容器的选型。
//选手可以设计一个类 Speaker（姓名和得分）
//所有选手编号和选手信息， 可以放在容器内： map<int, Speaker>
//所有选手的编号信息， 可以放在容器： vecter<int> v1 中
//第 1 轮晋级名单， 可以放在容器 vecter<int> v2 中
//第 2 轮晋级名单， 可以放在容器 vecter<int> v3 中
//第 3 轮前三名名单， 可以放在容器 vecter<int> v4 中
//每个小组的比赛得分信息， 按照从小到大的顺序放在
//multimap<成绩, 编号, greater<int>> multmapGroup也就是： multimap<int, int, greater<int> > multmapGroup;
//每个选手的得分， 可以放在容器 deque<int> dscore; 方便去除最低最高分

#include"iostream"
using namespace std;
#include"vector"
#include"algorithm"
#include"functional"
#include"string"
#include"map"
#include"deque"
#include"iterator"
#include"numeric"

class Speaker
{
public:

string name;
int score;
};
// 产生选手
int GenSpeaker(map<int, Speaker> &mapSpeaker, vector<int> &v1)
{
string str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
random_shuffle(str.begin(),str.end());
for (int i = 0; i < 24; i++)
{
Speaker tem;
tem.name = "选手";
tem.name = tem.name + str[i];//命名
mapSpeaker.insert(pair<int,Speaker>(100+i,tem));//编号和speaker信息放入到map容器中

}
for (int i = 0; i < 24; i++)
{
v1.push_back(100+i);//将编号信息放入到vector容器中，参加比赛的人员
}

return 0;
}

//选手抽签
int speech_contest_draw(vector<int> &v)
{
random_shuffle(v.begin(),v.end());  //对选手编号进行随机排序
return 0;
}
//选手比赛
int speech_contest(int index, vector<int> &v1, map<int, Speaker> &mapSpeaker, vector<int>&v2)
{//小组分组，记录得分，小组成绩
multimap<int, int, greater<int> >mutimapGroup;
int tep = 0;
for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++)
{

//打分
deque<int>dscore;
{tep++;
for (int j = 0; j < 10; j++)
{
int score = 50 + rand() % 50;
dscore.push_back(score);
}
sort(dscore.begin(),dscore.end());//排序

dscore.pop_back();
dscore.pop_front();	//去掉最高分和最低分

//求平均分
int scoredeque = accumulate(dscore.begin(), dscore.end(), 0);
int scoreave = scoredeque / dscore.size();
mapSpeaker[*it].score= scoreave;//选手得分存到容器中
mutimapGroup.insert(pair<int, int>(scoreave,*it));
}
//分组
if (tep % 6 == 0)
{
cout << "小组比赛成绩："<<endl;
for (multimap<int, int, greater<int> >::iterator mit = mutimapGroup.begin(); mit != mutimapGroup.end(); mit++)
{
//编号 姓名 得分
cout << mit->second << "\t" << mapSpeaker[mit->second].name << "\t" << mit->first << endl;
}
//前三名晋级
while (mutimapGroup.size() > 3)
{
multimap<int, int, greater<int> >::iterator mit1 = mutimapGroup.begin();
v2.push_back(mit1->second);//前三名晋级名单放到V2中
mutimapGroup.erase(mit1);
}
mutimapGroup.clear();//清空本小组比赛
}

}

return 0;
}
//打印选手比赛晋级名单
int speech_contest_print(int index, vector<int> v, map<int, Speaker> & mapSpeaker)
{
cout << "第" << index+1 << "轮晋级名单" << endl;
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << "参赛人员名单：" << *it << "\t" << mapSpeaker[*it].name << "\t" << mapSpeaker[*it].score << endl;
}

return 0;
}
int main()
{//定义数据结构 所有选手放到容器中
map<int, Speaker> mapSpeaker;
vector<int> v1; //第 1 轮演讲比赛 名单
vector<int> v2; //第 2 轮演讲比赛 名单
vector<int> v3; //第 3 轮演讲比赛 名单
vector<int> v4; //最后 演讲比赛 名单

//产生选手
GenSpeaker(mapSpeaker, v1); //第一轮选手信息
//第 1 轮 选手抽签 选手比赛 查看比赛结果(晋级名单 得分情况)
cout << "\n\n\n 任意键,开始第一轮比赛" << endl;
cin.get();
speech_contest_draw(v1);//选手抽签
speech_contest(0, v1, mapSpeaker, v2);  //第一轮、选手参赛名单、选手得分、结果名单
speech_contest_print(0, v2, mapSpeaker);//查看比赛结果

//第 2 轮 选手抽签 选手比赛 查看比赛结果
cout << "\n\n\n 任意键,开始第二轮比赛" << endl;
cin.get();
speech_contest_draw(v2);
speech_contest(1, v2, mapSpeaker, v3);
speech_contest_print(1, v3, mapSpeaker);

//第 3 轮 选手抽签 选手比赛 查看比赛结果
cout << "\n\n\n 任意键,开始第三轮比赛" << endl;
cin.get();
speech_contest_draw(v3);
speech_contest(2, v3, mapSpeaker, v4);
speech_contest_print(2, v4, mapSpeaker);

system("pause");
return 0;
}

阅读更多