《c++程序标准库》中的 STL算法 学习总结

头文件algo.hpp

#include <iostream>#include <vector>#include <deque>#include <list>#include <set>#include <map>#include <string>#include <algorithm>#include <functional>#include <numeric>template <class T>inline void PRINT_ELE(const T &coll,const char *optcstr=" "){typename T::const_iterator pos;std::cout<<optcstr;for( pos=coll.begin();pos!=coll.end();++pos){std::cout<<*pos<<' ';}std::cout<<std::endl;}template <class T>inline void INSERT_ELE(T &coll,int first,int last){for(int i=first;i<=last;++i){coll.insert(coll.end(),i);}}

具体算法的each.cpp算法：

#include "algo.hpp"
#include <cstdlib>
#include <iterator>
using namespace std;
/* *******  334
void print(int elem)
{
cout<<elem<<' ';
}
int main()
{
vector<int>coll;
INSERT_ELE(coll,1,9);
for_each(coll.begin(),coll.end(),print);
cout<<endl;
system("pause");
}
//********p335
template <class T>
class AddValue
{
private  :
T theValue;
public:
AddValue(const T &v):theValue(v){}
void operator() (T& elem)const 
{
elem+= theValue;
}
};
int main()
{
vector<int> coll;
INSERT_ELE(coll,1,9);
for_each(coll.begin(),coll.end(),AddValue<int>(10));
PRINT_ELE(coll);
for_each(coll.begin(),coll.end(),AddValue<int>(*coll.begin()));
PRINT_ELE(coll);
system("pause");




}
//********p336
class MeanValue
{
private:
long num;
long sum;
public:
MeanValue():num(0),sum(0){}
void operator()(int elem)
{
num++;
sum+= elem;
}
operator double()
{
return static_cast<double>(sum)/static_cast<double>(num);
}


};
int main()
{
vector<int>coll;
INSERT_ELE(coll,1,8);
double mv=for_each(coll.begin(),coll.end(),MeanValue());
cout<<"mean value:" <<mv<<endl;
system("pause");
}
//p*******338


bool isEven (int elem)
{
return elem%2==0;
}
int main()
{
vector<int> coll;
int num;
INSERT_ELE(coll,1,9);
PRINT_ELE(coll,"coll:");
num =count(coll.begin(),coll.end(),4);
cout<<"number of elements equal to 4:"<<num<<endl;
num=count_if(coll.begin(),coll.end(),isEven);
cout<<"number of elements with even value:"<<num<<endl;
num=count_if(coll.begin(),coll.end(),bind2nd(greater<int>(),4));
cout<<"number of elements greater than 4:"<<num<<endl;
system("pause");
return 0;
}
//340最大值 最小值


bool absLess(int elem1,int elem2)
{
return abs(elem1) <abs(elem2);
}
int main()
{
deque<int>coll;
INSERT_ELE(coll,2,8);
INSERT_ELE(coll,-3,5);
PRINT_ELE(coll);
cout<<"mininum:"<<*min_element(coll.begin(),coll.end())<<endl;
cout<<"maxinum"<<*max_element(coll.begin(),coll.end())<<endl;


cout<<"minunum of absolute values:"<<*min_element(coll.begin(),coll.end(),absLess)<<endl;


cout<<"maximum of absolute values:"<<*max_element(coll.begin(),coll.end(),absLess)<<endl;
system("pause");
return 0;


}
//搜寻元素find find_if p341
//min_element(inputiterator beg,inputiterator end)
//min_element(inputiterator beg,inputitreator en,comfunc op)
//返回区间【beg，end】中最小或者最大元素的位置
//op用来比较两个元素 op(elem1,elem2)如果第一个元素小于第二个元素，应当返回true
//op不应该改变传入的参数
//复杂度线性
int main()
{
list<int>coll;
INSERT_ELE(coll,1,9);
INSERT_ELE(coll,1,9);


PRINT_ELE(coll,"coll:");
list<int>::iterator pos1;
pos1=find(coll.begin(),coll.end(),4);
cout<<*pos1<<endl;
list<int>::iterator pos2;
if(pos1!=coll.end())
{
pos2=find(++pos1,coll.end(),4);
}
if(pos1!=coll.end()&& pos2!=coll.end())
{
copy(--pos1,++pos2,ostream_iterator<int>(cout," "));//区间不太明白？？？？？
cout<<endl;
}
system("pause");
return 0;
}
// find_if()**************************
int main()
{
vector<int> coll;
vector<int>::iterator pos;
INSERT_ELE(coll,1,9);
PRINT_ELE(coll,"coll: ");
pos=find_if(coll.begin(),coll.end(),bind2nd(greater<int>(),3));


cout<<"the" <<distance(coll.begin(),pos)+1<<".element is the first greater than 3" <<endl;
pos=find_if(coll.begin(),coll.end(),not1(bind2nd(modulus<int>(),3)));
cout<<"the" <<distance(coll.begin(),pos)+1<<".elenment is the first divisibel by 3"<<endl;
system("pause");
return 0;
}
//search_n "连续count个元素值全部等于value
//search_n " 连续count个元素造成以下一元判断结果为true的元素位置: op(elem,value)
//如果没有找到匹配的元素，两种元素都返回end
//复杂度：线性
int main()
{
deque<int> coll;
INSERT_ELE(coll,1,9);
PRINT_ELE(coll);
deque<int>::iterator pos;
pos=search_n(coll.begin(),coll.end(),4,3);
if(pos!=coll.end())
{
cout<<"four consecutive elements with value 3"<<"start with "<<distance(coll.begin(),pos)+1<<".element"<<endl;


}
else
cout<<"no four consective elements with value 3 found"<<endl;
pos=search_n(coll.begin(),coll.end(),4,5,greater<int>());
if(pos !=coll.end())
{
cout<< "four consecutive elements with value >3"<<"start with"<<distance(coll.begin(),pos)+1<<".element"<<endl;
}
else
cout<<"no four consecuive elements with value >3 found"<<endl;
system("pause");
return 0;
}
//搜索第一个子区间p347
//search(ForwardIterator1 beg,forwardIterator1 end,forwarditerator2 searchbeg,forwaditeraotr2 searchend)
//*****************************************************************************************************binarypredicate op)
// 第一种形式中子区间中的元素必须完全等于[searchBeg,searchEnd)的元素
// 第二形式中 子区间的元素和[searchBeg,searchEnd)对应的元素必须造成以下二元判断的结果为true


int main()
{
deque<int> coll;
list<int> subcoll;


INSERT_ELE(coll,1,7);
INSERT_ELE(coll,1,7);
INSERT_ELE(subcoll,3,6);


PRINT_ELE(coll,"coll:");
PRINT_ELE(subcoll,"subcoll:");


deque<int>::iterator pos;
pos =search(coll.begin(),coll.end(),subcoll.begin(),subcoll.end());
while(pos !=coll.end())
{
cout <<"subcoll found starting with element"<<distance(coll.begin(),pos)+1<<endl;
++pos;
pos=search(pos,coll.end(),subcoll.begin(),subcoll.end());
}
system("pause");
return 0;

}
//search算法的第二种形式 这里搜寻的是“偶数 基数 偶数" 排列而成的子序列
bool checkEven(int elem ,bool even)
{
if(even)
{
return elem%2 ==0;
}
else
return elem%2 ==1;
}
int main()
{
vector<int> coll;
INSERT_ELE(coll,1,9);
PRINT_ELE(coll,"coll:");


bool checkEvenArgs[3]={true,false,true};
vector<int>::iterator pos;
pos = search(coll.begin(),coll.end(),checkEvenArgs,checkEvenArgs+3,checkEven);
while(pos != coll.end())
{
cout<<"subrange found starting with element "<<distance(coll.begin(),pos)+1<<endl;
pos=search(++pos,coll.end(),checkEvenArgs,checkEvenArgs+3,checkEven);
}
system("pause");
return 0;

}
//find_end   搜寻最后一个元素
int main()
{
deque<int>coll;
list<int>subcoll;
INSERT_ELE(coll,1,7);
INSERT_ELE(coll,1,7);
INSERT_ELE(subcoll,3,6);
PRINT_ELE(coll,"coll:");
PRINT_ELE(subcoll,"subcoll:");
deque<int>::iterator pos;
pos = find_end(coll.begin(),coll.end(),subcoll.begin(),subcoll.end());
deque<int>::iterator end(coll.end());
while(pos != end)
{
cout<<"subcoll found starting with element "<<distance(coll.begin(),pos)+1<<endl;
end=pos;
pos=find_end(coll.begin(),end,subcoll.begin(),subcoll.end());
}
system("pause");
return 0;
}
//搜寻某些元素第一次出现地点
int main()
{
vector<int>coll;
list<int> searchcoll;
INSERT_ELE(coll,3,8);
INSERT_ELE(coll,1,11);
INSERT_ELE(searchcoll,3,5);
PRINT_ELE(coll,"coll:");
PRINT_ELE(searchcoll,"searchcoll:");
vector<int>::iterator pos;
pos = find_first_of(coll.begin(),coll.end(),searchcoll.begin(),searchcoll.end());
cout<<"first element of earchcoll in coll is element"<<distance(coll.begin(),pos)+1<<endl;
vector<int>::reverse_iterator rpos;
rpos =find_first_of(coll.rbegin(),coll.rend(),searchcoll.begin(),searchcoll.end());
cout<<"last element of searchcoll in coll is element"<<distance(coll.begin(),rpos.base())<<endl;
system("pause");
return 0;

}
//搜寻连续相等的两个元素
bool doubled(int elem1,int elem2)
{
return elem1*2==elem2;
}
int main()
{
vector<int> coll;
coll.push_back(1);
coll.push_back(3);
coll.push_back(2);
coll.push_back(4);
coll.push_back(5);
coll.push_back(5);
coll.push_back(0);
PRINT_ELE(coll,"coll:");
vector<int>::iterator pos;
pos= adjacent_find(coll.begin(),coll.end());
if(pos != coll.end())
{
cout<<"first two elements with equal value have position"<<distance(coll.begin(),pos)+1<<endl;
}
pos=adjacent_find(coll.begin(),coll.end(),doubled);
if(pos != coll.end())
{
cout<<"first two elements with equal value have position"<<distance(coll.begin(),pos)+1<<endl;
}
system("pause");
return 0;
}
//区间之间的比较  equal
bool bothEven(int elem1,int elem2)
{
return elem1%2 == elem2%2;
}
int main()
{
vector<int>  coll1;
list<int>  coll2;
INSERT_ELE(coll1,1,7);
INSERT_ELE(coll2,3,9);
PRINT_ELE(coll1,"coll1: ");
PRINT_ELE(coll2,"COll2: ");


if(equal( coll1.begin(),coll1.end(),coll2.begin()))
{
cout<<"coll1=coll2"<<endl;
}
else
cout <<"coll1 !=coll2" <<endl;
if(equal(coll1.begin(),coll1.end(),coll2.begin(),bothEven))
{
cout<<" equal"<<endl;


}
else
cout<<"not equal"<<endl;
}
//搜寻第一处不同点 mismatch
int main()
{
vector<int>   coll1;
list<int>     coll2;
INSERT_ELE(coll1,1,6);

for(int i=1;i<=16;i*=2)
coll2.push_back(i);
coll2.push_back(3);
PRINT_ELE(coll1,"coll2:");
PRINT_ELE(coll2,"coll2:");


pair<vector<int>::iterator,list<int>::iterator> values;
values = mismatch(coll1.begin(),coll1.end(),coll2.begin());
if(values.first ==coll1.end())
{
cout<<" no mismach"<<endl;
}
else
{
cout<<"first mismatch:"<<*values.first<<" and " <<*values.second<<endl;


}
values =mismatch(coll1.begin(),coll1.end(),coll2.begin(),less_equal<int>());
if(values.first ==coll1.end())
cout<<"always less-or-equal"<<endl;
else
cout<<"not less-or-equal:"<<*values.first<<" and "<<*values.second<<endl;
system("pause");
return 0;


}
//检验【小于】 第一个区间元素是否小于第二个区间元素，所谓小于是指额的是 字典次序的意义
void printCollection(const list<int>& l)
{
PRINT_ELE(l);
}
bool lessFor( const list<int>& l1,const list<int>& l2)
{
return  lexicographical_compare(l1.begin(),l1.end(),l2.begin(),l2.end());


}
int main()
{
list<int> c1,c2,c3,c4;
INSERT_ELE(c1,1,5);
c4=c3=c3=c1;
c1.push_back(7);
c3.push_back(2);
c3.push_back(0);
c4.push_back(2);


vector<list<int>> cc;
cc.push_back(c1);
cc.push_back(c2);
cc.push_back(c3);
cc.push_back(c4);
cc.push_back(c3);
cc.push_back(c1);
cc.push_back(c4);
cc.push_back(c2);


for_each(cc.begin(),cc.end(),printCollection);
cout<<endl;
sort(cc.begin(),cc.end(),lessFor);
for_each(cc.begin(),cc.end(),printCollection);
system("pause");
return 0;
}
//变动性算法*******************************
//1.运用迭代器遍历序列的过程。直接加以变动
//2.将元素从源source区间复制到目标区间的过程加以变动 某些算法同时提供两种方法，那么使用第二种法的版本会有尾词_copy
//复制元素copy


int main()
{
vector<int> coll1;
vector<int> coll2;
INSERT_ELE(coll1,1,9);
copy(coll1.begin(),coll1.end(),back_inserter(coll2));
copy(coll2.begin(),coll2.end(),ostream_iterator<int>(cout," "));
cout<<endl;
copy(coll1.rbegin(),coll1.rend(),ostream_iterator<int>(cout," "));
cout<<endl;
system("pause");
return 0;
}


//copy和copy_foward之间的区别
int main()
{
vector<char> source(10,'.');
for(char c='a';c<='f';c++)
source.push_back(c);
source.insert(source.end(),10,'.');
PRINT_ELE(source,"source: ");


vector<char> c1(source.begin(),source.end());
copy(c1.begin()+10,c1.begin()+16,c1.begin()+7);
PRINT_ELE(c1,"c1:");
vector<char> c2(source.begin(),source.end());
copy_backward(c2.begin()+10,c2.begin()+16,c2.begin()+19);
PRINT_ELE(c2,"c2:");
system("pause");
return 0;
}


//如何使用copy 作为标准的输出设置之间的数据过滤器 ：程序读取string 并以一行一个的方式打印他们
int main()
{
copy(istream_iterator<string>(cin),istream_iterator<string>(),ostream_iterator<string>(cout,"\n"));
}


//*********转换 transforming和结合combining元素
//treansform第一形式有4个参数，把源区的元素转换到目标空间 也就是说赋值和修改元素一起合成
//第二个形式有5个参数，将两个源序列中的元素合并，并将结果写入目标区间
int main()
{
vector<int> coll1;
list<int> coll2;
INSERT_ELE(coll1,1,9);
PRINT_ELE(coll1,"coll1:");


transform(coll1.begin(),coll1.end(),coll1.begin(),negate<int>());
PRINT_ELE(coll1,"negated:");
transform(coll1.begin(),coll1.end(),back_inserter(coll2),bind2nd(multiplies<int>(),10));
PRINT_ELE(coll2,"coll2:");
transform(coll2.rbegin(),coll2.rend(),ostream_iterator<int>(cout," "),negate<int>());
cout<<endl;
system("pause");
return 0;
}


//将两个元素加以结合 combing
int main()
{
vector<int> coll1;
list<int>  coll2;
INSERT_ELE(coll1,1,9);
PRINT_ELE(coll1,"coll:");
transform(coll1.begin(),coll1.end(),coll1.begin(),coll1.begin(),multiplies<int>());
PRINT_ELE(coll1,"squared:");
transform(coll1.begin(),coll1.end(),coll1.rbegin(),back_inserter(coll2),plus<int>());
PRINT_ELE(coll2,"coll2:");
cout<<"diff:";
transform(coll1.begin(),coll1.end(),coll2.begin(),ostream_iterator<int>(cout," "),minus<int>());
cout<<endl;
system("pause");
return 0;


}
//互换swapping元素内容*****swap_ranges
int main()
{
vector<int> coll1;
deque<int> coll2;
INSERT_ELE(coll1,1,9);
INSERT_ELE(coll2,11,23);
PRINT_ELE(coll1,"coll1:");
PRINT_ELE(coll2,"coll2:");
deque<int>::iterator pos;
pos=swap_ranges(coll1.begin(),coll1.end(),coll2.begin());


PRINT_ELE(coll1,"swapcoll1: ");
PRINT_ELE(coll2,"swap coll2: ");
if(pos != coll2.end())
{
cout<< "first element not modified: "<< *pos <<endl;
}
swap_ranges(coll2.begin(),coll2.begin()+3,coll2.rbegin());
PRINT_ELE(coll2,"\n coll2:");
system("pause");
return 0;
}


//赋值assigning新值fill fill_n
int main()
{
fill_n(ostream_iterator<float>(cout," "),10,7.7);
cout<<endl;
list<string> coll;
fill_n(back_inserter(coll),9,"hello");
PRINT_ELE(coll,"coll: ");
fill(coll.begin(),coll.end(),"again");
PRINT_ELE(coll,"coll: ");
fill_n(coll.begin(),coll.size()-2,"hi");
PRINT_ELE(coll,"coll: ");
list<string>::iterator pos1, pos2;
pos1= coll.begin();
pos2 = coll.end();
fill(++pos1,--pos2,"hmmm");
PRINT_ELE(coll,"coll:");
system("pause");
return 0;
}


//赋予新产生的数值
//generate generate_n
int main()
{
list<int> coll;
generate_n(back_inserter(coll),5,rand);
PRINT_ELE(coll,"coll: ");


generate(coll.begin(),coll.end(),rand);
PRINT_ELE(coll,"gcoll: ");
system("pause");
return 0;
}


//替换replacing元素
//将区间【beg，end)内的每一个 与 oldvalue 相得的元素替换为 newvalues
//replace_if   op 为true则替换
int main()
{
list<int> coll;
INSERT_ELE(coll,2,7);
INSERT_ELE(coll,4,9);
PRINT_ELE(coll,"coll: ");
replace(coll.begin(),coll.end(),6,42);
PRINT_ELE(coll,"coll: ");
replace_if(coll.begin(),coll.end(),bind2nd(less<int>(),5),0);
PRINT_ELE(coll,"coll_IF: ");
system("pause");
return 0;
}


//复制并且替换元素
//relace_copy
//replace_copy_if
int main()
{
list<int> coll;
INSERT_ELE(coll,2,6);
INSERT_ELE(coll,4,9);
PRINT_ELE(coll);
replace_copy(coll.begin(),coll.end(),ostream_iterator<int>(cout," "),5,55);
cout<<endl;
replace_copy_if(coll.begin(),coll.end(),ostream_iterator<int>(cout," "),bind2nd(less<int>(),5),42);
cout<<endl;
replace_copy_if(coll.begin(),coll.end(),ostream_iterator<int>(cout," "),bind2nd(modulus<int>(),2),0);
cout<<endl;
system("pause");
return 0;
}
//复制时并移除元素
//remove_copy(iter sourcebeg,iter source end,outputiter destbeg,const T&value)
//是copy和remove的组合，它将源区间[beg,end) 内的所有元素复制到"以 destBeg 为起点的目标区间去，并在复制过程中移除“与value相等的”所有元素
//remove_copy_if
int main()
{
list<int> coll1;
INSERT_ELE(coll1,1,6);
INSERT_ELE(coll1,1,9);
PRINT_ELE(coll1);
remove_copy(coll1.begin(),coll1.end(),ostream_iterator<int>(cout," "),3);
cout<<endl;
remove_copy_if(coll1.begin(),coll1.end(),ostream_iterator<int>(cout," "),bind2nd(greater<int>(),4));
cout<<endl;
multiset<int> coll2;
remove_copy_if(coll1.begin(),coll1.end(),inserter(coll2,coll2.end()),bind2nd(less<int>(),4));
PRINT_ELE(coll2);
system("pause");
return 0;

}


//移除重复元素 unique 移除连续重复元素中的多余元素
//必须先经过排序 才能使用这个算法移除所有重复元素
int main()
{
int source[]={1,4,4,6,1,2,2,3,1,6,6,6,5,7,5,4,4};
int sourceNum=sizeof(source)/sizeof(source[0]);
list<int> coll;
copy(source,source+sourceNum,back_inserter(coll));
PRINT_ELE(coll);
list<int>::iterator pos;
pos=unique(coll.begin(),coll.end());
copy(coll.begin(),pos,ostream_iterator<int>(cout," "));
cout<<"\n\n";
copy(source,source+sourceNum,coll.begin());
PRINT_ELE(coll);
coll.erase(unique(coll.begin(),coll.end(),greater<int>()),coll.end());
PRINT_ELE(coll);
system("pause");
cout<<endl;


}


//复制过程中移除重复元素
//unique_copy 是copy() unique ()的组合
bool differ(int elem1,int elem2)
{
return elem1+1==elem2 ||elem1-1==elem2;
}
int main()
{
int source[]={1,4,4,6,1,2,2,3,1,6,6,6,5,7,5,4,4};
list<int> coll;
int sourceNum=sizeof(source)/sizeof(source[0]);
copy(source,source+sourceNum,back_inserter(coll));
PRINT_ELE(coll);
unique_copy(coll.begin(),coll.end(),ostream_iterator<int>(cout," "));
cout<<endl;
unique_copy(coll.begin(),coll.end(),ostream_iterator<int>(cout," "),differ);
cout<<endl;
system("pause");
return 0;


}
//压缩空白序列
bool bothSpace(char  elem1,char elem2)
{
return elem1 ==' ' && elem2 ==' ';
}
int main()
{
cin.unsetf(ios::skipws);
unique_copy(istream_iterator<char>(cin),istream_iterator<char>(),ostream_iterator<char>(cout),bothSpace);


}




//*********变序性算法




//逆转reversing元素次序
//reverse 会将[beg,end)内的元素全部逆序
//reverse_copy 会将[beg,end）内的元素全部复制到以destbeg起始的目标区间，并且在复制过程中点到安置顺序
//list提供一个等效成员函数reverse（）,不能重新复制元素，而是重新安排指针 因此仅供更加性能 
int main()
{
vector<int> coll;
INSERT_ELE(coll,1,9);
PRINT_ELE(coll,"coll: ");
reverse(coll.begin(),coll.end());
PRINT_ELE(coll,"coll: ");
reverse(coll.begin()+1,coll.end()-1);//,ostream_iterator<int>(cout," "));
PRINT_ELE(coll,"coll:");
reverse_copy(coll.begin(),coll.end(),ostream_iterator<int>(cout," "));
cout<<endl;
system("pause");
return 0;


}
//旋转元素序列roating
//rotate(forearditerator beg, newbeg,end)
//将区间[beg,end)内的元素进行旋转。执行后 *newbeg成为新的第一元素
int main()
{
vector<int> coll;
INSERT_ELE(coll,1,9);
PRINT_ELE(coll,"coll: ");


rotate(coll.begin(),coll.begin()+1,coll.end());
PRINT_ELE(coll,"coll_rotate1: ");




rotate(coll.begin(),coll.end()-2,coll.end());
PRINT_ELE(coll,"coll_rotate2: ");


rotate(coll.begin(),find(coll.begin(),coll.end(),4),coll.end());
PRINT_ELE(coll,"coll_rotate3: ");
system("pause");
return 0;
}
//复制并同时旋转元素
//rotate_copy(forwarditerator sourcebeg,newbeg,sourceend,Outputiterator destbeg)
//这是rotate()和copy()的组合
//将源区间[sourcebeg,sourceEnd)内的元素复制到“以destbeg起始的目标区间”中，同时旋转元素，使newbeg成为新的第一元素
//返回目标区间内最后一个被复制元素的下一位置
int main()
{
set<int> coll;
INSERT_ELE(coll,1,9);
PRINT_ELE(coll,"coll: ");
set<int>::iterator pos =coll.begin();
advance(pos,1);
rotate_copy(coll.begin(),pos,coll.end(),ostream_iterator<int>(cout," "));
cout<<endl;


pos =coll.end();
advance(pos,-2);
rotate_copy(coll.begin(),pos,coll.end(),ostream_iterator<int>(cout," "));
cout<<endl;


rotate_copy(coll.begin(),coll.find(4),coll.end(),ostream_iterator<int>(cout," "));
cout<<endl;
system("pause");
return 0;

}
//排列（permuting)元素
//next_permutation()会改变区间[beg,end)内的元素次序，是他们符合“下一个排列次序"
//prev_permutation() 会改变区间[beg,end) 内的元素次序，使他们符合“上一个排列次序”
int  main()
{
vector<int> coll;
INSERT_ELE(coll,1,3);
PRINT_ELE(coll,"coll: ");
while(next_permutation(coll.begin(),coll.end()))
{
PRINT_ELE(coll," ");


}
PRINT_ELE(coll,"afterward: ");
while(prev_permutation(coll.begin(),coll.end()))
{
PRINT_ELE(coll," ");


}
PRINT_ELE(coll,"now: ");


while(prev_permutation(coll.begin(),coll.end()))
{
PRINT_ELE(coll," ");


}
PRINT_ELE(coll,"afterward:  ");
system("pause");
return 0;
}
//重排元素
//random_shuffle(RandomAccessIterator beg,end)
//random_shuffle(RandomAccessIterator beg,end,RandomFunc& op)
//第一种形式使用一个均匀分布随机数产生器(uniform distrbution random numner generator)来打乱区间[beg,end)内的元素次序
//第二种使用op打乱区间[beg,end)内的元素次序，算法内部会使用一个整数值（其型号为“迭代器所提供之difference_type）来调用op
//他应该返回一个大于零而小于max的随机数，不包括max本身
class MyRandom
{
public:
ptrdiff_t operator() (ptrdiff_t max)
{
double tmp;
tmp =static_cast<double>(rand())/static_cast<double>(RAND_MAX);
return static_cast<ptrdiff_t>(tmp *max);
}
};
int main()
{
vector<int> coll;
INSERT_ELE(coll,1,9);
PRINT_ELE(coll,"coll: ");
random_shuffle(coll.begin(),coll.end());
PRINT_ELE(coll,"shufffled: ");
sort(coll.begin(),coll.end());
PRINT_ELE(coll,"sorted:");
MyRandom rd;
random_shuffle(coll.begin(),coll.end(),rd);
PRINT_ELE(coll,"shuffled: ");
system("pause");
return 0;

}
//将元素向前搬移
//partition(BidirectionalIterator beg,end,UnaryPrredicate op)
//stable_patition(---------------------------------------------)
//这两种算法将区间[beg,end)中"造成以下一元判断式"op（elem）”结果为true的元素向前端移动
//这两种该算法都返回"令op()结果为false”的第一个元素位置
//两者差别是。无论元素是否符合给定的准侧，stable_partition()会保持他们之间的相对次序
int main()
{
vector<int> coll1;
vector<int> coll2;
INSERT_ELE(coll1,1,9);
INSERT_ELE(coll2,1,9);
PRINT_ELE(coll1,"coll1: ");
PRINT_ELE(coll2,"coll2: ");
cout<<endl;
vector<int>::iterator pos1,pos2;
pos1=partition(coll1.begin(),coll1.end(),not1(bind2nd(modulus<int>(),2)));
pos2=stable_partition(coll2.begin(),coll2.end(),not1(bind2nd(modulus<int>(),2)));
PRINT_ELE(coll1,"coll: ");
cout<<" first odd element: "<<*pos1 <<endl;
PRINT_ELE(coll2,"coll2: ");
cout<<"first odd element: "<<*pos2<<endl;
system("pause");
return 0;
}
//排序算法 sorting algorithms
 //sort(RandomAccessIterator beg,end) sort(beg,end,BinaryPredicate op)
//stable_sort(beg,end)                stable_sort(beg,end,op)
//sort 和stable_sort()的上述第一形式，使用<operator<对区间[beg,end)内的所有元素进行排序
//sort 和stable_sort()的区别是：保证后者相等元素的原本相对次序在排序后不改变
int  main()
{
deque<int> coll;
INSERT_ELE(coll,1,9);
INSERT_ELE(coll,1,9);
PRINT_ELE(coll,"coll: ");
sort(coll.begin(),coll.end());
PRINT_ELE(coll,"sorted: ");


sort(coll.begin(),coll.end(),greater<int>());
PRINT_ELE(coll,"sorted: ");
system("pause");
return 0;
}
//sort 和 stable_sort()区别
bool lessLength(const string &s1,const string &s2)
{
return s1.length()<s2.length();
}
int main()
{
vector<string> coll1;
vector<string> coll2;
coll1.push_back("1xxx");
coll1.push_back("2x");
coll1.push_back("3x");
coll1.push_back("4x");
coll1.push_back("5xx");
coll1.push_back("6xxxx");
coll1.push_back("7xx");
coll1.push_back("8xxx");
coll1.push_back("9xx");
coll1.push_back("10xxx");
coll1.push_back("11");
coll1.push_back("12");
coll1.push_back("13");
coll1.push_back("14xx");
coll1.push_back("15");
coll1.push_back("16");
coll1.push_back("17");
coll2=coll1;
PRINT_ELE(coll1,"coll1: ");
sort(coll1.begin(),coll1.end(),lessLength);
stable_sort(coll2.begin(),coll2.end(),lessLength);
PRINT_ELE(coll1,"\n with sort():\n");
PRINT_ELE(coll2,"\n with stable_sort(): \n");
system("pause");
return 0;//输出结果是一样的。。。。。。
}


//局部排序（Partial Sorting）
//partial_sort(RandomAccessItrator beg,sortend,end)
//------------------------------------,sortEnd,end,op)
//以第一形式，以operator< 对区间[beg,end) 内的元素进行排序，使区间[beg,sortEnd) 内的元素处于有序状态
int main()
{
deque<int> coll;
INSERT_ELE(coll,3,7);
INSERT_ELE(coll,2,6);
INSERT_ELE(coll,1,5);
PRINT_ELE(coll);


partial_sort(coll.begin(),coll.begin()+5,coll.end());
PRINT_ELE(coll);


partial_sort(coll.begin(),coll.begin()+5,coll.end(),greater<int>());
PRINT_ELE(coll);


partial_sort(coll.begin(),coll.end(),coll.end());
PRINT_ELE(coll);
system("pause");

}


//partial_sort_copy(InputIterator sourceBeg,end,destBeg,destEnd)
//------------------------------------------------------------op)
//两者是 copy()和partial_sort()的组合
//他们将元素从源区间[beg,end)复制到目标区间[destbeg,end),同时进行排序
int main()
{
deque<int> coll1;
vector<int> coll6(6);
vector<int> coll30(30);
INSERT_ELE(coll1,3,7);
INSERT_ELE(coll1,2,6);
INSERT_ELE(coll1,1,5);
PRINT_ELE(coll1);
vector<int>::iterator pos6;
pos6 = partial_sort_copy(coll1.begin(),coll1.end(),coll6.begin(),coll6.end());
copy(coll6.begin(),pos6,ostream_iterator<int>(cout," "));
cout<<endl;
vector<int>::iterator pos30;
pos30=partial_sort_copy(coll1.begin(),coll1.end(),coll30.begin(),coll30.end(),greater<int>());
copy(coll30.begin(),pos30,ostream_iterator<int>(cout," "));
cout<<endl;
system("pause");
return 0;
}


//根据第n个元素排序
//nth_element(RandomAccesIterator beg,nth,end)
//---------------------------------------------op)
//两种形式对区间[beg,end)内的元素进行排序，使第n个位置上的元素就位，也即是说，所有的位置n之前的元素都小于等于它，所有在位置n之后的元素都大于等于它。
//上述第一形式使用operator< 作为排序准则
int main()
{
deque<int> coll;
INSERT_ELE(coll,3,7);
INSERT_ELE(coll,2,6);
INSERT_ELE(coll,1,5);
PRINT_ELE(coll);
nth_element(coll.begin(),coll.begin()+3,coll.end());
cout<<"this four lowest elements are: ";
copy(coll.begin(),coll.begin()+4,ostream_iterator<int>(cout," "));
cout<<endl;
nth_element(coll.begin(),coll.end()-4,coll.end());
cout<<"The four highest elements are: ";
copy(coll.end()-4,coll.end(),ostream_iterator<int>(cout," "));
cout<<endl;
nth_element(coll.begin(),coll.begin()+3,coll.end(),greater<int>());
cout<<"the four highest elements are: ";
copy(coll.begin(),coll.begin()+4,ostream_iterator<int>(cout," "));
cout<<endl;
system("pause");
cout<<endl;
}
//Heap 算法
//STL提供四种算法
//1. make_heal()将某区间内的元素转化为heap
//2. push_heap()对着heap增加一个元素
//3.pop_heap()  对着heap取出下一个元素
//4 sort_heap()  将heap()转化为一个以序群集（此后就不再是heap了）
int main()
{
vector<int> coll;
INSERT_ELE(coll,3,7);
INSERT_ELE(coll,5,9);
INSERT_ELE(coll,1,4);




PRINT_ELE(coll,"on entry: ");
make_heap(coll.begin(),coll.end());
PRINT_ELE(coll,"after make_heap: ");
pop_heap(coll.begin(),coll.end());
coll.pop_back();
PRINT_ELE(coll,"after pop_back: ");
coll.push_back(17);
push_heap(coll.begin(),coll.end());
PRINT_ELE(coll,"after push_back(): ");
sort_heap(coll.begin(),coll.end());
PRINT_ELE(coll,"after sort_heap(): ");
system("pause");
return 0;
}
//************************已序区间算法(Sorted Range Algorithms)
//搜寻某个元素是否存在
//binary_search(ForeardIterator beg,end, const T& value)
//------------------------------------------------------op)
//用来判断以序区间[beg,end)中是否包含"和"value相等的元素”的值
int main()
{
list<int> coll;
INSERT_ELE(coll,1,9);
PRINT_ELE(coll,"coll: ");
if(binary_search(coll.begin(),coll.end(),5))
{
cout<<"5 is present "<<endl;
}
else
{
cout<<" 5 is not present"<<endl;
}
if(binary_search(coll.begin(),coll.end(),42))
{
cout<<"42 is present "<<endl;
}
else
{
cout<<" 42 is not present"<<endl;
}
system("pause");
return 0;

}
//以下代码展示includes() 的用法
//includes() 判断某区间内的每一个元素是否都涵盖于另一个区间中
int main()
{
list<int> coll;
vector<int> search;
INSERT_ELE(coll,1,9);
PRINT_ELE(coll,"coll: ");
search.push_back(3);
search.push_back(4);
search.push_back( 7);


PRINT_ELE(search,"search: ");
if(includes (coll.begin(),coll.end(),search.begin(),search.end()))
{
cout<<"all elements of search are in coll"<<endl;
}
else
cout<<"not all elements of search are also in coll"<<endl;
system("pause");
return 0;
}
//搜寻第一个或最后一个可能位置
//lower_bound(Forward beg, ForwardIterator end,const T& value)
//lower_bound() 返回第一个“大于等于value”的元素位置，这是可插入“元素值为value"切”不被破坏区间[beg,end)已序性“的第一个位置
//lower_bound(-----------------------------------------------,op)
//upper_bound(beg,end,const T&value) upper_bound(beg,end,const T&value op);
int main()
{
list<int> coll;
INSERT_ELE(coll,1,9);
INSERT_ELE(coll,1,9);
coll.sort();
PRINT_ELE(coll);
list<int>::iterator pos1,pos2;
pos1 =lower_bound(coll.begin(),coll.end(),5);
pos2=upper_bound(coll.begin(),coll.end(),5);
cout<<"5 could get position"<<
distance(coll.begin(),pos1)+1
<<" up to "
<<distance(coll.begin(),pos2)+1<<"without breaking the sorting" <<endl;
coll.insert(lower_bound(coll.begin(),coll.end(),3),3);
coll.insert(upper_bound(coll.begin(),coll.end(),3),3);
PRINT_ELE(coll);
system("pause");
return 0;
}


//搜寻第一个和最后一个可能位置
//equal_range(ForwardIterator beg,end,const T& value)
//两者形式都返回“与value相等”的元素所形成的区间，在此区间插入“其值为value”的元素，并不会破坏[beg,end)已序
int main()
{
list<int> coll;
INSERT_ELE(coll,1,9);
INSERT_ELE(coll,1,9);
coll.sort();
PRINT_ELE(coll);
pair<list<int>::iterator,list<int>::iterator> range;
range = equal_range(coll.begin(),coll.end(),5);
cout<<"5 could get position"
<<distance(coll.begin(),range.first)+1
<<"up to"
<<distance(coll.begin(),range.second)+1<<"without breaking the sorting"<<endl;
system("pause");
return 0;
}


//合并元素(Merging)
//两个已序集合的组合（sum）
//merge(source1beg,source1end,source2beg,source2end,destbeg)
//---------------------------------------------------,op)
//两者都是讲源区间[sourceBeg,sourceEnd)和[source2Beg,source2End)内的元素合并，使得"以destBeg起始的目标区间"内含有两个元区间的所有元素
int main()
{
list<int> coll1;
set<int> coll2;
INSERT_ELE(coll1,1,6);
INSERT_ELE(coll2,3,8);
PRINT_ELE(coll1,"coll1: ");
PRINT_ELE(coll1,"coll2: ");
cout<<"merged: ";
merge(coll1.begin(),coll1.end(),coll2.begin(),coll2.end(),ostream_iterator<int>(cout," "));
cout<<endl;
system("pause");
cout<<endl;
}
//两个已序集合的差集（Difference）
//set_difference(InputIterator source1Beg,source1End,source2Beg,source2End,destBeg)
//set_difference(source1Beg,InputIterator source1End,---------------------------------,op)
//  以上两者都是将已序源区间[sourcebeg,source1End) 和 [source2Beg,source2End)的元素合并，得到以destBeg起始的目标区间，这个区间内涵的元素只存在第一源区间，不存在于第二区间
//例子 两个序列 1 2 2 4 6 7 7 9和2 2 2 3 6 6 8 9 结果得到1 4 7 7 
//set_sysmetric_difference(InputIterator source1Beg,source1End,source2Beg,source2End,destBeg)
//set_sysmetric_difference(------------------------------------------------------------------,op)
//区间存在于第一源区间或者第二源区间，但不能同时存在于两源区间之间
int main()
{
int c1[]={1,2,3,4,6,7,7,9};
int num1=sizeof(c1)/sizeof(int);


int c2[]={2,2,2,3,6,6,8,9};
int num2=sizeof(c2)/sizeof(int);
cout<<"c1; ";
copy(c1,c1+num1,ostream_iterator<int>(cout," "));
cout<<endl;
cout<<" c2: ";
copy(c2,c2+num2,ostream_iterator<int>(cout," "));
cout<<'\n'<<endl;
cout<<"merge():";
merge(c1,c1+num1,c2,c2+num2,ostream_iterator<int>(cout," "));
cout<<endl;
cout<<"set_union():";
set_union(c1,c1+num1,c2,c2+num2,ostream_iterator<int>(cout," "));
cout<<endl;

cout<<endl;
cout<<"set_intersection():";
set_intersection(c1,c1+num1,c2,c2+num2,ostream_iterator<int>(cout," "));
cout<<endl;
cout<<"set_difference(): ";
set_difference(c1,c1+num1,c2,c2+num2,ostream_iterator<int>(cout," "));
cout<<endl;
set_symmetric_difference(c1,c1+num1,c2,c2+num2,ostream_iterator<int>(cout," "));
system("pause");
return 0;


}
//****************数值算法(包含头文件#include <numeric>************************
//加工运算后产生的结果
//对序列进行某种运算
//accumulate(InputIterator beg,  end, T initValue)
//accumulate(InputIterator beg,  end,  T initValue,BinaryFunc op)
//以上第一种形式计算initValue和区间[beg,end)内的所有元素总和，更具体的说对每一个元素调用以下表达式
//initValue = initValue +elem
//以上第二种形式计算initValue 和区间[beg,end)内的每一个元素进行op运算的结果，更具体的说 它针对每一个元素调用以下表达式：
//initValue= op（initValue,elem)
//因此对于以下数值序列:
//a1 a2 a3 a4 ....两个表达式分别为 initvalue+a1+a2+a3+a4和initValue op a1 op a2 opa3 op...
int main()
{
vector<int> coll;
INSERT_ELE(coll,1,9);
PRINT_ELE(coll,"coll: ");
cout<<"sumL: "<<accumulate(coll.begin(),coll.end(),0)<<endl;
cout<<"sum2: "<<accumulate(coll.begin(),coll.end(),-100)<<endl;
cout<<"sum3: "<<accumulate(coll.begin(),coll.end(),1,multiplies<int>())<<endl;
cout<<"sum4: "<<accumulate(coll.begin(),coll.end(),0,multiplies<int>());
system("pause");
return 0;
}
//计算两序列的内积(Inner Product)
//inner_product(InputIterator beg,end1,beg2,initValue)
//------------------------------------,--------------,BinaryFunc op1,op2);
//调用以下表达式: initValue = initValue +elem1*elem2
//initValue=op1(initValue,op2(elem1,elem2))
//所以对于数值序列a1,a2,a3,.... b1,b2,b3.....
//上述两个算法分别返回:
//initValue+(a1*b1)+(a2*b2)+(a3*b3).....+
//initvalue op1(a1 op2 b1) op1 (a2, op2 b2) op1(a3 op2 b3)op1....
int main()
{
list<int> coll;
INSERT_ELE(coll,1,6);
PRINT_ELE(coll,"coll: ");
cout<<"inner product: "<<inner_product(coll.begin(),coll.end(),coll.begin(),0)<<endl;
cout<<"inner product: "<<inner_product(coll.begin(),coll.end(),coll.rbegin(),0)<<endl;


cout<<"product of sums: "<<inner_product(coll.begin(),coll.end(),coll.begin(),1,multiplies<int>(),plus<int>())<<endl;
system("pause");
return 0;
//1*

}
//相对值和绝对值之间的转换
//将相对值转化为绝对值
//partial_sum(InputIterator sourceBeg,sourceEnd,destBeg)
//-----------------------------------------------------,BinaryFunc op)
//第一种形式计算源区间[sourceBeg,sourceEnd)中的每个元素部分和，然后将结果写入以destBeg为起点的目标区间
//第二种形式将计算源区间[sourceBeg,sourceEnd)中的每个元素和其先前所有元素进行op预案算，--------------
//例子 a1 a2 a3他们分别计算a1,a1+a2,a1+a2+a3,....和 a1,a1 opa 2,a1 op a2 op a3 ....
int main()
{
vector<int> coll;
INSERT_ELE(coll,1,6);
PRINT_ELE(coll);
partial_sum(coll.begin(),coll.end(),ostream_iterator<int>(cout," "));
cout<<endl;
partial_sum(coll.begin(),coll.end(),ostream_iterator<int>(cout," " ),multiplies<int>());
cout<<endl;
system("pause");
return 0;
}
//计算绝对值转化为相对值
//adjacent_difference(InputIterator sourceBeg,sourceEnd,destBeg)
//--------------------------------------------------------------,Binary op)
//第一种形式计算区间[sourcebeg,sourceBeg)中每一个元素和其紧邻前驱元素的差额，并将结果写入destBeg为起点的目标区间
//第二种-------------------------------------------------------------调用op操作，并写入destBeg为起点的目标区间
//数值序列：a1 a2 a3 a4.....
//他们分别计算 a1,a2-a1,a3-a2,a4-a3 和a1,a2 op a1, a3 op a2, a4 op a3,...
int main()
{
deque<int>coll;
INSERT_ELE(coll,1,6);
PRINT_ELE(coll);
adjacent_difference(coll.begin(),coll.end(),ostream_iterator<int>(cout," "));
cout<<endl;


adjacent_difference(coll.begin(),coll.end(),ostream_iterator<int>(cout," "),multiplies<int>());
cout<<endl;
system("pause");
return 0;
}*/
//将绝对值和相对值对换
int main()
{
vector<int> coll;
coll.push_back(17);
coll.push_back(-3);
coll.push_back(22);
coll.push_back(13);
coll.push_back(13);
coll.push_back(-9);


adjacent_difference(coll.begin(),coll.end(),coll.begin());
PRINT_ELE(coll,"relative: ");
partial_sum(coll.begin(),coll.end(),coll.begin());
PRINT_ELE(coll,"absolute: ");
system("pause");
return 0;


}