排序入门

排序：外部排序，内部排序

以下内容 无须铭记
内部排序是在内存中进行排序
外部排序 当文件较大，内存无法全部储存，将文件存放在外面，使用......方法让文件依次进入内存排序
我们接触到的排序都是内部排序

bogo排序：随机打乱，检查是否有序。

srand(time(NULL))

for(;;){  //while(1)
	bool pd=1;
	for(i:1->n-1) if(a[i]>a[i+1]){
		pd=0;
		break;
	}
	if(pd) break;
	for(i:1->n) {  
		int j=rand()%n+1;
		swap(a[i],a[j]);
	}
	// random_shuffle(a+1,a+n+1);
}

------------------------------------华------丽------的------分------割------线-------------------------------------

八大排序：

插入排序： 直接插入排序，希尔排序
选择排序：简单选择排序，堆排序

交换排序：冒泡排序，快速排序

归并排序

基数排序

——————————————————————————————————————————————————————————
简单介绍以下各种排序：
直接插入排序：从未排序的数中依次枚举，插入到已排序的序列中

for(int i=2;i<=n;++i){
	int j=i-1;
	int tmp=a[i];
	while(j&&a[j]>tmp) a[j+1]=a[j],j--;
	if(j!=i-1) a[j+1]=tmp;
}
//时间复杂度：O(n^2)
//空间复杂度：O(n)
//稳定排序

希尔排序：插入排序改进版，选择一个增量d，将d的倍数放在一组，进行插入排序

for(int d=n/2;d;d>>=1) {
	for(i=d;i<=n;++i) {
		int j=i-d;
		int tmp=a[i];
		while(j>0&&a[j]>tmp) a[j+d]=a[j],j-=d;
		if(j+d!=i) a[j+d]=tmp;
	}
}
//时间复杂度：O(玄学)（最优O(n^1.3)）
//空间复杂度：O(n)
//不稳定排序

简单选择排序：在未排序数列中，找出最小的数与第一个交换，再在未排序数列中，找出最小的数与第二个交换

简单选择排序：

for(int i=1;i<=n;++i){
	int k=i;
	for(j=i+1;j<=n;++j) if(a[j]<a[k]) k=j;
	swap(a[k],a[i]);
}
//时间复杂度：O(n^2)
//空间复杂度：O(n)
//不稳定排序

冒泡排序：不断交换相邻两个值

for(int i=1;i<n;++i){
	bool change=0;
	for(j=1;j<n-i;++j) if(a[j]>a[j+1]) swap(a[j],a[j+1]);
	if(!change) break;
}
//时间复杂度：O(n^2)
//空间复杂度：O(n)
//稳定排序

附：
鸡尾酒排序：双向冒泡排序排序

int l=1,r=n;
while(l<r){
	for(i=l;i<r;++i) if(a[i]>a[i+1]) swap(a[i],a[i+1]);
	r--;
	for(i=r;i>l;--i) if(a[i-1]>a[i]) swap(a[i-1],a[i]);
	l++;
}
//时间复杂度：O(n^2)
//空间复杂度：O(n)
//稳定排序

桶排：不常用但很好用，将所有的数放入到桶中，依次取出

int Max=0,Min=oo;
for(int i=1;i<=n;++i) t[a[i]]++,Max=max(Max,a[i]),Min=min(Min,a[i]);
for(int i=Min;i<=Max;++i) while(t[i]) a[++cnt]=i,t[i]--;
//时间复杂度：O(max_num)
//空间复杂度：O(n+max_num)
//不稳定排序

——————————————————————————————————————————————————————————
当然，除了堆排序、快速排序、归并排序、基数排序，其余的基本不用

堆排序 维护堆，将 数据放入一个堆中 依次取出
实现 : 大根堆 priority_queue<数据类型>
如 ： priority_queue\(<int>\)
小根堆 priority_queue<数据类型,容器,比较函数>
如 ： priority_queue<int,vector \(<int>\) ,greater \(<int>\) >
（注：greater<> 是c++标准模板库(STL) 自带比较函数）

priority_queue<int> q;//priority_queue<int,vector<int>,greater<> > q;
for(int i=1;i<=n;++i) q.push(a[i]);
while(!q.empty()) a[++cnt]=q.top(),q.pop();
//时间复杂度：O(nlogn)
//空间复杂度：O(n)
//不稳定排序

———————————————————————————————————————————————————————————

归并排序 不断递归二分，使子区间有序，在合并成一个大区间

void Merge_sort(int l,int r){
	if(l==r) return ;
	int mid=l+r>>1;
	Merge_sort(l,mid);
	Merge_sort(mid+1,r);
	int i=l,j=mid+1,cnt=0;
	while(i<=mid&&j<=r)
		if(a[i]<=a[j])  b[++cnt]=a[i++];
		else b[++cnt]=a[j++];
	while(i<=mid) b[++cnt]=a[i++];
	while(j<=r) b[++cnt]=a[j++];
	for(i=1;i<=cnt;++i) a[l+i-1]=b[i];
}
//时间复杂度：O(nlogn)
//空间复杂度：O(2n)
//稳定排序

———————————————————————————————————————————————————————————

快速排序 以 小-->大 排序 二分，选择一个基准，在基准左边选一个小于基准的元素
在右边选一个大于基准的元素
交换
再递归，分别对左右区间操作，将大于基准的放在基准右边
小于基准的放在基准左边

实现 : 小-->大 sort(a+1,a+n+1); （区间是 左闭右开）
大-->小 sort(a+1,a+n+1,greater\(<int>\)())
防止相同元素改变顺序:stable_sort();

void Quick_sort(int l,int r){
	int mid=a[l+r>>1];
	int i=l,j=r;
	while(i<=j) {
		while(a[i]<mid) i++;
		while(a[j]>mid) j--;
		if(i<=j) swap(a[i],a[j]),i++,j--;
	}
	if(i<r) Quick_sort(i,r);
	if(j>l) Quick_sort(l,j);
}
//时间复杂度：O(nlogn)
//空间复杂度：O(n)
//不稳定排序

————————————————————————————————————————————————————————————

基数排序 按位 （从低位到高位） 排序，
以 小-->大 排序 从低位--高位 按每一位 由小到大进行排序，具体实现可用通排

void BCN_sort(int n,int Max_len){
	int t[10][Max]={0};
	int k=1,m=1,cnt=1;
	while(k<Max_len){
		for(i=1;i<=len;++i){
			if(a[i]<m) t[0][cnt]=a[i];
			else {
				int pos=a[i]/m%10;
				t[pos][cnt]=a[i];
			}
			cnt++;
		}
		Collect(a,t);
		cnt=0;
		m*=10;
		k++;
	}
}
//时间复杂度：O(Max_len*n)
//空间复杂度：O(10*n)
//稳定排序

————————————————————————————————————————————————————————————

用堆来排序并不多见，因为堆是可以支持O(1)查询 O(log n)插入、删除
所以 在一些取最值的题目中，才能体现他的优势

快排是OI中用的最多的排序，标准模板库中的 sort 与自己写的快速排序要快得多，尽管它是STL
况且，你可你自己写比较函数来改变 sort 的比较键值(Key)
虽然它不稳定，但应该不会有人要出数据去卡快速排序
至于快排的另一用法 查询某一元素在序列中是第几大，也可以用 nth_element() 来实现

基数排序，也不常用，讲它的是因为 后缀数组(SA) 中会用到它

归并排序 本来不想讲，它虽然稳定，真不常用，但他的思想非常重要，在CDQ分治中它起着很大作用

————————————————————————————————————————————————————————————

排序应用：去重、离散化

去重：排序后 保留当前元素和前一个元素不同的

void Unique(){
	sort(a+1,a+n+1);
	int cnt=0;
	for(int i=1;i<=n;++i) if(a[i]!=a[i-1]) b[cnt++]=a[i];
}

离散化：一个大区间有许多浪费的位置，而且我们只需要它们的大小关系，可以将它们按大小重新编号

struct array{
	int Ori_num,Now_num,id;
	friend bool operator < (array x,array y){
		return x.Ori_num<y.Ori_num;
	}
}a[N];

boold comp(array x,array y){
	return x.id<y.id;
}

void Discre{
	sort(a+1,a+n+1);
	int cnt=0;
	for(int i=1;i<=n;++i) if(a[i].Ori_num!=a[i-1].Ori_num) a[i].Now_num=++cnt;
	sort(a+1,a+n+1,comp);
}

for(int i=1;i<=n;++i) scanf("%d",&a[i]),pos[i]=a[i];
sort(pos+1,pos+n+1);
int m=unique(pos+1,pos+n+1)-pos-1;
for(int i=1;i<=n;++i) b[i]=lower_bound(pos+1,pos+m+1,a[i])-pos;

————————————————————————————————————————————————————————————
简单题：
佳佳的魔法照片