C++ STL sort 函数的用法（自定义排序函数）

sort基本简介

sort 在 STL 库中是排序函数，有时冒泡、选择等 O(n2)O(n2) 算法会超时时，我们可以使用 STL 中的快速排序函数 O(n log n)O(n log n) 完成排序

sort 在 algorithm 库里面，原型如下：

template <class RandomAccessIterator>
 void sort ( RandomAccessIterator first, RandomAccessIterator last );
template <class RandomAccessIterator, class Compare>
 void sort ( RandomAccessIterator first, RandomAccessIterator last, Compare comp );

其中 sort 有两种形式一个有三个参数，一个有两个参数

sort 的前两个参数是起始地址和终止地址

sort对基本类型集合（数组，vector等已支持<运算符的类型）排序

主要有以下几种情况：

  1.默认排序函数

  2.greater（升序）与less（降序）

  3.自定义比较函数（注意格式）

  4.lambda表达式

如：sort(a,a+n) 表示对 a[0] ... a[n-1] 排序

代码如下：

#include <algorithm>
#include <cstdio>
using namespace std;
int main() {
    int n,a[1001];
    scanf("%d",&n);
    for (int i = 1;i <= n;i++) scanf("%d",&a[i]);
    sort(a+1,a+n+1);  //对a[1] ... a[n] 排序
    for (int i = 1;i <= n;i++) printf("%d",a[i]);
    return 0'
}

这样是默认升序的，那如果是降序呢？

这样，我们就要用到第三个参数，第三个参数是一个比较函数

bool cmp(int a,int b) { return a > b; }

这个就是降序排序的比较函数，意思是:

是 a > b 时为true，就不交换，a < b 时为 false，交换

然后我们调用 sort(a+1,a+n+1,cmp) 就可以对 a 数组进行排序了

还可以调用 greater 和 less 进行升/降序排序，其实就是一个帮你写好的函数

int a[11],n;
scanf("%d",&n);
for (int i = 1;i <= n;i++) scanf("%d",&a[i]);
sort(a+1,a+n+1,greater<int>()); //升序
sort(a+1,a+n+1,less<int>()); //降序，注意尖括号内写的是排序的数组类型

sort 对结构体排序

主要有以下几种方式：

1.自定义比较函数（作为sort第三个参数）

2.在结构体中重载<运算符（sort只需前两个参数）

3.lambda表达式

#include <algorithm>
#include <cstdio>
using namespace std;
struct Node {
    int x,y;
} p[1001];
int n;
bool cmp(Node a,Node b) {
    if (a.x != b.x) return a.x < b.x;
    return a.y < b.y;
}
int main() {
    scanf("%d",&n);
    for (int i = 1;i <= n;i++) scanf("%d%d",&p[i].x,&p[i].y);
    sort(p+1,p+n+1,cmp);
    for (int i = 1;i <= n;i++) printf("%d %d\n",p[i].x,p[i].y);
    return 0;
}

以上代码的意思是，对 p 数组按 x 升序排序，若两个数的 x 相等则按 y 升序排序

结构体还可以重载运算符（greater 和 less 都是重载运算符的），使 sort 只用两个参数就可以按自己的规则排序，如：

#include <algorithm>
#include <cstdio>
using namespace std;
struct Node {
    int x,y;
    bool operator < (Node cmp) const {
        if (x != cmp.x) return x < cmp.x;
        return y < cmp.y;
    }
}p[1001];
int n;
/*bool cmp(Node a,Node b) {
 *    if (a.x != b.x) return a.x < b.x;
 *    return a.y < b.y;
 *}
 */
int main() {
    scanf("%d",&n);
    for (int i = 1;i <= n;i++) scanf("%d%d",&p[i].x,&p[i].y);
    sort(p+1,p+n+1);
    for (int i = 1;i <= n;i++) printf("%d %d\n",p[i].x,p[i].y);
    return 0;
}

综合示例：

//以下例子测试了在使用stl的sort排序时，对于比较函数的自定义与默认测试。


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

//一般结构体
struct Mystruct
{
	int m_one;
	int m_two;

}Myst;

//重载<运算符的结构体
struct Mystruct_load
{
	int m_one;
	int m_two;

	bool operator<(Mystruct_load one)
	{
		if (m_one!=one.m_one)
		{
			return m_one < one.m_one;
		}
		else
		{
			return m_two < one.m_two;
		}
	}

}Myst_load;


//整型vector自定义排序函数
bool cmp(int a, int b)
{
	return a>b;
}

//结构体类型vector自定义排序函数
bool cmpstruct(Mystruct one, Mystruct two)
{
	if (one.m_one!=two.m_one)
	{
		return one.m_one < two.m_one;
	}
	else
	{
		return one.m_two < two.m_two;
	}
}

int main()
{
	vector<int>vector_int;
	vector<int>::iterator iter_int;

	vector<Mystruct>vector_Myst;
	vector<Mystruct>::iterator iter_Myst;

	vector<Mystruct_load>vector_Mload;
	vector<Mystruct_load>::iterator iter_Mload;

	//int vector初始化
	vector_int.push_back(4);
	vector_int.push_back(1);
	vector_int.push_back(6);
	vector_int.push_back(3);

	//结构体vector初始化
	Myst.m_one = 1;
	Myst.m_two = 1;
	vector_Myst.push_back(Myst);

	Myst.m_one = 7;
	Myst.m_two = 3;
	vector_Myst.push_back(Myst);

	Myst.m_one = 3;
	Myst.m_two = 2;
	vector_Myst.push_back(Myst);

	//重载<运算符结构体初始化
	Myst_load.m_one = 1;
	Myst_load.m_two = 1;
	vector_Mload.push_back(Myst_load);

	Myst_load.m_one = 7;
	Myst_load.m_two = 3;
	vector_Mload.push_back(Myst_load);

	Myst_load.m_one = 3;
	Myst_load.m_two = 2;
	vector_Mload.push_back(Myst_load);

	//======================vector_int整型元素vector==========================================================
	//sort(begin(vector_int),end(vector_int));  //默认排序（升序）

	//sort(begin(vector_int), end(vector_int), greater<>());  //使用greater调整次序（降序）

	//sort(begin(vector_int), end(vector_int), cmp);  //自定义比较函数

	sort(begin(vector_int), end(vector_int), [](int &a, int &b) {return a < b; });  //自定义比较函数(lambda表达式)
	//======================vector_int整型元素vector==========================================================
	

	//vector_Myst结构体类型元素vector
	sort(begin(vector_Myst), end(vector_Myst), cmpstruct);


	//vector_Mload结构体类型元素vector（重载<操作符）
	sort(begin(vector_Mload), end(vector_Mload));
	



	//整型数组显示
	for (iter_int = vector_int.begin(); iter_int < vector_int.end(); iter_int++)
	{
		cout << *iter_int << endl;
	}

	cout << "============================="<<endl;

	//结构体排序显示
	for (iter_Myst=vector_Myst.begin();iter_Myst<vector_Myst.end();iter_Myst++)
	{
		cout << (*iter_Myst).m_two << endl;
	}

	cout << "=============================" << endl;

	//结构体排序显示（重载<运算符）
	for (iter_Mload = vector_Mload.begin(); iter_Mload < vector_Mload.end(); iter_Mload++)
	{
		cout << (*iter_Mload).m_two << endl;
	}

	system("pause");
	return 0;
}

本文前面部分内容摘自：https://www.cnblogs.com/lrj124/p/7254043.html      感谢分享