[C++STL]算法<algorithm>中各种算法解析



一,巡防算法

for_each(容器起始地址,容器结束地址,要执行的方法)

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

template<class T>
struct plus2
{
	void operator()(T&x)const
	{
		x+=2;
	}

};

void printElem(int& elem)
{
  cout << elem << endl;
}

int main()
{
	int ia[]={0,1,2,3,4,5,6};
	for_each(ia,ia+7,printElem);//输出

	int ib[]={7,8,9,10,11,12,13};
	vector<int> iv(ib,ib+7);
	for_each(iv.begin(),iv.end(),plus2<int>());//更改元素
	for_each(iv.begin(),iv.end(),printElem);//输出

	return 0;
}

二,find算法

int *find(int *begin,int *end,int  value)

前闭后合的区间 begin,end中,查找value如果查找到了就返回第一个符合条件的元素,否则返回end指针

#include <iostream>
#include <algorithm>

using namespace std;

void printElem(int& elem)
{
  cout << elem << endl;
}

int main()
{
	int ia[]={0,1,2,3,4,5,6};

	int *i= find(ia,ia+7,9);//在整个数组中查找元素 9
	int *j= find(ia,ia+7,3);//在整个数组中查找元素 3
	int *end=ia+7;//数组最后位置
	if(i == end)
	   cout<<"没有找到元素 9"<<endl;
    else
	   cout<<"找到元素9"<<endl;

    if(j == end)
	   cout<<"没有找到元素 3"<<endl;
    else
	   cout<<"找到元素"<<*j<<endl;
	return 0;
}

三,数值算法

包含在<numeric>头文件中

#include <iostream>
#include <numeric>  //数值算法
#include <vector>
#include <functional>
#include <iterator> 

#include <math.h>
 using namespace std;

 int main()
 {
 	int ia[]={1,2,3,4,5};
 	vector<int> iv(ia,ia+5);

 	cout<<accumulate(iv.begin(),iv.end(),0)<<endl; //累加  初值为0
 	cout<<accumulate(iv.begin(),iv.end(),0,minus<int>())<<endl; //累加 符号位负

	cout<<inner_product(iv.begin(),iv.end(),iv.begin(),10)<<endl;//两个数组内积  初值为10
	cout<<inner_product(iv.begin(),iv.end(),iv.begin(),10,minus<int>(),plus<int>())<<endl;//10-(1+1)-(2+2)

    ostream_iterator<int> oite(cout," ");//迭代器绑定到cout上作为输出使用
	partial_sum(iv.begin(),iv.end(),oite);//依次输出前n个数的和 

	cout<<endl;
	partial_sum(iv.begin(),iv.end(),oite,minus<int>());//依次输出第一个数减去(除第一个数外到当前数的和)

	cout<<endl;
    adjacent_difference(iv.begin(),iv.end(),oite); //输出相邻元素差值 前面-后面

    cout<<endl;
    adjacent_difference(iv.begin(),iv.end(),oite,plus<int>()); //输出相邻元素差值 前面+后面  。前面更改影响后面元素 

	cout<<endl;
    cout<<pow(10,3)<<endl; // 平方

	/*  VC 不支持   只有安装了才SGI STL支持
    int n=3;
	iota(iv.begin(),iv.end(),n);//在指定区间填入n  n+1 n+2
	for(int i=0;i<iv.size();++i)
	    cout<<iv[i]<<" "; 

	    */
 	return 0;
 }
 

四,基本算法

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

template<typename T>
struct display
{
	void operator()(const T  &x)const
	{
		cout<<x<<" ";
	}

};

int main()
{
	int ia[]={0,1,2,3,4,5,6,7,8};
	vector<int> iv1(ia,ia+5);
	vector<int> iv2(ia,ia+9);

	pair<vector<int>::iterator,vector<int>::iterator> pa;
	pa=mismatch(iv1.begin(),iv1.end(),iv2.begin());
	cout<<"两个数组不同点--第一个数组点:"<<*(pa.first)<<endl; //这样写很危险,应该判断是否到达end
	cout<<"两个数组不同点--第二个数组点:"<<*(pa.second)<<endl;

	//更改之后
	if(pa.first == iv1.end())
		cout<<"第一个数组与第二个数组匹配"<<endl; 

	cout<<equal(iv1.begin(),iv1.end(),iv2.begin())<<endl;// 1 表示 相等,因为只比较跟 iv1长度大小的数组
	cout<<equal(iv1.begin(),iv1.end(),&ia[3])<<endl;// 0 表示 不相等
	cout<<equal(iv1.begin(),iv1.end(),&ia[3],less<int>())<<endl;// 1 表示 前者小于后者

	fill(iv1.begin(),iv1.end(),9);//将iv1区间内填满 9
	for_each(iv1.begin(),iv1.end(),display<int>());
	cout<<endl; 	

	fill_n(iv1.begin(),3,6);//从iv1区间开始填 3个6
	for_each(iv1.begin(),iv1.end(),display<int>());
	cout<<endl;

	vector<int>::iterator ite1=iv1.begin();
	vector<int>::iterator ite2=ite1;
	advance(ite2,3);//向前跳3个

	iter_swap(ite1,ite2);//交换迭代器指向的元素
	for_each(iv1.begin(),iv1.end(),display<int>());

    cout<<"\nmax:"<<max(*ite1,*ite2)<<endl;
    cout<<"min:"<<min(*ite1,*ite2)<<endl;

	swap(*ite1,*ite2);
    for_each(iv1.begin(),iv1.end(),display<int>());

    cout<<endl;
    string stra1[]={"a","b","c"};
    string stra2[]={"d","e","f"};

    cout<<lexicographical_compare(stra1,stra1+2,stra2,stra2+2)<<endl;//按照字典序 前者小于后者
    cout<<lexicographical_compare(stra1,stra1+2,stra2,stra2+2,greater<string>())<<endl;//按照字典序 前者不大于后者

	return 0;
}

五,copy()对不同容器复制;关于输出区间与输入区间重叠的讨论

#include <iostream>
#include <algorithm>
#include <deque>

using namespace std;
template<class T>
struct display
{
	void operator()(const T &x)const
	{
		cout<<x<<" ";
	}
};

int main()
{
	//以下复制区间没有问题
	int ia1[]={0,1,2,3,4,5,6,7,8};
	copy(ia1+2,ia1+7,ia1);//将下标2-6复制给 1-5
	for_each(ia1,ia1+9,display<int>()); //2,3,4,5,6,5,6,7,8
	cout<<endl;

	//输出区间的起点与输入区间重叠,可能会有问题。但本例copy采用memmove()执行实际复制操作
	int ia2[]={0,1,2,3,4,5,6,7,8};
	copy(ia2+2,ia2+7,ia2+4);//将下标2-6复制给 4-8
	for_each(ia2,ia2+9,display<int>()); //0,1,2,3,2,3,4,5,6
	cout<<endl;

	//以下复制区间没有问题
	int ia3[]={0,1,2,3,4,5,6,7,8};
	deque<int> id(ia3,ia3+9);
	deque<int>::iterator first=id.begin();
	deque<int>::iterator last=id.end();
	deque<int>::iterator result=id.begin();
	++++first;
	cout<<*first<<endl;
	----last;
	cout<<*last<<endl;
	cout<<*result<<endl;
	copy(first,last,result);
	for_each(id.begin(),id.end(),display<int>());//2,3,4,5,6,5,6,7,8
	cout<<endl;

	//以下复制区间存在问题,由于实际复制没有采用memove(),结果错误
	int ia4[]={0,1,2,3,4,5,6,7,8};
	deque<int> ide(ia4,ia4+9);
	deque<int>::iterator first1=ide.begin();
	deque<int>::iterator last1=ide.end();
	deque<int>::iterator result1=ide.begin();
	advance(result1,4);//注意这里跟上面不一样
	++++first1;
	cout<<*first1<<endl;
	----last1;
	cout<<*last1<<endl;
	cout<<*result1<<endl;
	copy(first1,last1,result1);
	for_each(ide.begin(),ide.end(),display<int>());// 0,1,2,3,2,3,2,3,2不是预期的 0,1,2,3,2,3,4,5,6
	cout<<endl;

	return 0;
} 

【注意】如果以vector 容器替代deque容器则每种情况都正确,因为vector迭代器其实是个源生指针,调用的copy()算法以mommove()执行实际复制。

copy_backward(first,last,result);  //逆向复制,将迭代器first - last位置的元素逆向复制到 从result-1开始的逆向区间

补充:

        原型:void *memmove( void  * dest, const   void  * src, size_t  count );

  用法:#include <string.h>或#include <memory.h>

  功能:由src所指内存区域复制count个字节到dest所指内存区域。

  说明:src和dest所指内存区域可以重叠,但复制后dest内容会被更改。函数返回指向dest的指针。采取先拷贝再复制的方式,有效解决了dest和src区域重叠问题

  相关函数:memset、memcpy、strcpy 参考博文http://blog.csdn.net/tianshuai11/article/details/7624419

实例

#include <stdio.h>
#include <string.h>
int main()
{
  char s[]="Golden Global View";
   memmove(s,s+7,strlen(s)+1-7);
   printf("%s",s);
  
  return 0;
}

六,Set方法

#include <iostream>
#include <set>
#include <algorithm>
#include <iterator>
using namespace std;

template <class T>
struct display
{
	void operator()(const T &x)
	{
		cout<<x<<" ";
	}

};
int main()
{
	int ia1[]={1,3,5,7,9,11};
	int ia2[]={1,1,2,3,5,8,13};

	multiset<int> s1(ia1,ia1+6);
	multiset<int> s2(ia2,ia2+7);
	for_each(s1.begin(),s1.end(),display<int>());
	cout<<endl;
	for_each(s2.begin(),s2.end(),display<int>());
	cout<<endl;

	multiset<int>::iterator first1 = s1.begin();
	multiset<int>::iterator last1 = s1.end();
	multiset<int>::iterator first2 = s2.begin();
	multiset<int>::iterator last2 = s2.end();

	cout<<"union of s1 and s2: ";
	//两个集合合并,相同元素个数取 max(m,n)。
	set_union(first1,last1,first2,last2,ostream_iterator<int>(cout," "));
	cout<<endl;

	first1=s1.begin();
	first2=s2.begin();
	cout<<"Intersection of s1 and s2: ";
	//两个集合交集,相同元素个数取 min(m,n).
	set_intersection(first1,last1,first2,last2,ostream_iterator<int>(cout," "));
	cout<<endl;

	first1=s1.begin();
	first2=s2.begin();
	cout<<"Intersection of s1 and s2: ";
	//两个集合差集 就是去掉S1中 的s2
	set_difference(first1,last1,first2,last2,ostream_iterator<int>(cout," "));
	cout<<endl;

	first1=s1.begin();
	first2=s2.begin();
	cout<<"Intersection of s1 and s2: ";
	//两个集合对称差集:就是取两个集合互相没有的元素 。两个排序区间,元素相等指针后移,不等输出小的并前进
	//相同元素的个数 abs(m-n)
	set_symmetric_difference(first1,last1,first2,last2,ostream_iterator<int>(cout," "));
	cout<<endl;

	return 0;
}

七,其他算法(运算逻辑相对单纯的算法)

#include <iostream>
#include <algorithm>
#include <vector>
#include <functional>
#include <vector> 

using namespace std;

template <class T>
struct display
{
	void operator()(const T &x)const
	{
		cout<<x<<" ";
	} 

}; 

struct even
{
	bool operator()(int x)const
	{
		return x%2?false:true;
	}
};

class even_by_two
{
private:
	static int _x; //注意静态变量
public:
	int operator()()const
	{
		return _x+=2;
	}	 

};
int even_by_two::_x=0; 

int main()
{
	int ia[]={0,1,2,3,4,5,6,6,6,7,8};
	vector<int> iv(ia,ia+sizeof(ia)/sizeof(int));

	//找出iv之中相邻元素值相等的第一个元素
	cout<<*adjacent_find(iv.begin(),iv.end())<<endl;
	cout<<*adjacent_find(iv.begin(),iv.end(),equal_to<int>())<<endl; //仿函数

	cout<<count(iv.begin(),iv.end(),6)<<endl;//统计6的个数
	cout<<count_if(iv.begin(),iv.end(),bind2nd(less<int>(),7))<<endl;//统计小于7的元素的个数 :9个

	cout<<*find(iv.begin(),iv.end(),4)<<endl; //返回元素为4的元素的下标位置

	cout<<*find_if(iv.begin(),iv.end(),bind2nd(greater<int>(),2))<<endl; //返回大于2的第一个元素的位置:3

	vector<int> iv2(ia+6,ia+8);//6 6

	for(int i=0;i<iv2.size();++i)
	  cout<<iv2[i]<<" "; 

    cout<<endl;
    //返回iv序列中 iv2序列 出现的最后一个位置(再往后三个位置的值):8
	cout<<"find_end:"<<*(find_end(iv.begin(),iv.end(),iv2.begin(),iv2.end())+3)<<endl;
	 //返回iv序列中 iv2序列 出现的最后一个位置(再往后三个位置的值):7
	cout<<"find_first_of:"<<*(find_first_of(iv.begin(),iv.end(),iv2.begin(),iv2.end())+3)<<endl;

	 for_each(iv.begin(),iv.end(),display<int>());
	 cout<<endl;

	 //遍历整个iv2区间并执行 even_by_two操作
	 generate(iv2.begin(),iv2.end(),even_by_two());
     for_each(iv2.begin(),iv2.end(),display<int>());
	 cout<<endl;

	 //遍历区间(给出起点和长度),对每个遍历元素执行even_by_two操作
	 generate_n(iv.begin(),3,even_by_two());
     for_each(iv.begin(),iv.end(),display<int>()); //由于_X是static 所以接着 增长
	 cout<<endl;

	 //删除元素6 尾端可能有残余数据
	 remove(iv.begin(),iv.end(),6);
     for_each(iv.begin(),iv.end(),display<int>()); //由于_X是static 所以接着 增长
	 cout<<endl; //8 10 3 4 5 7 8 6 6 7 8 (最后四个是残留数据) 

     //去除value 然后将一个容器的元素复制到另一个 容器。仍然可能有残留元素
	  vector<int> iv3(12);//重新申请空间
	  remove_copy(iv.begin(),iv.end(),iv3.begin(),6);
      for_each(iv3.begin(),iv3.end(),display<int>()); //由于_X是static 所以接着 增长
      cout<<endl; //8 10 3 4 5 7 8 7 8 0 0 (最后两个是残留元素) 

	  //将小于6的元素 "删除" iv 此时为 8 10 3 4 5 7 8 6 6 7 8
	  remove_if(iv.begin(),iv.end(),bind2nd(less<int>,6));
      for_each(iv1.begin(),iv1.end(),display<int>()); //由于_X是static 所以接着 增长
      cout<<endl; //8 10 7 8 6 6 7 8 6 7 8 (最后三个是残留元素) 

	  //将小于7的元素 "删除"  iv3元素:8 10 3 4 5 7 8 7 8 0 0 (最后两个是残留元素)
	  remove_copy_if(iv.begin(),iv.end(),iv3.begin(),bind2nd(less<int>,7));
      for_each(iv3.begin(),iv3.end(),display<int>()); //由于_X是static 所以接着 增长
      cout<<endl; //8 10 7 8 7 8 7 8 8 0 0(最后三个残留元素) 

  	 return 0;
} 

第二段算法示例:

#include <iostream>
#include <algorithm>
#include <vector>
#include <functional>

using namespace std;

template <class T>
struct display
{
	void operator()(const T &x)const
	{
		cout<<x<<" ";
	} 

}; 

int main()
{
	int ia[]={8,10,7,8,6,6,7,8,6,7,8};
	vector<int> iv(ia,ia+sizeof(ia)/sizeof(int));

	//将容器中6 替换为 3
    replace(iv.begin(),iv.end(),6,3);
    for_each(iv.begin(),iv.end(),display<int>()); //由于_X是static 所以接着 增长
    cout<<endl; //iv:8 10 7 8 3 3 7 8 3 7 8 

	vector<int> iv2(12);
	//将容器中3 替换为 5 放入另一个容器
    replace_copy(iv.begin(),iv.end(),iv2.begin(),3,5);
    for_each(iv2.begin(),iv2.end(),display<int>()); //由于_X是static 所以接着 增长
    cout<<endl; //iv2:8 10 7 8 5 5 7 8 5 7 8 0(最后y一个残留元素) 

    //将容器中小于 5 替换为 2
    replace_if(iv.begin(),iv.end(),bind2nd(less<int>(),5),2);
    for_each(iv.begin(),iv.end(),display<int>()); //由于_X是static 所以接着 增长
    cout<<endl; //iv:8 10 7 8 2 5 7 8 2 7 8 

	//将容器中小于 5 替换为 2
    replace_copy_if(iv.begin(),iv.end(),iv2.begin(),bind2nd(equal_to<int>(),8),9);
    for_each(iv2.begin(),iv2.end(),display<int>()); //由于_X是static 所以接着 增长
    cout<<endl; //iv2:9 10 7 8 2 5 7 9 2 7 8 0(最后一个残留元素) 

    //逆向重排每一个元素 (倒置)
    reverse(iv.begin(),iv.end());
    for_each(iv.begin(),iv.end(),display<int>());
	cout<<endl; //iv:8 7 2 8 7 5 2 8 7 10 8

	//逆向重排每一个元素 (倒置)
    reverse_copy(iv.begin(),iv.end(),iv2.begin());
    for_each(iv2.begin(),iv2.end(),display<int>());
	cout<<endl; //iv2:8 10 7 8 2 5 7 8 2 7 8 0 (最后一个残留元素)  

    // 互换元素  [bigin,middle)  [middle,end)
    rotate(iv.begin(),iv.begin()+4,iv.end());
    for_each(iv.begin(),iv.end(),display<int>());
    cout<<endl;//iv:7 2 2 8 7 10 8 8 7 2 8 

    // 互换元素  [bigin,middle)  [middle,end)
    rotate_copy(iv.begin(),iv.begin()+5,iv.end(),iv2.begin());
    for_each(iv2.begin(),iv2.end(),display<int>());
    cout<<endl;//iv2:10 8 8 7 2 8 7 2 2 8 7 0 (最后一个是残留元素) 

	//在iv中查找 子序列 2 8 第一次出现的位置的元素
	int ia2[3]={2,8};
	vector<int> iv3(ia2,ia2+2);
	cout<<*search(iv.begin(),iv.end(),iv3.begin(),iv3.end())<<endl; //2 

	//在iv中查找 2个8 出现的第一个位置的元素
	cout<<*search_n(iv.begin(),iv.end(),2,8)<<endl; //8 

	//在iv中查找 3个小于8 出现的第一个位置的元素
	cout<<*search_n(iv.begin(),iv.end(),3,8,less<int>())<<endl; //7

	swap_ranges(iv3.begin(),iv3.end(),iv.begin());
	cout<<"iv:";
    for_each(iv.begin(),iv.end(),display<int>());//iv:2 8 2 8 7 10 8 8 7 2 8
    cout<<endl;
	cout<<"iv3:";
    for_each(iv3.begin(),iv3.end(),display<int>()); //iv3: 7 2
    cout<<endl;

    //全部减2
    transform(iv.begin(),iv.end(),iv.begin(),bind2nd(minus<int>(),2));
    for_each(iv.begin(),iv.end(),display<int>());//0 6 0 6 5 8 6 6 5 0 6
    cout<<endl; 

     //两个区间元素相加然后放到 iv上
    transform(iv.begin(),iv.end(),iv.begin(),iv.begin(),plus<int>());
    for_each(iv.begin(),iv.end(),display<int>());
    cout<<endl; //0 12 0 12 10 16 12 12 10 0 12

  	 return 0;
}

第三段算法示例:

#include <iostream>
#include <algorithm>
#include <vector>
#include <functional>

using namespace std;

template <class T>
struct display
{
	void operator()(const T &x)const
	{
		cout<<x<<" ";
	} 

};
struct even
{
	bool operator()(int x)const
	{
		return x%2?false:true;
	}
};

int main()
{
	int ia[]={0,1,2,3,4,5,6,6,6,7,8};
	vector<int> iv(ia,ia+sizeof(ia)/sizeof(int));
	vector<int> iv2(ia+4,ia+8);//4 5 6 6
	vector<int> iv3(15);

    cout<<*max_element(iv.begin(),iv.end())<<endl;
	cout<<*min_element(iv.begin(),iv.end())<<endl; 

    //判断iv2中元素是否都出现在 iv中
	cout<<includes(iv.begin(),iv.end(),iv2.begin(),iv2.end())<<endl; 

	//iv 和iv2合并到iv3中
	merge(iv.begin(),iv.end(),iv2.begin(),iv2.end(),iv3.begin());
	for_each(iv3.begin(),iv3.end(),display<int>());
	cout<<endl; 

	//符合条件的 放到前面,不符合条件的放到后面
	partition(iv3.begin(),iv3.end(),even());
    for_each(iv3.begin(),iv3.end(),display<int>());
	cout<<endl; 

	//去除连续并且重复的元素
	unique(iv.begin(),iv.end());
	for_each(iv.begin(),iv.end(),display<int>());
	cout<<endl; 

	//去除连续并且重复的元素
	unique_copy(iv.begin(),iv.end(),iv3.begin());
	for_each(iv3.begin(),iv3.end(),display<int>());
	cout<<endl; 

  	 return 0;
}

八,复杂算法示例(解释在源码中)

#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>

using namespace std;

struct even //是否是奇数
{
	bool operator()(int x)const
	{
		return x%2?false:true;
	} 

};
template<class T>
struct display
{
	void operator()(T &x)const
	{
		cout<<x<<" ";
	} 

}; 

int main()
{
	int ia[] = {12,17,20,22,23,30,33,40};
	vector<int> iv(ia,ia+sizeof(ia)/sizeof(int));

	//返回可以插入的第一个位置
	cout<<*lower_bound(iv.begin(),iv.end(),21)<<endl; //22
	cout<<*upper_bound(iv.begin(),iv.end(),21)<<endl; //22
	//返回可以插入的最后一个位置
	cout<<*lower_bound(iv.begin(),iv.end(),22)<<endl; //22
	cout<<*upper_bound(iv.begin(),iv.end(),22)<<endl; //23

	//二分查找某个元素,返回是否找到
	cout<<binary_search(iv.begin(),iv.end(),33)<<endl; //1
	cout<<binary_search(iv.begin(),iv.end(),34)<<endl; //0 

	//生成下一个排列组合(字典序)
    next_permutation(iv.begin(),iv.end());
	for_each(iv.begin(),iv.end(),display<int>());
	cout<<endl; 

	prev_permutation(iv.begin(),iv.end());
	for_each(iv.begin(),iv.end(),display<int>());
	cout<<endl; 

	//打乱顺序
	random_shuffle(iv.begin(),iv.end());
	for_each(iv.begin(),iv.end(),display<int>());
	cout<<endl;

	//找出最小的4个元素 放在前四个 后面顺序不一定有序
	partial_sort(iv.begin(),iv.begin()+4,iv.end());
	for_each(iv.begin(),iv.end(),display<int>());
	cout<<endl;

	//排序(缺省为递增排序)
	sort(iv.begin(),iv.end());
	for_each(iv.begin(),iv.end(),display<int>());
	cout<<endl;

	 //排序(设置为递减)
	sort(iv.begin(),iv.end(),greater<int>());
	for_each(iv.begin(),iv.end(),display<int>());
	cout<<endl;

	iv.push_back(22);
	iv.push_back(30);
	iv.push_back(17);

	//排序并保持原相对位置
	stable_sort(iv.begin(),iv.end());
	for_each(iv.begin(),iv.end(),display<int>());
	cout<<endl;//12 17 17 20 22 22 23 30 30 33 40 

	pair<vector<int>::iterator,vector<int>::iterator> pairIte;
	//返回等于22的一个小区间
	pairIte = equal_range(iv.begin(),iv.end(),22);
    cout<<*(pairIte.first)<<endl;//lowerbound 22
	cout<<*(pairIte.second)<<endl; //upperbound 23

	//这里返回一个空区间
    pairIte = equal_range(iv.begin(),iv.end(),25);
    cout<<*(pairIte.first)<<endl;//lowerbound 30
	cout<<*(pairIte.second)<<endl; //upperbound 30

	 //打乱顺序
    random_shuffle(iv.begin(),iv.end());
    for_each(iv.begin(),iv.end(),display<int>());
	cout<<endl;

	//将小于iv.begin+5的放到左边
	nth_element(iv.begin(),iv.begin()+5,iv.end());
	for_each(iv.begin(),iv.end(),display<int>());
	cout<<endl;

	//将小于iv.begin+5的放到右边
	nth_element(iv.begin(),iv.begin()+5,iv.end(),greater<int>());
	for_each(iv.begin(),iv.end(),display<int>());
	cout<<endl;

	//排序
	stable_sort(iv.begin(),iv.end(),even());
    for_each(iv.begin(),iv.end(),display<int>());
	cout<<endl;

	return 0;
}
时间: 2024-10-21 04:22:38

[C++STL]算法<algorithm>中各种算法解析的相关文章

【转】STL算法 &lt;algorithm&gt;中各种算法解析

原文:http://blog.csdn.net/tianshuai1111/article/details/7674327 一,巡防算法 for_each(容器起始地址,容器结束地址,要执行的方法) #include <iostream> #include <algorithm> #include <vector> using namespace std; template<class T> struct plus2 { void operator()(T&

STL源码剖析——STL算法之find查找算法

前言 由于在前文的<STL算法剖析>中,源码剖析非常多,不方便学习,也不方便以后复习,这里把这些算法进行归类,对他们单独的源码剖析进行讲解.本文介绍的STL算法中的find.search查找算法.在STL源码中有关算法的函数大部分在本文介绍,包含findand find_if.adjacent_find.search.search_n.lower_bound. upper_bound. equal_range.binary_search.find_first_of.find_end相关算法,下

数据结构(DataStructure)与算法(Algorithm)、STL应用

catalogue 0. 引论 1. 数据结构的概念 2. 逻辑结构实例 2.1 堆栈 2.2 队列 2.3 树形结构 2.3.1 二叉树 3. 物理结构实例 3.1 链表 3.1.1 单向线性链表 3.1.2 单向循环链表 3.1.3 双向线性链表 3.1.4 双向循环链表 3.1.5 数组链表 3.1.6 链表数组 3.1.7 二维链表 3.2 顺序存储 4. 算法 4.1 查找算法 4.2 排序算法 0. 引论 0x1: 为什么要学习数据结构 N.沃思(Niklaus  Wirth)教授提

STL 笔记(五) 算法 algorithm

在 STL 中,算法是一系列的函数模版.STL 提供了大概 70 个算法,由头文件 <algorithm>.<numeric>.<functional>组成. 头文件 <algorithm>  是最大的一个,里面常用到的功能有:查找.排序.修改.移除.交换.合并等: 头文件 <numeric>  较小,主要包括数序运算的函数模版: 头文件 <functional>  中则定义了一些类模版,来声明函数对象: 算法的分类: 算法按其实现的

STL中的算法小结

(1)要运用STL的算法,首先必须包含头文件<algorithm>,某些STL算法用于数值处理,因此被定义于头文件<numeric> (2)所有STL算法都被设计用来处理一个或多个迭代器区间,第一个区间通常以起点和终点表示,至于其他区间,多数情况下你只需提供起点便足以,其终点可以自动以第一个区间的元素数量推断出来,调用者必须保证这些区间的有效性. STL算法采用覆盖模式而非安插模式,所以调用者必须保证目标区间拥有足够的元素空间,当然你也可以运用特殊的安插型迭代器将覆盖模式改变为安插

C++中的算法头文件&lt;algorithm&gt;,&lt;numeric&gt;和&lt;functional&gt;

算法部分主要由头文件<algorithm>,<numeric>和<functional>组成.<algorithm>是所有STL头文件中最大的一个,它是由一大堆模版函数组成的,可以认为每个函数在很大程度上都是独立的,其中常用到的功能范围涉及到比较.交换.查找.遍历操作.复制.修改.移除.反转.排序.合并等等.相关函数:http://www.cplusplus.com/reference/algorithm/<numeric>体积很小,只包括几个在

STL中排序算法的选择

 当大多数程序员需要对一组对象进行排序的时候,首先想到的一个算法是sort.sort是一个非常不错的算法,但它也并非在任何场合下都是完美无缺的.有时候我们并不需要一个完全的排序操作.比如说,如果我们有一个存放Widget的矢量,而我们希望将质量最好的20个Widget送给最重要的顾客,按照顾客的重要程度送上不同质量的Widget,那么只需要排序出前20个最好的Widget,其他的Widget可以不用排序.在这种情况下,需要的是一种部分排序的功能,而有一个名为partial_sort的算法正好

STL中heap算法(堆算法)

 ①push_heap算法 以下是push_heap算法的实现细节.该函数接收两个迭代器,用来表现一个heap底部容器(vector)的头尾,而且新元素已经插入究竟部的最尾端. template <class RandomAccessIterator> inline void push_heap(RandomAccessIterator first,RandomAccessIterator last) { //注意,此函数被调用时,新元素应已置于底部容器的最尾端 _push_heap_au

STL函数 lower_bound 和 upper_bound 在算法竞赛中的用法

以前比较排斥这两个函数,遇到二分都是手写 \(while(left<=right)\). 这次决定洗心革面记录一下这两个函数的在算法竞赛中的用法,毕竟一般不会导致TLE. 其实百度百科已经概述得比较清楚了, 我们假设 \(value\) 为一个给定的数值, \(lower\_bound\) 是在一个升序序列中从前后后找第一个大于等于 \(value\) 的值, \(upper\_bound\) 是在一个升序序列中从前后后找第一个大于 \(value\) 的值. 比如:\(lower\_bound