各种排序算法

快速排序

在L，R区间内通过一个中间值来使左边的数比中间值小，右边的值比中间值大，对于中间值来说，是有序的，再递归排序(L,mid-1）和（mid+1，R）即可。对于排序的过程，用一个双指针来查询左边区间不合法的值和右边区间不合法值，然后再进行交换。总的复杂度是O（nlogn）。不过一般用sort会更快，也会更方便。

#include<bits/stdc++.h>
using namespace std;
const int N=100005;
int n,a[N];
void quicksort(int l,int r)
{
	if(l==r)return;
	int mid=a[(l+r)/2];
	int i=l-1,j=r+1;
	while(i<j)
	{
		i++;
		while(a[i]<mid)i++;
		j--;
		while(a[j]>mid)j--;
		if(i<j)swap(a[i],a[j]);
	}
	quicksort(l,j);
	quicksort(j+1,r);
}
int main()
{
	while(cin>>n)
	{
		for(int i=1;i<=n;i++)scanf("%d",&a[i]);
		quicksort(1,n);
		for(int i=1;i<=n;i++)
		{
			if(i!=1)cout<<" ";
			cout<<a[i];
		}
		cout<<endl;
	}
}

归并排序

也是在L,R的区间内通过一个中间值mid，来使左右两区间本身是有序的，再去合并左右两区间使得整个L到R区间内是有序的。时间复杂度也是O（nlogn）。

一般可以用来写求整个数组的逆序对数量。

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=1000000+10;
int n,a[N],num=0,b[N];
void quicksort(int l,int r)
{
	if(l==r)return;
	int mid=(l+r)/2;
	quicksort(l,mid);
	quicksort(mid+1,r);
	int i=l,j=mid+1,p=l;
	while(i<=mid&&j<=r)
	{
		if(a[i]<=a[j])b[p++]=a[i++];
		else b[p++]=a[j++],num+=mid-i+1;
	}

	while(i<=mid)b[p++]=a[i++];
	while(j<=r)b[p++]=a[j++];
	for(i=l;i<=r;i++)a[i]=b[i];
}
signed main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin>>n;
	for(int i=1;i<=n;i++)cin>>a[i];
	quicksort(1,n);
	cout<<num<<endl;
}

堆排序

堆排序实际上是一颗二叉树，这个二叉树的父节点永远大于（或小于）其子节点，那么这棵树的根节点就是最大值（或最小值）。

复杂度也是O（nlogn）。但是他对于维护一个最大值或者最小值会更快。

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=1e6+10;
int a[N],cnt;
void up(int u)
{
	if(u/2&&a[u/2]>a[u])swap(a[u],a[u/2]),up(u/2);
}
void push(int x)
{
	cnt++;
	a[cnt]=x;
	up(cnt);
}
void down(int u)
{
	int v=u;
	if(u*2<=cnt&&a[u*2]<a[v])v=u*2;
	if(u*2+1<=cnt&&a[u*2+1]<a[v])v=u*2+1;
	if(u!=v)swap(a[u],a[v]),down(v);
}
void Delete()
{
	a[1]=a[cnt--];
	down(1);
}

这三种排序都是使用了分治的思想，首先排序部分，通过部分的有序最后达到整体的有序。