4.2 Algorithm Overview
Algorithm mainly header file <algorithm> <functional> <numeric> composition.
<Algorithm> header file is all STL largest of which involve relatively commonly used functions, exchange, search, traverse, copy, modify, reverse, sort, merge, and so on ...
<Numeric> small volume, simple template function includes only operations performed on the sequence of several containers.
<Functional> defines the template class to declare a function object.
4.3 Common traversal algorithm
| /* Traversal algorithm traverse the container elements @param beg begin iterator @param end the end iterator @param _callback callback or function object @return function object */ for_each(iterator beg, iterator end, _callback); /* transform algorithm specified container section element conveyed to another vessel Note: transform the target container does not allocate memory, so we need a good memory allocated in advance @param beg1 source container begin iterator @param end1 source container end iterator @param beg2 target vessel began iterator @param _cakkback callback function or function object @return return target container iterator */ transform(iterator beg1, iterator end1, iterator beg2, _callbakc) |
for_each:
| /*
template<class _InIt,class _Fn1> inline void for_each(_InIt _First, _InIt _Last, _Fn1 _Func) { for (; _First != _Last; ++_First) _Func(*_First); }
*/
// normal function void print01(int val){ cout << val << " "; } // function object struct print001{ void operator()(int val){ cout << val << " "; } };
//for_each算法基本用法 void test01(){
vector<int> v; for (int i = 0; i < 10;i++){ v.push_back(i); }
//遍历算法 for_each(v.begin(), v.end(), print01); cout << endl;
for_each(v.begin(), v.end(), print001()); cout << endl;
}
struct print02{ print02(){ mCount = 0; } void operator()(int val){ cout << val << " "; mCount++; } int mCount; };
//for_each返回值 void test02(){
vector<int> v; for (int i = 0; i < 10; i++){ v.push_back(i); }
print02 p = for_each(v.begin(), v.end(), print02()); cout << endl; cout << p.mCount << endl; }
struct print03 : public binary_function<int, int, void>{ void operator()(int val,int bindParam) const{ cout << val + bindParam << " "; } };
//for_each绑定参数输出 void test03(){
vector<int> v; for (int i = 0; i < 10; i++){ v.push_back(i); }
for_each(v.begin(), v.end(), bind2nd(print03(),100)); } |
transform:
| //transform 将一个容器中的值搬运到另一个容器中 /* template<class _InIt, class _OutIt, class _Fn1> inline _OutIt _Transform(_InIt _First, _InIt _Last,_OutIt _Dest, _Fn1 _Func) {
for (; _First != _Last; ++_First, ++_Dest) *_Dest = _Func(*_First); return (_Dest); }
template<class _InIt1,class _InIt2,class _OutIt,class _Fn2> inline _OutIt _Transform(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _OutIt _Dest, _Fn2 _Func) { for (; _First1 != _Last1; ++_First1, ++_First2, ++_Dest) *_Dest = _Func(*_First1, *_First2); return (_Dest); } */
struct transformTest01{ int operator()(int val){ return val + 100; } }; struct print01{ void operator()(int val){ cout << val << " "; } }; void test01(){
vector<int> vSource; for (int i = 0; i < 10;i ++){ vSource.push_back(i + 1); }
//目标容器 vector<int> vTarget; //给vTarget开辟空间 vTarget.resize(vSource.size()); //将vSource中的元素搬运到vTarget vector<int>::iterator it = transform(vSource.begin(), vSource.end(), vTarget.begin(), transformTest01()); //打印 for_each(vTarget.begin(), vTarget.end(), print01()); cout << endl;
}
//将容器1和容器2中的元素相加放入到第三个容器中 struct transformTest02{ int operator()(int v1,int v2){ return v1 + v2; } }; void test02(){
vector<int> vSource1; vector<int> vSource2; for (int i = 0; i < 10; i++){ vSource1.push_back(i + 1); }
//目标容器 vector<int> vTarget; //给vTarget开辟空间 vTarget.resize(vSource1.size()); transform(vSource1.begin(), vSource1.end(), vSource2.begin(),vTarget.begin(), transformTest02()); //打印 for_each(vTarget.begin(), vTarget.end(), print01()); cout << endl; } |
15 常用遍历算法
for_each 可以有返回值
可以绑定参数进行输出
transform 将容器中的数据进行搬运到另一个容器中
注意：目标容器需要开辟空间。
#include <iostream>
#include <algorithm>
#include <vector>
#include <functional> //bind2nd
using namespace std;
/*
遍历算法 遍历容器元素
@param beg 开始迭代器
@param end 结束迭代器
@param _callback 函数回调或者函数对象
@return 函数对象
*/
void myPr(int v){
cout<<v<<endl;
}
class myPr01{
public:
void operator()(int v){
cout<<v<<endl;
}
};
struct myPr02{
void operator()(int v){
cout<<v<<endl;
}
};
void test01(){
vector<int>v;
for(int i=0;i<10;i++){
v.push_back(i);
}
for_each(v.begin(),v.end(),myPr);
cout<<"--------------------"<<endl;
for_each(v.begin(),v.end(),myPr01());//类匿名对象
cout<<"--------------------"<<endl;
for_each(v.begin(),v.end(),myPr02());//结构体的匿名对象
}
class myPr03{
public:
void operator()(int v){
cout<<v<<endl;
m_Count++;
}
int m_Count;
};
//for_each 可以保存内部状态(有返回值)
void test02(){
vector<int>v;
for(int i=0;i<10;i++){
v.push_back(i);
}
myPr03 print2=for_each(v.begin(),v.end(),myPr03());
cout<<print2.m_Count<<endl;
}
//for_each 可以绑定参数进行输出
class myPr04:public binary_function<int,int,void>{
public:
void operator()(int v , int start ) const {
cout<<v+start<<endl;
}
};
void test03(){
vector<int>v;
for(int i=0;i<10;i++){
v.push_back(i);
}
for_each(v.begin(),v.end(),bind2nd(myPr04(),1000));
}
/*
transform算法 将指定容器区间元素搬运到另一容器中
注意 : transform 不会给目标容器分配内存，所以需要我们提前分配好内存
@param beg1 源容器开始迭代器
@param end1 源容器结束迭代器
@param beg2 目标容器开始迭代器
@param _cakkback 回调函数或者函数对象
@return 返回目标容器迭代器
*/
//transform(iterator beg1, iterator end1, iterator beg2, _callbakc)
//可以做搬运工的工作
class TransForm{
public:
int operator()(int val){
return val+10;//这里可能做运算，提供了这样的时机，仿函数协助算法完成不同的策略
}
};
void test04(){
vector<int>v;//作为原容器
for(int i=0;i<10;i++){
v.push_back(i);
}
vector<int>vTarget;//目标容器
//重点；提前预留内存
vTarget.resize(v.size());
transform(v.begin(),v.end(),vTarget.begin(),TransForm());
for_each(vTarget.begin(),vTarget.end(),[](int val){cout<<val<<endl;});
}
//transform第二种用法 把两个容器中的数据相加之后搬运到目标容器中
class TransForm2{
public:
int operator()(int val1,int val2){
return val1+val2;//这里可能做运算，提供了这样的时机，仿函数协助算法完成不同的策略
}
};
void test05(){
vector<int>v1;
vector<int>v2;
for(int i=0;i<10;i++){
v1.push_back(100+i);
v2.push_back(200+i);
}
vector<int>vTarget;//目标容器
vTarget.resize(v1.size());//v1 v2无所谓
transform(v1.begin(),v1.end(),v2.begin(),vTarget.begin(),TransForm2());
for_each(vTarget.begin(),vTarget.end(),[](int val){cout<<val<<endl;});
}
int main(){
// test01();
//test02();
//test03();
//test04();
test05();
return 0;
}
4.4 常用查找算法
| /* find算法 查找元素 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param value 查找的元素 @return 返回查找元素的位置 */ find(iterator beg, iterator end, value) /* find_if算法 条件查找 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param callback 回调函数或者谓词(返回bool类型的函数对象) @return bool 查找返回true 否则false */ find_if(iterator beg, iterator end, _callback);
/* adjacent_find算法 查找相邻重复元素 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param _callback 回调函数或者谓词(返回bool类型的函数对象) @return 返回相邻元素的第一个位置的迭代器 */ adjacent_find(iterator beg, iterator end, _callback); /* binary_search算法 二分查找法 注意: 在无序序列中不可用 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param value 查找的元素 @return bool 查找返回true 否则false */ bool binary_search(iterator beg, iterator end, value); /* count算法 统计元素出现次数 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param value回调函数或者谓词(返回bool类型的函数对象) @return int返回元素个数 */ count(iterator beg, iterator end, value); /* count算法 统计元素出现次数 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param callback 回调函数或者谓词(返回bool类型的函数对象) @return int返回元素个数 */ count_if(iterator beg, iterator end, _callback); |
16 常用查找算法
find 按值查找 Person
find_if 按条件查找 Person*
adjacent_find算法 查找相邻重复元素 返回第一个重复元素的迭代器位置
binary_search算法 二分查找法 容器必须是有序序列
count
count_if
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <functional>
using namespace std;
/*
find算法 查找元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value 查找的元素
@return 返回查找元素的位置
*/
void test01(){
vector<int>v;
for(int i=0;i<10;i++){
v.push_back(i);
}
vector<int>::iterator pos=find(v.begin(),v.end(),5);
if(pos!=v.end()){
cout<<"找打了数据:"<<*pos<<endl;
}
else {
cout<<"no find"<<endl;
}
}
//利用find查找自定义数据类型
class Person{
public:
Person(string name,int age){
this->m_Name=name;
this->m_Age=age;
}
string m_Name;
int m_Age;
bool operator==(const Person &p){
if(this->m_Name==p.m_Name&&this->m_Age==p.m_Age)
{
return true;
}
return false;
}
};
void test02(){
vector<Person> v;
Person p1("aaa",101);
Person p2("bbb",110);
Person p3("ccc",323);
Person p4("ddd",143);
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
vector<Person>::iterator pos=find(v.begin(),v.end(),p2);
if(pos!=v.end()){
cout<<"找打了数据~姓名:"<<(*pos).m_Name<<"年龄 "<<pos->m_Age<<endl;
}
else {
cout<<"no find"<<endl;
}
}
class myCom:public binary_function<Person*,Person*,bool>{
public:
bool operator()(Person * p1,Person *p2) const {
if(p1->m_Name==p2->m_Name && p1->m_Age==p2->m_Age)
{
return true;
}
return false;
}
};
void test03(){
vector<Person *> v;
Person p1("aaa",101);
Person p2("bbb",20);
Person p3("ccc",323);
Person p4("ddd",143);
v.push_back(&p1);
v.push_back(&p2);
v.push_back(&p3);
v.push_back(&p4);
Person *p=new Person("bbb",20);
vector<Person*>::iterator pos=find_if(v.begin(),v.end(),bind2nd(myCom(),p));
if(pos!=v.end()){
cout<<"already find !!!\n name:"<<(*pos)->m_Name<<"age:"<<(*pos)->m_Age<<endl;
}
else {
cout<<"no find!"<<endl;
}
}
//adjacent_find(iterator beg, iterator end, _callback);
/*
adjacent_find算法 查找相邻重复元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param _callback 回调函数或者谓词(返回bool类型的函数对象)
@return 返回相邻元素的第一个位置的迭代器
*/
void test04(){
vector<int>v;
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(4);
v.push_back(6);
v.push_back(22);
vector<int>::iterator pos= adjacent_find(v.begin(),v.end());
if(pos!=v.end()){
cout<<"the same elem already find !!!\n"<<*pos<<endl;
}
else {
cout<<"no find!"<<endl;
}
}
/*
binary_search算法 二分查找法
注意: 在无序序列中不可用
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value 查找的元素
@return bool 查找返回true 否则false
*/
//bool binary_search(iterator beg, iterator end, value);
//效率比较高，有序序列
void test05(){
vector<int>v;
for(int i=0;i<10;i++){
v.push_back(i);
}
if(binary_search(v.begin(),v.end(),4)){//返回值是bool类型
cout<<"already find!"<<endl;
}
}
/*
count算法 统计元素出现次数
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value回调函数或者谓词(返回bool类型的函数对象)
@return int返回元素个数
*/
//count(iterator beg, iterator end, value);
/*
count算法 统计元素出现次数
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param callback 回调函数或者谓词(返回bool类型的函数对象)
@return int返回元素个数
*/
//count_if(iterator beg, iterator end, _callback);
//count按值查找 count_if按条件查找
class greaterThanFour{
public:
bool operator()(int v){
return v>=4;
}
};
void test06(){
vector<int>v;
for(int i=0;i<10;i++){
v.push_back(i);
}
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(4);
v.push_back(6);
v.push_back(6);
v.push_back(6);
v.push_back(6);
v.push_back(22);
int num=count(v.begin(),v.end(),6);
//返回值int
cout<<"the 6 number is ："<<num<<endl;
num=count_if(v.begin(),v.end(),greaterThanFour());
cout<<"more than 4 number is ："<<num<<endl;
}
int main(){
// test01();
// test02();
// test03();
//test04();
// test05();
test06();
system("pause");
return 0;
}
（本笔记内容整理自网络资源，侵删）