STL 排序算法

最新推荐文章于 2025-03-30 17:09:01 发布
原创 最新推荐文章于 2025-03-30 17:09:01 发布 · 934 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了STL中的各种排序算法及其应用示例，包括通用排序、部分排序、堆操作等，并展示了如何利用这些算法进行高效的数据处理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

STL中的排序算法及其他主要包括：

1，排序 2，第n个元素 3，二分检索  4，归并  5，序结构上的集合操作   6，堆操作   7，最大和最小  8，词典比较 9，排列生成器 10，数值算法

 

1，排序：

 

sort()，stable_sort()，partial_sort()，partial_sort_copy()

template<class RanIt>
void sort(RanIt first , RanIt last;
template<class RanIt ,class Pred>
void sort(RanIt  first, RanIt last, Pred pr);

template<class RanIt>
void stable_sort(RanIt  first,RanIt last)
template<class RanIt,class Pred>
void stable_sort(RanIt first,RanIt last,Pred pr);

template<class RanIt>
void partial_sort(RanIt first,RanIt  middle,RanIt last);
template<class RanIt,class Pred>
void partial_sort(RanIt first,RanIt middle,RanIt last,Pred pr);

template<class Init,class RanIt>
RanIt partial_sort_copy(Init first1 , Init last1, RanIt first2,RanIt last2);
template<class Init,class RanIt,class Pred>
RanIt partial_sort_copy(Init first1,Init last1,RanIt first1 , RanIt last2,Pred pr);

示例：

1，>

 

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

using  namespace std;

int main()
{
	int a[] = {1,8,6,10,4};
	vector<int> v(a,a+5);
	sort(v.begin(),v.end());

	cout << "sort as increment : " << endl;
	copy(v.begin(),v.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;

	return 0;
}


2,>

 

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

using  namespace std;

bool myless(int &m,int &n)
{
	return m > n;
}

int main()
{
	int a[] = {1,8,6,10,4};
	vector<int> v(a,a+5);
	sort(v.begin(),v.end(),myless);

	cout << "sort as decrement : " << endl;
	copy(v.begin(),v.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;

	return 0;
}


3,>

 

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

using namespace std;

class Student
{
public:
	int NO;
	string name;
	int grade;
	
	Student(int NO,string name,int grade)
	{
		this -> NO = NO;
		this -> name = name;
		this -> grade = grade;
	}

	bool operator< (const Student &s) const
	{
		return grade < s.grade;
	}
};

ostream & operator << (ostream &os,const Student & s)
{
	os << s.NO << "\t" << s.name << "\t" << s.grade;
	return os;
}

int main()
{
	Student s1(101,"zhangsan",90);
	Student s2(102,"lisi",80);
	Student s3(103,"wangwu",85);
	Student s4(103,"zhaoliu",65);

	vector<Student> v;
	v.push_back(s1);
	v.push_back(s2);
	v.push_back(s3);
	v.push_back(s4);

	sort(v.begin(),v.end());
	cout << "sort as increment : " << endl;
	cout << "NO\tname\tgrade" << endl;
	copy(v.begin(),v.end(),ostream_iterator<Student>(cout,"\n"));
	
	return 0 ;
};


4,>

 

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

using namespace std;

int main()
{
	int a[] = {10,1,3,9,7,6,2,4,5,8};
	vector<int> v(a,a+10);
	cout << "Org vector data: ";
	copy(v.begin(),v.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;

	partial_sort(v.begin(),v.begin()+4,v.end());
	cout << "After partial_sort : ";
	copy(v.begin(),v.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;

	return 0;
}


 

5,>

 

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

using namespace std;

class Student
{
public:
	int NO;
	string name;
	int grade;
	
	Student() {}
	Student(int NO,string name,int grade)
	{
		this -> NO = NO;
		this -> name = name;
		this -> grade = grade;
	}

	bool operator> (const Student &s) const
	{
		return grade > s.grade;
	}
};

int main()
{
	vector<Student> v;
	Student s1(101,"aaa",90);
	Student s2(102,"bbb",80);
	Student s3(103,"ccc",60);
	Student s4(104,"ddd",96);
	Student s5(105,"eee",95);
	Student s6(106,"fff",78);
	Student s7(107,"ggg",94);
	Student s8(108,"hhh",92);

	v.push_back(s1);
	v.push_back(s2);
	v.push_back(s3);
	v.push_back(s4);
	v.push_back(s5);
	v.push_back(s6);
	v.push_back(s7);
	v.push_back(s8);

	vector<Student> vResult(3);
	partial_sort_copy(v.begin(),v.end(),vResult.begin(),vResult.end(),greater<Student>());

	for(int i = 0 ;i < vResult.size(); i++)
	{
		Student & s = vResult.at(i);
		cout << s.NO << "\t" << s.name << "\t" << s.grade << endl;
	}

	return 0 ;
};


 

6,>

 

#include <iostream>
#include <list>
#include <algorithm>

using namespace std;

int main()
{
	int a[] = {10,1,3,9,7,6,2,4,5,8};

	list<int> l(a,a+10);
//	l.sort(l.begin(),l.end());   错误调用，因为list特殊，重载了sort!
	l.sort(greater<int>());
	copy(l.begin(),l.end(),ostream_iterator<int>(cout,"\t"));

	return 0;
}


2,第n个元素

 

nth_element()

template<class RanIt>
void nth_element(RanIt first,RanIt nth,RanIt last);

template<class RanIt,class Pred>
void nth_element(RanIt first,RanIt nth,RanIt last,Pred pr);

示例：

 

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

using namespace std;

class Student
{
public:
	int NO;
	string name;
	int grade;

	Student(int NO,string name,int grade)
	{
		this -> NO = NO;
		this -> name = name;
		this -> grade = grade;
	}

	bool operator > (const Student & s) const
	{
		return grade > s.grade;
	}
};

int main()
{
	vector<Student> v;

	Student s1(101,"aaa",90);
	Student s2(102,"bbb",80);
	Student s3(103,"ccc",60);
	Student s4(104,"ddd",96);
	Student s5(105,"eee",95);
	Student s6(106,"fff",78);
	Student s7(107,"ggg",94);
	Student s8(108,"hhh",92);

	v.push_back(s1);
	v.push_back(s2);
	v.push_back(s3);
	v.push_back(s4);
	v.push_back(s5);
	v.push_back(s6);
	v.push_back(s7);
	v.push_back(s8);

	nth_element(v.begin(),v.begin()+2,v.end(),greater<Student>());
	vector<Student>::iterator it = v.begin()+2;

	cout << "the 3th good student info : " << endl;
	cout << "ID\tname\tgrade" << endl;
	cout << (*it).NO << "\t" << (*it).name << "\t" << (*it).grade << endl;

	return 0;
}


 

3，二分检索

 

lower_bound() , upper_bound() , equal_range() , binary_search()

template<class FwdIt, class T>
FwdIt lower_bound(FwdIt first,FwdIt last,const T &val);
template<class FwdIt,class T,class Pred>
FwdIt lower_bound(FwdIt first,FwdIt last,const T &val,Pred pr);

template<class FwdIt,class T>
FwdIt upper_bound(FwdIt first, FwdIt last,const T &val);
template<class FwdIt,class T,class Pred>
FwdIt upper_bound(FwdIt first,FwdIt last,const T &val,Pred pr);

template<class FwdIt,class T>
pair<FwdIt,FwdIt> equal_range(FwdIt first,FwdIt last,const T &val);
template<class FwdIt,class T,class Pred>
pair<FwdIt,FwdIt>equal_range(FwdIt fist,FwdIt last,const T &val,Pred pr);

template<class FwdIt,class T>
bool binary_search(FwdIt first ,FwdIt last, const T &val);
template<class FwdIt,class T,class Pred>
bool binary_search(FwdIt first,FwdIt last,const T &val,Pred pr);

示例：

 

#include <iostream>
#include <algorithm>
#include <list>

using namespace std;

int main()
{
	int a[] = {1,2,2,3,3,3,4,4,4,4};

	list<int> l1(a,a+10);
	cout << "org data a[] = ";
	copy(l1.begin(),l1.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;

	bool bExist = binary_search(l1.begin(),l1.end(),5);
	cout << "have element 5 ? " << (bExist==0?"false" : "true") << endl;

	list<int>::iterator first2 = lower_bound(l1.begin(),l1.end(),2);
	if(first2 != l1.end())
	{
		cout <<  "the first element 2 appear : " << distance(l1.begin(),first2) << endl;
	}

	list<int>::iterator last3 = upper_bound(l1.begin(),l1.end(),3);
	if(last3 != l1.end())
	{
		cout << "the last element 3 appear : " << distance(l1.begin(),--last3) << endl;;
	}

	pair<list<int>::iterator,list<int>::iterator> p = equal_range(l1.begin(),l1.end(),4);
	if(p.first != l1.end())
	{
		int nSize = distance(p.first,p.second);
		cout << "Total have element 4 is : " << nSize <<endl;
	}

	return 0 ;
}


 

4，归并

 

merge() , inplace_merge()

template<class Init1,class Init2,class OutIt>
OutIt merge(Init1 first,Init1 last1,Init2 first2,Init2 last2,OutIt x);
template<class Init1,class Init2,class OutIt,class Pred>
OutIt merge(Init1 first1,Init1 last1,Init2 first2,Init2 last2,OutIt x,Pred pr);

template<class BidIt>
void inplace_merge(BidIt first,BidIt middle,BidIt last)
template<class BidIt,class Pred>
void inplace_merge(BidIt first,BidIt middle,BidIt last, Pred pr);

示例：

 

#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
	int a[] = {1,3,5,7};
	int b[] = {2,4,6,8};
	int result[8];
	cout << "Org a[] = " << endl;
	copy(a,a+4,ostream_iterator<int>(cout,"\t"));
	cout << endl;
	cout << "Org b[] = " << endl;
	copy(b,b+4,ostream_iterator<int>(cout,"\t"));
	cout << endl;

	merge(a,a+4,b,b+4,result);
	cout << "After a[],b[] merge: " << endl;
	copy(result,result+8,ostream_iterator<int>(cout,"\t"));
	cout << endl << endl;

	int c[8] = {1,3,4,8,2,5,6,7};
	cout << "Org c[] = " << endl;
	copy(c,c+8,ostream_iterator<int>(cout,"\t"));
	cout << endl;
	inplace_merge(c,c+4,c+8);
	cout << "After c[] inplace_merge : " << endl;
	copy(c,c+8,ostream_iterator<int>(cout,"\t"));
	cout << endl;

	return 0;
}


 

5，有序结构上的集合操作：

 

includes(),  set_union(), set_intersection() , set_difference() , set_symmetric_difference() 

template<class Init1,class Init2>
bool includes(Init1 first1,Init1 last1,Init2 first2,Init2 last2);
template<class Init1,class Init2,class Pred>
bool includes(Init1 first1,Init1 last1,Init2 first2,Init2 last2,Pred pr);

template<class Init1,class Init2,class OutIt>
OutIt set_union(Init1 first1,Init1 last1,Init2 first2,Init2 last2,OutIt x);
tempalte<class Init2,class Init2 ,class OutIt,class Pred>
OutIt set_union(Init1 first1,Init1 last1,Init2 first2,Init2 last2,OutIt x,Pred pr);

template<class Init1,class Init2,class OutIt>
OutIt set_intersection(Init1 first1,Init1 last1,Init2 first2,Init2 last2,OutIt x)
template<class Init1,class Init2,class OutIt,class Pred>
OutIt set_intersection(Init1 first,Init1 last1,Init2 first2,Init2 last2,OutIt x,Pred pr);

template<class Init1,class Init2,class OutIt>
OutIt set_difference(Init1 first1,Init1 last1,Init2 first2,Init2 last2,OutIt x);
template<class Init1,class Init2,class OutIt,class Pred>
OutIt set_difference(Init1 first1,Init1 last1,Init2 first2,Init2 last2,OutIt x,Pred pr);

template<class Init1,class Init2,class OutIt>
OutIt set_symmetric_difference(Init1 first1,Init1 last1,Init2 first2,Init2 last2,OutIt x);
template<class Init1,class Init2,class OutIt,class Pred>
OutIt set_symmetric_dirrerence(Init1 first1,Init1 last1,Init2 first1,Init2 last2,OutIt x,Pred pr);

示例：

1,>

 

#include <iostream>
#include <list>
#include <algorithm>

using namespace std;

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

	list<int> l1(a,a+5);
	list<int> l2(b,b+4);

	cout << "org l1 = ";
	copy(l1.begin(),l1.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;
	cout << "org l2 = ";
	copy(l2.begin(),l2.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;

	bool bRet = includes(l1.begin(),l1.end(),l2.begin(),l2.end());
	cout << "l1 include l2 ? " << (bRet == 1? "yes" : "no") << endl;
	list<int>l3;
	set_union(l1.begin(),l1.end(),l2.begin(),l2.end(),back_inserter(l3));
	cout << "l1 ²¢ l2 : " << endl;
	copy(l3.begin(),l3.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;

	list<int> l4;
	set_intersection(l1.begin(),l1.end(),l2.begin(),l2.end(),back_inserter(l4));
	cout << "l1 ½» l2 : " << endl;
	copy(l4.begin(),l4.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;

	list<int> l5;
	set_difference(l1.begin(),l1.end(),l2.begin(),l2.end(),back_inserter(l5));
	cout << "l1 ²î l2 : " << endl;
	copy(l5.begin(),l5.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;

	list<int> l6;
	set_symmetric_difference(l1.begin(),l1.end(),l2.begin(),l2.end(),back_inserter(l6));
	cout << "l1 ¶Ô³Æ²î l2 : " << endl;
	copy(l6.begin(),l6.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;

	list<int> l7;
	merge(l1.begin(),l1.end(),l2.begin(),l2.end(),back_inserter(l7));
	cout << "l1 merge l2 : " << endl;
	copy(l7.begin(),l7.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;

	return 0;
}


2,>

 

#include <iostream>
#include <algorithm>

using namespace std;

struct Student
{
	int NO;
	char name[20];
	bool operator < (Student &s)
	{
		return NO < s.NO;
	}
};

int main()
{
	bool bRet = true;

	Student s1[] = {{1001,"zhang"},{1003,"li"},{1004,"wang"},{1002,"zhao"}};
	Student s2[] = {{1001,"zhang"},{1004,"wang"},{1002,"zhao"}};

	sort(s1,s1+4);
	sort(s2,s2+3);
	bRet = includes(s1,s1+4,s2,s2+3);

	cout << (bRet == true ? "s1 include s2" : "s1 not includes s2") << endl;

	return 0;
}


3,>

 

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

struct Student
{
	int NO;
	string name;
	int chinese;
	int math;
public:
	bool operator< (const Student &s)
	{
		if(NO == s.NO)
		{
			math = s.math;
		}
		return NO < s.NO;
	}
};

int main()
{
	vector<Student> v1;
	vector<Student> v2;

	ifstream in1("1.txt");
	ifstream in2("2.txt");

	while(!in1.eof())
	{
		Student s;
		in1 >> s.NO >> s.name >> s.chinese;
		v1.push_back(s);
	}

	while(!in1.eof())
	{
		Student s;
		in2 >> s.NO >> s.name >> s.math;
		v2.push_back(s);
	}

	in1.close();
	in2.close();

	set_union(v1.begin(),v1.end(),v2.begin(),v2.end(),v1.begin());
	for(int i = 0 ; i < v1.size();i ++)
	{
		Student &s = v1.at(i);
		cout << s.NO << "\t" << s.name << "\t" << s.chinese << s.math << endl;
	}

	return 0;
}


 

 6，堆操作

 

make_heap() , pop_heap() , push_heap() , sort_heap() 

template<class RanIt>
void make_heap(RanIt first,RanIt last);
template<class RanIt ,class Pred>
void make_heap(RanIt first,RanIt last,Pred pr);

template<class RanIt>
void pop_heap(RanIt first,RanIt last);
template<class RanIt>
void pop_heap(RanIt first,RanIt last,Pred pr);

template<class RanIt>
void push_heap(RanIt first,RanIt last)
template<class RanIt,clas Pred>
void push_heap(RanIt first,RanIt last,Pred pr)

template<class RanIt>
void sort_heap(RanIt first,RanIt last);
template<class RanIt,class Pred>
void sort_heap(RanIt first,RanIt last,Pred pr);

 

 示例程序：

 

1,> 建最大堆，建最小堆，求堆中最大值和次大值

 

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

using namespace std;

int main()
{
	int a[] = {1,4,2,10,6,5,9,7,8,3};
	cout << "org a[] = ";
	copy(a,a+10,ostream_iterator<int>(cout,"\t"));
	cout << endl;

	vector<int> v1(a,a+10);
	make_heap(v1.begin(),v1.end(),greater<int>());
	cout << "Min heap:" << endl;
	copy(v1.begin(),v1.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;

	vector<int> v2(a,a+10);
	make_heap(v2.begin(),v2.end(),less<int>());
	cout << "Max heap:" << endl;
	copy(v2.begin(),v2.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;

	pop_heap(v2.begin(),v2.end());
	cout << "Max value in heap : ";
	cout << *(v2.end()-1) << endl;
	pop_heap(v2.begin(),v2.end()-1);
	cout << "The second Max value in heap :";
	cout << *(v2.end()-2) << endl;

	return 0 ;
}


 

 

2,>   封装堆

 

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

using namespace std;

template<class T,class Pred = less<T> >
class MyHeap
{
	Pred pr;
	vector<T> v;
	int ValidSize;
public:
	MyHeap(T t[],int nSize):v(t,t+nSize)
	{
		ValidSize = nSize;
		make_heap(v.begin(),v.begin()+ValidSize,pr);
	}

	void Insert(const T &t)
	{
		v.push_back(t);
		ValidSize ++;
		push_heap(v.begin(),v.begin()+ValidSize,pr);
	}

	bool Remove(T &result)
	{
		if(ValidSize == 0)
			return false;
		pop_heap(v.begin(),v.begin()+ValidSize,pr);
		result = *(v.begin()+ValidSize-1);
		ValidSize --;
		return true;
	}

	void Sort()
	{
		if(ValidSize > 0)
			sort_heap(v.begin(),v.end()+Validsize);
	}

	bool IsEmpty()
	{
		return ValidSize == 0;
	}

	void Display()
	{
		copy(v.begin(),v.begin()+ValidSize,ostream_iterator<T>(cout,"\t"));
	}
};

int main()
{
	int a[] = {1,4,2,10,6};
	MyHeap<int,greater<int> >m(a,5);
	cout << "org heap:" << endl;
	m.Display();
	cout << endl;
	m.Insert(100);
	cout << "After insert heap : " << endl;
	m.Display();
	cout << endl;

	int result;
	m.Remove(result);
	cout << "Min value in heap : " << result << endl;
	m.Remove(result);
	cout << "The second Min value in heap : " << result << endl;

	return 0 ;
}


 

7，最大和最小：

 

min() , max() , min_element() , max_element() 

template<class T>
const T &  min(const T &x ,const T &y);
template<class T,class Pred>
const T & min(const T &x,const T &y,Pred pr);

template<class T>
const T & max(const T &x,const T &y);
template<class T,Pred pr>
const T & max(const T &x,const T &y,Pred pr);

template<class FwdIt>
FwdIt  min_element(FwdIt first,FwdIt last);
template<class FwdIt,class Pred>
FwdIt  min_element(FwdIt first, FwdIt last,Pred pr);

template<class FwdIt>
FwdIt max_element(FwdIt first,FwdIt last);
template<class FwdIt,class Pred>
FwdIt max_element(FwdIt first ,FwdIt last, Pred pr);

示例：

 

#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
	int a = _MIN(10,20);
	int b = _MAX(10,20);
	cout << "min(10,20) : " << a << endl;
	cout << "max(10,20) : " << b << endl;

	int c[] = {1,10,5,7,9};
	cout << "org c[] = ";
	copy(c,c+5,ostream_iterator<int>(cout,"\t"));
	cout << endl;

	int  * it_min = min_element(c,c+5);
	int  * it_max = max_element(c,c+5);
	cout << "the min value in c[]: " << *it_min << endl;
	cout << "the max value in c[]: " << *it_max << endl;

	return 0;
}


 

8，词典比较

 

lexicographical_compare()

template<class InIt1,class InIt2>
bool lexicographical_compare(InIt1 first1,InIt1 last1,InIt2 first2, InIt2 last2);
template<class Init1,class Init2,class Pred>
bool lexicographical_compare(Init1 first1,Init1 last1,Init2 first2,Init2 last2 , Pred pr);

示例：

1,>

 

#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
	int a[] = {1,2,3};
	int b[] = {1,2,2};

	bool bRet = lexicographical_compare(a,a+3,b,b+3);

	cout << (bRet == 1 ? "a[] < b[]" : "a[] > b[]") << endl;

	return 0;
}


 

2,>

 

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

using namespace std;

bool mycompare(vector<int> &v1,vector<int> &v2)
{
	return lexicographical_compare(v1.begin(),v1.end(),v2.begin(),v2.end());
}

int main()
{
	int a[] = {1,2,3};
	int b[] = {1,2,2};
	int c[] = {1,2,3,1};

	vector<int> v[3] = {vector<int>(a,a+3),vector<int>(b,b+3),vector<int>(c,c+4)};
	
	cout << "org 3 vector : " << endl;
	for(int i = 0 ;i < 3 ;i ++)
	{
		copy(v[i].begin(),v[i].end(),ostream_iterator<int>(cout,"\t"));
		cout << endl;
	}

	sort(v,v+3,mycompare);

	cout << "After sort(as lexicographical_compare) : " << endl;
	for(i = 0 ; i < 3 ;i ++)
	{
		copy(v[i].begin(),v[i].end(),ostream_iterator<int>(cout,"\t"));
		cout << endl;
	}

	return 0;
}


 

9,排列生成器：

 

next_permutation()  , prev_permutation()

template<class BidIt>
bool next_permutation(BidIt first,BidIt last);
template<class BidIt,class Pred>
bool next_permutation(BidIt first,BidIt last,Pred pr);

template<class BidIt>
bool prev_permutation(BidIt first,BidIt last);
tempalte<class BidIt,class Pred>
bool prev_permutation(BidIt first,BidIt last,Pred pr);


 示例：

1,>

 

#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
	int A[] = {2,3,4,5,6,1};
	const int N = sizeof(A) / sizeof(int);

	cout << "Initialize: " ;
	copy(A,A+N,ostream_iterator<int>(cout," "));
	cout << endl;
	
	prev_permutation(A,A+N);
	cout << "After prev_permutation : ";
	copy(A,A+N,ostream_iterator<int>(cout," "));
	cout << endl;

	next_permutation(A,A+N);
	cout << "After next_permutation : ";
	copy(A,A+N,ostream_iterator<int>(cout," "));
	cout << endl;

	return 0;
}

 

2,>  全排列：

 

#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
	int a[]={0,0,1,1,3,2};
	sort(a,a+6);

	if(a[0] == 0)
	{
		int *it = upper_bound(a,a+6,0);
		swap(a[0],*it);
	}

	do
	{
		copy(a,a+6,ostream_iterator<int>(cout,"\t"));
		cout << endl;
	}while(next_permutation(a,a+6));

	return 0;
}

 

 

2,>

 

#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
	int a[]={0,0,1,1,3,2};
	sort(a,a+6);

	if(a[0] == 0)
	{
		int *it = upper_bound(a,a+6,0);
		swap(a[0],*it);
	}

	do
	{
		copy(a,a+6,ostream_iterator<int>(cout,"\t"));
		cout << endl;
	}while(next_permutation(a,a+6));

	return 0;
}

 

 

10,数值算法

 

accumulate() ,  inner_product()  partial_sum() , adjacent_difference()

template<class Init,class T>
T accumulate(Init first,Init last,T init);
template<class Init,class T,class Pred>
T accumulate(Init first,Init last,T init,Pred pr);

template<class Init1,class Init2,class T>
T inner_product(Init1 first1,Init1 last1,Init2 first2,T val);
template<class Init1,class Init2,class T,class Pred1,class Pred2>
T inner_product(Init1 first1,Init1 last1,Init2 first2 ,T val,Pred1 pr1,Pred2 pr2);

template<class Init,class OutIt>
OutIt partial_sum(Init first,Init last,OutIt result);
template<class Init,class OutIt,class Pred>
OutIt partial_sum(Init first,Init last,OutIt result,Pred pr);

template<class Init,class OutIt>
OutIt adjacent_difference(Init first,Init last,OutIt result);
template<class Init,class OutIt,class Pred>
OutIt adjacent_difference(Init first,Init last,OutIt result);

 

示例：

1,>

 

#include <iostream>
#include <numeric>
#include <functional>
#include <vector>
#include <iterator>

using namespace std;

int main()
{
	vector<int> v(10);
	for(int i = 0 ;i < 10 ; i ++)
	{
		v[i] = i +1 ;
	}

	vector<int> mid(10);
	partial_sum(v.begin(),v.end(),mid.begin(),multiplies<int>());
	int sum = accumulate(mid.begin(),mid.end(),0);

	cout << "1+(1 X 2) + (1 X 2 X 3) + ... the first ten sum: " << sum << endl;

	return 0;
}

 

 

2,>

 

#include <iostream>
#include <numeric>
#include <vector>

using namespace std;

int main()
{
	vector<float> v(10);

	for(int i = 1;i <= 10 ;i++)
	{
		v.push_back((float)i/(i+1));
		cout << (float)i/(i+1) << "\t";
	}

	float sum = inner_product(v.begin(),v.end(),v.begin(),0.0f);
	cout << endl << sum << endl;

	return 0;
}


 

11,自定义STL风格：

 

1>函数参数一般是迭代指针，不要以数组形式传递

2>要从迭代指针参数获得迭代指针类型，这一点很重要

 

示例：

如果自定义泛型算法中要使用临时变量，一定要使用_Val_type函数，一定要用转换函数

 

template<class Ty> inline
Ty * _Val_type(const _Ty *)

_Ty * 一般来说表示一个迭代器指针下面例子中 _Val_type(first)  就会得到 _Ty * 等于int *,则Ty等于int

 

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

using namespace std;

template<class Init1,class Init2>
void my_swap(Init1 first,Init1 last,Init2 first2)
{
	_my_swap(first,last,first2,_Val_type(first));
}

template<class init1,class init2,class T> inline
void _my_swap(init1 first,init1 last,init2 first2, T *)
{
	int n = 0 ;

	for(; first != last;first ++,first2 ++,n ++)
	{
	//	if(n % 2 == 0)
		{
			T tmp = *first;
			* first = * first2;
			*first2 = tmp;
		}
	}
}

int main()
{
	int a[] = {1,3,5,7,9};
	int b[] = {2,4,6,8,10};

	vector<int> v(a,a+5);
	list<int> l(b,b+5);

	cout << "org v = ";
	copy(v.begin(),v.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;
	cout << "org l = ";
	copy(l.begin(),l.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;

	my_swap(v.begin(),v.end(),l.begin());

	cout << "After swap v =";
	copy(v.begin(),v.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;
	cout << "After swap l =";
	copy(l.begin(),l.end(),ostream_iterator<int>(cout,"\t"));
	cout << endl;

	return 0;
}
数据结构之集合Set
HiterCoder
03-14 210
1、高层的数据结构，集合Set和映射Map，什么是高层的数据结构呢，比如说是栈和队列，这种数据结构更像是先定义好了使用接口，有了这些使用接口，包括数据结构本身所维持的一些性质，可以很方便的放入到一些应用中，但是底层实现可以多种多样的，比如栈和队列，底层实现既可以是动态数据，也可以是链表。 　　集合就是承载元素的容器，集合Set中有一个重要的特性，就是每个元素在集合中只能存在一次，可以快速...
个人学习LFS搭建总结
birth12的博客
05-11 1920
本人是个小菜鸟，初次通过学习搭建linux for search（LFS）进行Linux的学习，下面是我综合了不少网上资料之后进行的总结本人的搭建系统是centos7lfs的版本为7.7首先是官方手册的中文连接网页...
STL排序算法
羽的博客
12-29 1309
STL排序算法 STL简介 STL：标准模板库。 包含一些常用的算法如排序查找，还有常用的数据结构如可变长数组，链表，字典等。 使用方便，效率较高 要使用其中的算法，需要#include sort排序 用法一： 对基本数据类型的数组从小到大排序： sort（数组名+n1，数组名+n2）； ​ n1和n2都是int类型的表达式，可以包含变量。 ​ 如果n1=0,则+n1可以不写 将数组中下标范围为[n1,n2)的元素从小到大排序。下标为n2的元素不在排序区间内。 例如： int a[]={12,
C++ STL常用算法之常用排序算法
basketball616的博客
03-30 679
掌握常用的排序算法。sort//对容器内元素进行排序//洗牌，指定范围内的元素随机调整次序merge//容器元素合并，并存储到另一容器中reverse//反转指定范围的元素。
STL常用算法——排序算法
万里顾一程的博客
10-31 1504
合并排序，merge() 函数用于将 2 个有序序列合并为 1 个有序容器，前提是这 2 个有序容器的排序规则相同（要么都是升序，要么都是降序）。并且最终借助该函数获得的新有序容器，其排序规则也和这 2 个有序容器要相同。sort() 函数在对自定义的类对象实现排序时，需要在该类的内部提供移动构造函数和移动赋值运算符。sort()：对容器或普通数组中范围内的元素进行排序，默认进行升序排序，也可以自定义排序规则。reverse()函数：将容器指定范围内的元素进行反转。函数原型：该函数有以下两种格式。
STL之算法——排序算法
qq_38082979的博客
03-30 1984
一：介绍 常用的STL排序算法包括sort，reverse，merge，random_shuffle。 二：sort：对容器内元素进行排序 1.函数原型 sort(iterator begin, iterator end) 默认以升序方式对元素进行排序 sort(iterator begin, iterator end, _Pred) 自定义方式对元素排序 2.操作 #include <iostream> #include <algorithm> #include &
STL——排序算法
weixin_64238628的博客
12-30 935
random_shuffle洗牌算法使用时需要加随机数种子。merge合并两个容器必须是有序序列。容器元素合并，并存储到另一容器中。指定范围内的元素随机调整次序。两个容器必须是有序的。
C++STL--排序算法
学无止境
04-03 1067
sort算法
STL 中排序相关算法总结
编程猿来如此
06-30 645
STL 中排序相关算法总结
【算法】STL概述/STL排序算法_sort/STL二分查找
m0_65431212的博客
08-30 114
cg
使用Nginx实现负载均衡配置详解.doc
最新发布
08-12
使用Nginx实现负载均衡配置详解.doc
无线电能传输LCC-S拓扑的MATLAB Simulink仿真：滑模控制与PI控制效能对比 无线电能传输
08-12
基于LCC-S拓扑的无线电能传输系统的MATLAB Simulink仿真模型，重点比较了滑模控制和PI控制方法的效果。文中首先描述了系统的硬件构成，包括两电平H桥逆变器、LCC补偿网络以及不可控整流桥。接着，作者通过MATLAB RF Toolbox确定了LCC参数组合，确保系统能在85kHz附近形成低阻抗通路。对于滑模控制，作者展示了具体的S函数实现及其关键参数设定，如滞环宽度的选择。而对于PI控制，则使用了Simulink自带的PID模块并进行了参数优化。最终，通过对负载阶跃响应、开关噪声频谱等方面的对比，得出滑模控制在响应速度上有显著优势，但也存在高频毛刺的问题。此外，还讨论了H桥死区时间设置对系统性能的影响。 适合人群：从事电力电子、无线充电技术研发的工程师和技术研究人员。 使用场景及目标：适用于需要评估不同控制方法在无线电能传输系统中表现的研究项目，帮助选择最优控制策略以提高系统性能。 其他说明：附带的文章有助于深入理解仿真模型的设计思路和具体实现细节。
基于开源大模型的教学实训智能体软件，基于 Vue3+TypeScript 开发，帮助教师生成课前备课设计、课后检测问答，提升效率与效果，提供学生全时在线练习与指导，实现教学相长 .zip
08-12
基于开源大模型的教学实训智能体软件，帮助教师生成课前备课设计、课后检测问答，提升效率与效果，提供学生全时在线练习与指导，实现教学相长。 智能教学辅助系统 这是一个智能教学辅助系统的前端项目，基于 Vue3+TypeScript 开发，使用 Ant Design Vue 作为 UI 组件库。 功能模块 用户模块 登录/注册功能，支持学生和教师角色 毛玻璃效果的登录界面 教师模块 备课与设计：根据课程大纲自动设计教学内容 考核内容生成：自动生成多样化考核题目及参考答案 学情数据分析：自动化检测学生答案，提供数据分析 学生模块 在线学习助手：结合教学内容解答问题 实时练习评测助手：生成随练题目并纠错 管理模块 用户管理：管理员/教师/学生等用户基本管理 课件资源管理：按学科列表管理教师备课资源 大屏概览：使用统计、效率指数、学习效果等 技术栈 Vue3 TypeScript Pinia 状态管理 Ant Design Vue 组件库 Axios 请求库 ByteMD 编辑器 ECharts 图表库 Monaco 编辑器 双主题支持（专业科技风/暗黑风） 开发指南 # 安装依赖 npm install # 启动开发服务器 npm run dev # 构建生产版本 npm run build 简介 本项目旨在开发一个基于开源大模型的教学实训智能体软件，帮助教师生成课前备课设计、课后检测问答，提升效率与效果，提供学生全时在线练习与指导，实现教学相长。
医疗病历交互系统源码-基于Web的医疗病历交互系统设计与实现-医疗病历交互网站代码-医疗病历交互项目代码
08-12
医疗病历交互-医疗病历交互系统-医疗病历交互系统源码-医疗病历交互系统代码-springboot医疗病历交互系统源码-基于springboot的医疗病历交互系统设计与实现-医疗病历交互管理系统代码
基于主从博弈理论的共享储能与电热综合需求响应优化运行研究
08-12
内容概要：本文探讨了在共享储能背景下，微网运营商与用户聚合商之间的主从博弈模型，旨在优化电热综合需求响应和电网技术的应用。文中详细介绍了主从博弈理论的基本概念及其在共享储能中的具体应用，证明了Stackelberg均衡解的存在性和唯一性。此外，作者还在MATLAB平台上进行了仿真实验，采用Yalmip工具和CPLEX求解器结合启发式算法对模型进行了优化，验证了理论的有效性。 适合人群：从事电力系统、能源管理及相关领域的研究人员、工程师以及高校相关专业的师生。 使用场景及目标：适用于希望深入了解共享储能在微网环境中优化运行机制的研究者，帮助他们掌握主从博弈理论的实际应用方法，提升对复杂能源系统的理解和应对能力。 其他说明：本文不仅提供了理论支持，还展示了具体的实验步骤和结果，有助于推动该领域的进一步发展。
Docker镜像制作与容器管理全流程讲解.doc
08-12
Docker镜像制作与容器管理全流程讲解.doc
【最新版】 IEC TS 63528- 2025多媒体系统 - 触觉反馈 - 触觉刺激描述符.rar
08-12
【最新版】 IEC TS 63528- 2025多媒体系统 - 触觉反馈 - 触觉刺激描述符.rar
JAVA办公自动化系统(源代码+论文+外文翻译).7z
08-12
JAVA办公自动化系统(源代码+论文+外文翻译).7z
MATLAB程序设计：基于阶梯碳交易机制与电制氢的综合能源系统优化调度及Cplex+Yalmip求解 · 综合能源系统
08-12
内容概要：本文探讨了如何利用MATLAB程序设计，在考虑阶梯型碳交易机制的情况下对电制氢综合能源系统进行优化调度。文中详细介绍了阶梯碳交易机制的概念及其在MATLAB中的建模方法，解释了电制氢作为清洁能源在综合能源系统中的重要性，并展示了如何使用Cplex和Yalmip这两种优化求解工具来进行具体的计算。此外，还提供了完整的代码实例和运行结果的可视化图表，帮助读者更好地理解和应用所学知识。 适合人群：从事能源管理、环境保护及相关领域的研究人员和技术人员，尤其是那些希望通过编程手段提升工作效率的人群。 使用场景及目标：适用于需要对综合能源系统进行优化调度的研究项目或实际工程中。主要目标是通过合理的碳排放管理和高效的氢能生产，达到节能减排的目的，同时提高能源利用效率。 其他说明：文中提供的代码可以在MATLAB环境下直接运行，并配有详细的注释，便于初学者上手。参考文献部分列出了多篇高质量的相关论文，供有兴趣深入探究的读者查阅。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值