C++中sort()函数的用法以及如何对类按某一成员参数排序

.前言
在编码时，对元素的排序是一个基础且重要的内容，我们已经学到了众多排序的算法，但那是否在每次使用的时候都要再编码一次？

事实上，C++早已经给我们封装了一个极为便利的算法sort()，我们仅需要引入头文件< algorithm>即可使用。

.语法描述
sort()函数中需要三个参数：sort(begin,end,cmp)，其中：
begin为指向待排序的数组的第一个元素的指针
end为指向待排序的数组的最后一个元素的下一位置的指针
cmp为可选参数，作为我们排序的准则。在无第三参数的情况下默认升序，但可以通过定义cmp改变排序方式。

.无第三参数例子

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

int main()
{
	int a[6] = { 5,2,6,1,8,2 };
	vector<int> v(a,a+6);
	sort(a, a + 6);//或sort(std::begin(a), std::end(a));
	for(int i=0;i<6;i++)
	{
		cout << a[i] << endl; //输出1 2 2 5 6 8
	}
	sort(v.begin(), v.end());
	for(int i=0;i<6;i++)
	{
		cout << v[i] << endl; //输出1 2 2 5 6 8  
	}
	return 0;
}

.定义第三参数

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

bool cmp(int x,int y)
{
	return x > y;//第一参数大于第二参数表示降序
}
int main()
{
	int a[] = { 8,2,6,5,1,2 };
	sort(std::begin(a), std::end(a), cmp);
	for(int i=0;i<6;i++)
	{
		cout << a[i] << endl;//结果为8 6 5 2 2 1
	}
	return 0;
}

.为什么建议使用sort()?
sort函数在大多数情况下效率都会比较高。
以下摘抄：https://blog.csdn.net/qq_36378681/article/details/102816726（很不错的文章）

sort函数是用什么排序实现的？
实际上，STL中的sort是一种混合排序，它应用了快速排序、堆排序和插入排序，以下是各个排序应用时的情况：

开始时使用的是快速排序
当递归深度超过logn时，为了防止快速排序退化，sort会改用为堆排序
当递归深度小于logn时，但是区间长度小于等于16时，改用插入排序。

为什么一开始不用堆排序？
为什么面试官会这么问呢？因为他已经问了你堆排序和快速排序的实现，这个时候你对他们的时空复杂度已经很清楚了，这时候你意识到其实堆排序的空间复杂度比快速排序还要低（堆排序o(1)，快速排序o(logn) ），而且堆排序还不会退化。

所以面试官想知道为什么快速排序效率要比堆排序高？

这个问题如果没去了解过，真的很难回答

实际上我们学习算法，研究的都是理论复杂度，而实际工程应用时，还会考虑算法实际的效率，这不仅涉及到算法的理论复杂度，还涉及到硬件、操作系统等问题

而快速排序就是一个典型的例子

同样是nlogn的时间复杂度，为什么堆排序和归并排序整体效率不如快速排序呢？这是因为计算机硬件中有一个高速缓存区（cache），它的访问读取速度非常快（比内存还要快很多），它通常集成在CPU上，所以其容量十分有限，通常CPU会把经常访问到的数暂存到缓存里，CPU找数据也会先从缓存里找。

快速排序因为其用到了一个枢纽，这个枢纽的访问次数非常之多，那么其就会被放入缓存中，那么访问枢纽的效率就会非常高，所以快速排序整体效率会比其他几个排序要高。

.如何用sort()函数实现对类依靠某一成员参数排序
前面说过，sort函数的排序方式是靠第三参数，函数对象实现的，具体操作如下所示。

示例：

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

//定义有复数参数的类
class item
{
public:
	int type_A;//类成员参数A
	int type_B;//类成员参数B

	item(int a, int b) :type_A(a), type_B(b) {}
};

//以下排序默认降序
//按照参数A排序
bool cmpA(const item& x,const item& y)
{
	return x.type_A < y.type_A;
}
//按照参数B排序
bool cmpB(const item& x, const item& y)
{
	return x.type_B < y.type_B;
}
int main()
{
	vector<item> arr;
	item t1(1, 3), t2(5, 2), t3(3, 1);
	arr.push_back(t1);
	arr.push_back(t2);
	arr.push_back(t3);
	cout << "未排序前：" << endl;
	for (int i = 0;i < 3;i++)
	{
		cout << "<x,y>= " << arr[i].type_A << " " << arr[i].type_B << endl;
	}
	//按照参数A排序
	sort(arr.begin(), arr.end(), cmpA);
	cout << "按照参数A排序：" << endl;
	for(int i=0;i<3;i++)
	{
		cout << "<x,y>= " << arr[i].type_A << " " << arr[i].type_B<<endl;
	}
	//按照参数B排序
	sort(arr.begin(), arr.end(), cmpB);
	cout << "按照参数B排序：" << endl;
	for (int i = 0;i < 3;i++)
	{
		cout << "<x,y>= " << arr[i].type_A << " " << arr[i].type_B<<endl;
	}
	return 0;
}

结果：

未排序前：
<x,y>= 1 3
<x,y>= 5 2
<x,y>= 3 1
按照参数A排序：
<x,y>= 1 3
<x,y>= 3 1
<x,y>= 5 2
按照参数B排序：
<x,y>= 3 1
<x,y>= 5 2
<x,y>= 1 3