把排序大全移植到这里吧（

主要是看这里输出只有一个数（
首先出厂的是我们的冒泡排序
冒泡排序 综合:B 时间复杂度:O(n^2) (n~n^2) 稳定:√ 难度:☆ 新手必备！

void bubblesort(int *a, int len){
	for(int i = 1; i <= len; i++){
		for(int j = 1; j <= len - i; j++){
			if(cmp(a[j + 1], a[j])) swap(a[j], a[j + 1]);//遇到右边比左边大（小）就交换 
		}
	}
}

结果：$\text{7AC,3TLE}$
然后是我们的顶级辅助插排
插入排序 综合:B 时间复杂度:O(n^2) (n~n^2) 稳定:√ 难度:☆☆

void insertsort(int *a, int left, int right){
	for(int i = left + 1; i <= right; i++){//把前面的当成有序数组
		int tmp = i - 1, cur = a[i];
		while(tmp >= left){
			if(cmp(cur, a[tmp])){
				a[tmp + 1] = a[tmp];//逐一比较，继续向前 
				tmp--;
			}
			else break;
		}a[tmp + 1] = cur;
	}
}

结果：$\text{9AC,1TLE}$
接着出场的是选择排序
选择排序 综合:B 时间复杂度:O(n^2) 稳定:× 难度:☆ 新手必备!

void selectionsort(int *a, int len){
	for(int i = 1; i <= len; i++){
		int mi = a[i], idx = i;
		for(int j = i + 1; j <= len; j++){
			if(cmp(a[j], mi)) mi = a[j], idx = j;//寻找最小值 
		}swap(a[i], a[idx]);//交换 
	}
}

结果：……什么？？？这么稳定的（指时间复杂度）排序竟然还能$\text{9AC}$！！！
不管了不管了（
我不对计数排序抱希望了，1e9的数据肯定会爆缸
看看能AC几个吧
计数排序 综合:B+ 时间复杂度:O(n) (实际你自己定，我这是n) 空间复杂度:O(a(max) - a(min)) 稳定:√ 难度:☆

void bucketsort(int *a, int len){//不想搜了就当是桶排序吧（
	int mn = 0x7fffffff, mx = -1e9;
	for(int i = 1; i <= len; i++){
		mn = min(mn, a[i]), mx = max(mx, a[i]);
	}for(int i = 1; i <= len; i++){
		arr[a[i] - mn]++;//放入桶 
	}
	mx -= mn;
	int ct = 1;
	for(int i = 0; i <= mx; i++){
		while(arr[i]--){
			a[ct++] = i + mn;//复制数组
		}
	}
}

结果：$………………$官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据官方赶紧给我改数据
咳咳，然后是本场mvp基数排序
基数排序 综合:S+ 时间复杂度:O(d(n + r)) (其中d为最大数的位数(即log(a(max))，底数为r)，这里为了公平设置成了r=10)

//基数排序
void radixsort(int, int, int);
int getweishu(int x, int r){//求位数
	int ct = 0;
	while(x){
		ct++;
		x /= r;
	}return ct;
}int pow(int r, int i){//
	int ct = 1;
	while(i--){
		ct *= r;
	}return ct;
}
void radixsort(int *a, int len, int r){
	int weishu = 0;
	for(int i = 1; i <= len; i++){
		weishu = max(weishu, getweishu(a[i], r));//确定最大数的位数 
	}
	int dgt, x;
	for(int i = 1; i <= weishu; i++){//重复位数次排序
		dgt = pow(r, i - 1);
		for(int j = 1; j <= len; j++){
			x = a[j] / dgt % r;//求这个数的第x位 
			jishu[x].push_back(a[j]);//录入数
		}
		int ct = 1;
		for(int i = 0; i < r; i++){
			for(int j = 0; j < jishu[i].size(); j++){
				a[ct++] = jishu[i][j];//复制回数组 
			}jishu[i].clear();//清空vector 
		}
	}
	
}

结果：$10\text{AC}，耗时最长：555\text{ms}$
我心目中的神，归并！
归并排序 综合:S+ 时间复杂度:O(nlogn) 稳定:√ 难度:☆☆☆ 神！！！

//归并排序 
void mergesort(int, int, int);
void merge(int *a, int left, int right){
	int mid = (left + right) / 2;
	int i = left, j = mid + 1, st = left;
	//left和right中间因为被mid分割，可看做两个有序数组
	while(i <= mid && j <= right){
		if(cmp(a[i], a[j])) arr[st++] = a[i++];//把两个有序的数组里的元素一个一个进行比较，小的放进备用数组
		else arr[st++] = a[j++];
	}
	while(i <= mid) arr[st++] = a[i++];//没被遍历完 
	while(j <= right) arr[st++] = a[j++];
	for(int i = left; i <= right; i++){
		a[i] = arr[i];
	}
}
void mergesort(int *a, int left, int right){
	if(left >= right) return;
	int mid = (left + right) / 2;
	mergesort(a, left, mid);
	mergesort(a, mid + 1, right);//分割成一个个的小数组再去合并 
	merge(a, left, right);
}

结果：$\text{10AC}, 耗时最长：621\text{ms}$
最后是快排（这里讲清楚，sort不是快排，为了保持速度快，还涉及到了多种排序）
快速排序 综合:S+ 时间复杂度:O(nlogn) 稳定:× 难度:☆☆☆☆ 神！！！

int partition(int left, int right){
	while(left < right){
		while(left < right && a[left] <= a[right]) left++;
		swap(a[left], a[right]);
		while(left < right && a[left] <= a[right]) right--;
		swap(a[left], a[right]);
	}return left;
}
void _sort(int left, int right){
    if(left >= right) return;
	int i = partition(left, right);
    _sort(left, i - 1);
    _sort(i + 1, right);
}

结果：$\text{10AC}, 耗时最长：563\text{ms}$