以快排方式重写sort库函数(未含迭代器版本)

函数范式：

template<class T>
void sort(T *start, T *end, 比较器);

第一个参数，数组的首地址或者是排序的起始指针位置

第二个参数，数组的排序末尾位置，参见algorithm中使用时常用 sort(arr, arr + n);的方式，所以这个末尾位置不参与排序，排序位置为 【start， end - 1】

第三个参数是一个比较器，用于用户传递lambda表达式，应该赋予默认值。默认是一个函数，因此可以使用指针函数的方式用于实现，但是使用了指针函数的方式，那么传递lambda表达式将无法找到对应的函数进行调用。

函数指针示例：

template<class T> bool defaultCmp(T _1, T _2) {
    return _1 < _2;
}

template<class T>
void sort(T *start, T *end, bool (*cmp)(T, T) = defaultCmp) {

}

这里的指针函数赋予了一个初始值，但是无法传递lambda表达式，只能传递一个函数式指针。

采用struct重载括号运算符，不一定是struct，class也可以

template<class T> struct sortCmp {
	bool operator() (T _1, T _2) const {
		return _1 < _2;
	}
};

template<class T, class lambda = userSortDetail::sortCmp<T>>
void sort(T *start, T *end, lambda cmp = userSortDetail::sortCmp<T>{}) {


}

注释版本：

#include <iostream>
using namespace std;

// 采用命名空间，防止在写sort的默认函数时会污染全局变量
namespace userSortDetail {
// 使用模板定义这个结构体，并重载括号运算符，创造比较器
// 如果用户重载了排序的时候的规则，那么就可以像sort一样
	template<class T> struct sortCmp {
		bool operator() (T _1, T _2) const {
			return _1 < _2;
		}
	};
}

// class T 约束传递数组的类型
// class lambda 定义传入的 lambda 表达式，并且要基于默认的类型，因为在函数中要使用默认值并创造这个比较器对象
template<class T, class lambda = userSortDetail::sortCmp<T>>
void sort(T *start, T *end, lambda cmp = userSortDetail::sortCmp<T>{}) {
// 接下来时快速排序，当然可以判断排序的规模，然后使用不同的排序方法，比如归并、树状排序等
	if (start >= end - 1) return;
	int i = -1, j = end - start;
	T x = start[i + j >> 1];
	while (i < j) {
		do i ++; while (cmp(start[i], x));
		do j --; while (cmp(x, start[j]));
		if (i < j) swap(start[i], start[j]);
	}
	sort(start, start + j + 1, cmp), sort(start + j + 1, end, cmp);
}

int main() {
	const int N = 100;
	int arr[100];
	for (int i = 100;i > 0;i --) arr[i - 1] = i;
// 然后再使用的时候就可以像sort库函数一样调用
	sort(arr, arr + N, [](int _1, int _2) {
		return _1 > _2;
	});
	for (int i = 0;i < 100;i ++) cout << arr[i] << ' ';
	return 0;
}

无注释版本：

#include <iostream>
using namespace std;

namespace userSortDetail {
	template<class T> struct sortCmp {
		bool operator() (T _1, T _2) const {
			return _1 < _2;
		}
	};
}

template<class T, class lambda = userSortDetail::sortCmp<T>>
void sort(T *start, T *end, lambda cmp = userSortDetail::sortCmp<T>{}) {
	if (start >= end - 1) return;
	int i = -1, j = end - start;
	T x = start[i + j >> 1];
	while (i < j) {
		do i ++; while (cmp(start[i], x));
		do j --; while (cmp(x, start[j]));
		if (i < j) swap(start[i], start[j]);
	}
	sort(start, start + j + 1, cmp), sort(start + j + 1, end, cmp);
}

int main() {
	const int N = 100;
	int arr[100];
	for (int i = 100;i > 0;i --) arr[i - 1] = i;
	sort(arr, arr + N, [](int _1, int _2) {
		return _1 > _2;
	});
	for (int i = 0;i < 100;i ++) cout << arr[i] << ' ';
	return 0;
}