排序

//1.直接插入排序，稳定
//很久以前就学过直接插入了，但是写起来还是出了挺多问题的
void inssort(int *d, int s, int e){
	for(int i = s+1; i <= e; ++i){
		int x = d[i];
		int j = i-1;
		while(j >= s && d[j] > x){
			d[j+1] = d[j];
			--j;
		}
		d[j+1] = x;
	}
}
//2.希尔排序，不稳定
//缩小增量法，增量选择，直至增量为1
//组内直接插入排序，不喜欢插入，不过还是写一下看看
void shesort(int *d, int s, int e){
	for(int dt = (e-s)>>1; dt; dt >>= 1){
		for(int i = s+dt; i <= e; ++i){
			int x = d[i];
			int j = i - dt;
			while(j >= s && d[j] > x){
				d[j+dt] = d[j];
				j -= dt;
			}
			d[j+dt] = x;
		}
	}
}
//3.冒泡排序,稳定
void bubsort(int *d, int s, int e){
	for(int i = s; i < e; ++i){
		for(int j = e; j > i; --j){
			//此处可优化，如果扫描一遍没有发生交换，表明剩余部分也已经有序，结束排序
			if(d[j-1] > d[j]){
				int t = d[j]; d[j] = d[j-1]; d[j-1] = t;
			}
		}
	}
}
//4.快速排序，不稳定
void qsort(int *d, int s, int e){
	if(s >= e)return;
	int l = s, r = e;
	int x = d[l];
	while(l < r){
		while(l < r && x < d[r])--r;
		if(l < r)d[l++] = d[r];
		while(l < r && x > d[l])++l;
		if(l < r)d[r--] = d[l];
	}
	d[l] = x;
	qsort(d, s, l-1);
	qsort(d, l+1, e);
}
//5.简单选择排序，不稳定
void selsort(int *d, int s, int e){
	for(int i = s; i < e; ++i){
		//也可以每次都和d[i]比较，更小则交换，但是交换次数会多一些
		int id = i;
		for(int j = i+1; j <= e; ++j){
			if(d[j] < d[id])id = j;
		}
		if(id != i){
			int t = d[id]; d[id] = d[i]; d[i] = t;
		}
	}
}
//6.堆排序，不稳定
//算法是理解的，但是从来没写过，写来试试
//下标从1开始的话比较简单,2k,2k+1，从0开始也是可以的，为了一致性，此处依然从0开始,2k+1,2k+2
//大顶堆，小顶堆，此处大顶堆，输入顺序是降序，数组变为升序
//堆调整
void heapadjust(int *d, int e, int x){
	int t = d[x];
	int child;
	while((child = 2 * x + 1) <= e){
		if(child+1 <= e && d[child+1] > d[child]){
			++child;
		}
		if(t < d[child]){
			d[x] = d[child];
			x = child;
		}else{
			break;
		}
	}
	d[x] = t;
}
//首先是非叶子的调整，然后依次替换、调整，此处默认s=0，从0开始
void heasort(int *d, int s, int e){
	for(int i = (e-1)>>1; i >= 0; --i){
		heapadjust(d, e, i);
	}
	for(int i = e; i > 0; --i){
		int t = d[i]; d[i] = d[0]; d[0] = t;
		heapadjust(d, i-1, 0);
	}
}
//7.归并排序，稳定
//典型的分治，分而治之，划分→合并
void megsort(int *d, int s, int e){
	if(s >= e)return;
	int m = (s + e)>>1;
	megsort(d, s, m);
	megsort(d, m+1, e);
	int i = s, j = m +1, p = s;
	int t[len];
	while(i <= m && j <= e){
		if(d[i] <= d[j]){
			t[p++] = d[i++];
		}else{
			t[p++] = d[j++];
		}
	}
	while(i <= m){
		t[p++] = d[i++];
	}
	while(j <= e){
		t[p++] = d[j++];
	}
	for(int i = s; i <= e; ++i){
		d[i] = t[i];
	}
}
//8.基数排序（桶，分配）
//特殊情况，不予讨论
//每一位进行
//9.计数排序
//特殊情况，不予讨论
//范围小，频度高，可列

qsort和sort，比较喜欢sort，简单一些

均可自己实现cmp，实现自定义比较，比如多重排序

qsort，c语言库函数

#include <stdlib.h>
void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));
int cmp(const void *a, const void *b );

a-b升序，反之降序
sort,c++ stl

#include <algorithm>
using std::sort;
void sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
bool cmp(const Type1 &a, const Type2 &b)

a<b升序，反正降序