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      感謝分享