C++ STL 学习笔记

（一）   STL：

（A）#include <iostream> #include <algorithm> using namespace std;

1）  void sort( iterator start, iterator end );

void sort( iterator start, iterator end, StrictWeakOrdering cmp );

cmp函数的参数类型只能和sort中排序的类型相同。

sort_heap 和sort 的使用方法相同。

void sort_heap( iterator start, iterator end );

void sort_heap( iterator start, iterator end, StrictWeakOrdering cmp );

2）  a: bool binary_search( iterator start, iterator end, const TYPE& val );  bool binary_search( iterator start, iterator end, const TYPE& val, Comp f ); val表示的是要查找的值。

If val is found, binary_search() returns true, otherwise false

b:InputIterator find ( InputIterator first, InputIterator last, const T& value );

the usage would be:

cout<<find(a,a+20,5)-a<<endl;

or using the vector.

3）  iterator partition( iterator start, iterator end, Predicate p );

通过p将元素分为两个部分。

iterator stable_partition( iterator start, iterator end, Predicate p );

不改变元素的顺序。

4）  reverse(start,end) which can be used by combined with the <for_each(start,end,action)>like:

reverse(a,a+20);for_each(a,a+20,act); void act(int i){cout<<i<<” “;}cout<<endl;

5）  remove(start , end, ele); remove the ele in the container.start to container.end. and the function return the last position of the container after remove the ele.

6）  replace(start,end,old,new) using the new element to replace the old element in the range of [start,end]

7）  rotate(start,mid,end) chang the range of [start,mid] with [mid,end] and the usage of it is the same of rp.

8）  swap_ranges(arr1.start,arr1.end,arr2) this function change the range of arr1[start,end] with arr2.

9）  transform(arr1.start,arr1.end,arr2,act) this function is cast the effect of act on the range of arry1 from start to end, and store the new element in the array2. Note that we need to initialize the array2 with enough space in order to store the element before recall transform

10）                 unique（arr.start,arr.end） this function will remove any sequential element in the array. And it will return iterator(if using vector) or int* ( you can check the usage in the program present below)

（二）   numeric：

(A)  #include <numeric> #include <iostream> using namespace std;

1)      accumulate(start,end,init) init means the initial sum. By default the operation is sum, while the user can define other operation by define a function Like:

a)         int myFunction(int x, int y){ return x+2*y;}

b)        accumulate(start,end,init,myFunction);

2)      numeric also include other standard function like:

adjacent_difference, inner_product, partial_sum which I need to acknowledge.

#include <iostream>
#include <algorithm>
#include <vector>
#include <numeric>
using namespace std;

bool cmp(int a , int b)
{
	return a>b;
}
struct Point
{
	int x;
	int y;
};
bool cmp1(Point a,Point b)
{
	if(a.x == b.x)
		return a.y>b.y;
	else
		a.x >b.x;
}
void op1(int i)	{ cout<<i<<' ';}
bool isOdd(int i){ return (i%2)==1;}
int op_increase(int i){ return ++i;}
int main()
{
	int i,j,k;
	int a[20] = {10,23,5,34,5,56,34,53,304,457,3,
		46,34,2345,35,34,444,45,34};
	Point p[5] = {​{1,2},{5,2},{1,7},{2,6},{3,3}};

	//===============================================
	cout<<"sort+struct"<<endl;
	sort(p,p+5,cmp1);
	for(j = 0 ; j < 5; j++)
		printf("(%d,%d) ",p[j].x,p[j].y);
	cout<<endl;

	//=====================================
	vector<int> myVector(a,a+20);
	vector<int>::iterator bound = partition(myVector.begin(),myVector.end(),isOdd);
	cout<<"partition odd"<<endl;
	vector<int>::iterator it;
	for(it = myVector.begin();it!=bound;it++)
		cout<<*it<<" ";
	cout<<endl<<"partition even"<<endl;
	for(it = bound ;it!=myVector.end();it++)
		cout<<*it<<" ";
	cout<<endl;
	//==========================================
	int n;
	cout<<"sort/n";
	//sortÒ²¿ÉÒÔ×Ô¶¨ÒåÓû§µÄ±È½Ïº¯Êý,µ«ÊǺÍqsort²»Í¬ÕâÀïcmpº¯ÊýµÄ²ÎÊýҪΪÌض¨µÄÖµ£¬²»ÄÜΪconst void*£»
	sort(a,a+20,cmp);
	//sort_heap ÓësortµÄʹÓ÷½·¨Ïàͬ¡£
	//sort_heap(a,a+20,cmp);
	for(i = 0 ; i < 20; i++)
		cout<<a[i]<<" ";
	cout<<endl;
	//============================================================
	cout<<"reverse the array"<<endl;
	reverse(a,a+20);
	for_each(a,a+20,op1);
	cout<<endl;
	//============================================================
	// accumulate is not stl but numeric;
	vector<int> v1(a,a+20);
	cout<<"the sum of vector v is : "<<accumulate(v1.begin(),v1.end(),0)<<endl;
	cout<<"the sum of array a is : "<<accumulate(a,a+20,0)<<endl;
	//==================================================================

	cout<<"find in the array"<<endl;
	cout<<find(a,a+20,5)-a<<endl;
	//==================================================================
	cout<<"find the first of : in the array"<<endl;
	cout<<*find_first_of(a,a+10,a,a+20)<<endl;
	//==================================================================
	cout<<"remove the element from the array:"<<endl;
	int* start = a;//the pointer after the remove will change;
	int* end = a+sizeof(a)/sizeof(int);
	end = remove(start,end,5);
	//for_each(a,a+sizeof(a)/sizeof(int),op1);
	for_each(start,end,op1);
	//for(int* pp = start; pp<end; ++pp)
	//	cout<<*pp<<" ";
	//cout<<endl;
	//==================================================================
	cout<<"/nreplace in the array"<<endl;
	replace(a,a+18, 3,-1);
	for_each(a,a+18,op1);
	//==================================================================
	cout<<"rotate in the array"<<endl;
	rotate(a,a+3,a+18);
	for_each(a,a+18,op1);
	cout<<endl;
	//==================================================================
	cout<<"swap_range"<<endl;
	int ar1[5] = {1,1,1,1,1};
	int ar2[5] = {2,2,2,2,3};
	swap_ranges(ar1,ar1+5,ar2);
	for_each(ar1,ar1+5,op1);
	cout<<endl;
	for_each(ar2,ar2+5,op1);
	cout<<endl;
	//================================================================
	cout<<"transform"<<endl;
	int *new_array = new int[sizeof(ar1)/sizeof(int)];
	transform(ar1,ar1+5,new_array,op_increase);
	for_each(new_array,new_array+5,op1);
	cout<<endl;
	//==================================================================
	cout<<"unique"<<endl;
	int* l = unique(ar1,ar1+5);
	for_each(ar1,ar1+*l,op1);
	cout<<endl;
	//==================================================================
	while(cin>>n)
	{
		//binary_search ʹÓÃ֮ǰһ¶¨Òª½«Êý×éÅźÃ˳Ðò²Å¿ÉÒÔʹÓá£
		cout<<"binary_search()"<<endl;
		if(binary_search(a,a+20,n))
			printf("yes/n");
		else
			printf("no/n");
	}
	
	return 0;
}