0x05排序

排序算法分为三类：

1. 选择排序（不稳定），插入排序，冒泡排序
2. 堆排序（不稳定），归并排序，快速排序（不稳定）
3. 计数排序，基数排序，桶排序

前两类是基于比较的排序算法
第一类O(n²)；第二类O(nlogn)
第三类不直接比较大小，对被排序数值采取按位划分或分类映射等处理方式，因此时间复杂度与数值大小范围也有关。

各类算法分析具体参考
https://blog.csdn.net/alzzw/article/details/98100378

两种常用高性能算法（基于分治思想）模板：
快排：
确定分界点——>调整区间——>递归处理区间
确定一个合适的分界点十分重要
【分界点随机值；常用a[l],a[r],a[mid]】
序列有序时，取边界点作为分界点，快排算法效率降至O(n²)

void quick_sort(int a[],int l,int r)
{
    if(l>=r) return;
    int x=a[(l+r)/2],i=l-1,j=r+1;
    while(i<j)
    {
        do i++;while(a[i]<x);
        do j--;while(a[j]>x);
        if(i<j) swap(a[i],a[j]);
    }
    quick_sort(a,l,j);
    quick_sort(a,j+1,r);
}

归并排序：
确定分界点——>递归处理区间——>归并区间

void merge_sort(int l,int r)
{
    if(l>=r) return;
    int mid=(l+r)/2;
    merge_sort(l,mid);
    merge_sort(mid+1,r);
    int k=0,i=l,j=mid+1;
    while(i<=mid&&j<=r)
    {
        if(a[i]<=a[j]) temp[k++]=a[i++];
        else temp[k++]=a[j++];
    }
    while(i<=mid) temp[k++]=a[i++];
    while(j<=r) temp[k++]=a[j++];
    for(int i=l,j=0;i<=r;++i,++j)
    {
        a[i]=temp[j];
    }
}

离散化：
将无穷大的集合中的若干元素映射为有限集合以便于统计的方法
（问题与数值的绝对大小无关，或只与相对顺序有关）
数组排序并去重得到有序数组b，有序数组下标与数值之间建立映射关系，若要查询整数i代替的数值，返回b[i]；若要查询整数a[i]被谁替代，在b中二分查找其位置

sort(b,b+n);
n=unique(b,b+n)-b;
int find(int x)
{
	return lower_bound(b,b+n,x)-b
}

例题：


代码：

#include<bits/stdc++.h>
using namespace std;
const int N=200005;
int a[N],b[N],c[N],p[N*3],tot=0,ans[N*3];
int find(int x)
{
	return lower_bound(p,p+tot,x)-p;
}
int main()
{
	int n,m;cin>>n;
	for(int i=1;i<=n;++i)
	{
		cin>>a[i];
		p[tot++]=a[i];
	}
	cin>>m;
	for(int i=1;i<=m;++i)
	{
		cin>>b[i];p[tot++]=b[i];
	}
	for(int i=1;i<=m;++i)
	{
		cin>>c[i];p[tot++]=c[i];
	}
	sort(p,p+tot);
	tot=unique(p,p+tot)-p;
	for(int i=1;i<=n;++i)
	{
		ans[find(a[i])]++;
	}int maxn1=0,maxn2=0,res=0;
	for(int i=1;i<=m;++i)
	{
		int t1=ans[find(b[i])],t2=ans[find(c[i])];
		if(t1>maxn1||(t1==maxn1&&t2>maxn2))
		{
			maxn1=t1;maxn2=t2;res=i;
		}
	}
	cout<<res<<endl;
 } 

中位数：
代码：

#include<bits/stdc++.h>
using namespace std;
int a[100005];
int main()
{
	int n;cin>>n;
	for(int i=0;i<n;++i)
	{
		cin>>a[i];
	}
	int ans=0,res=0;
	sort(a,a+n);
	if(n%2) ans=a[n/2];
	else ans=(a[n/2]+a[n/2-1])/2;
	for(int i=0;i<n;++i)
	{
		res+=abs(a[i]-ans);
	 } 
	 cout<<res<<endl;
}

分析参考：[算法竞赛进阶指南] 七夕祭 (贪心+前缀和+中位数+排序)
代码：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=1e5+5;
ll row[N],col[N]; 
ll fun(ll a[],int n,ll temp)
{
	ll res=0;
		for(int i=1;i<=n;++i)
		{
			a[i]+=(a[i-1]-temp);
		}
		sort(a+1,a+1+n);
		temp=a[(n+1)/2]; 
		for(int i=1;i<=n;++i)
		{
			res+=abs(a[i]-temp);
		}
		return res;
}
int main()
{
	int n,m,k;cin>>n>>m>>k;

	for(int i=1;i<=k;++i)
	{
		int x,y;
		cin>>x>>y;
		row[x]++;
		col[y]++;
	}ll sumr=0,sumc=0;

	ll rows=k%n,cols=k%m;
	if(rows&&cols) 
	{
	cout<<"impossible"<<endl;return 0;	
	}
	else if(!rows&&!cols) cout<<"both "<<fun(row,n,k/n)+fun(col,m,k/m)<<endl;
	else if(!rows&&cols) cout<<"row "<<fun(row,n,k/n)<<endl;
	else if(rows&&!cols)cout<<"column "<<fun(col,m,k/m)<<endl;
}

动态维护中位数：
对顶堆：用小根堆和大根堆来动态维护序列。
其中，大根堆维护较小的一半元素，小根堆维护较大的一半元素。
序列中从小到大次序为 [1,len/2] 的整数存储在大根堆中。
序列中从小到大次序为[len/2+1,len] 的整数存储在小根堆中。
维护过程中，要保持两堆的元素个数相对一致，如果一边过多，就会打破这些性质，这时候就要取出元素较多的一堆的堆顶元素插入到另一个堆中。因此序列的中位数就是小根堆的堆顶元素。

维护过程如下：
读入一个新的数值 x
（比较x与中位数/即小根堆堆顶数的大小关系）：
若 x < small . t o p ( )，则将 x 插入大根堆。
若 x ≥ small . t o p ( )，则将 x 插入小根堆。
每次检查并维护上述性质即可。

代码：

#include<bits/stdc++.h>
using namespace std;

int main()
{
	int t;cin>>t;
	while(t--)
	{
		int n,m;cin>>n>>m;
		cout<<n<<' '<<(m+1)/2<<endl;
		priority_queue<int>big;
	priority_queue<int,vector<int>,greater<int> >small;
		int cnt=0;
		for(int i=1;i<=m;++i)
		{
			int x;cin>>x;
			if(small.empty()) small.push(x);
			else if(x>=small.top()) small.push(x);
			else big.push(x);
			if(small.size()>big.size()+1) 
			{
			big.push(small.top());small.pop();	
			}
			if(small.size()<big.size()) 
			{
				small.push(big.top());big.pop();
			}
			if(i&1)
			{
				cout<<small.top()<<' ';
				if(++cnt%10==0) cout<<endl;
			}
		}
		if(cnt%10) cout<<endl;
		
	}
 } 

#include<bits/stdc++.h>
#define ll long long  
using namespace std;
ll a[500005],b[500005];
ll ans=0;
void mergesort(int l,int r)
{
	if(l==r) return ;
	ll mid=(l+r)/2;
	mergesort(l,mid);
	mergesort(mid+1,r); 
		int i=l,j=mid+1,k=l;
	while(i<=mid&&j<=r)
	{
		if(a[i]<=a[j])
		{
			b[k++]=a[i++];
		}
		else 
		{
			b[k++]=a[j++];
			ans+=mid-i+1;
		}
	 } 
	while(i<=mid)
	{
		b[k++]=a[i++];
	}
	while(j<=r)
	{
		b[k++]=a[j++];
	}
	for(int i=l;i<=r;++i)
	{
		a[i]=b[i];
	}
}

int main()
{
	int n;
	while(cin>>n)
	{
		if(n==0) break;
		for(int i=0;i<n;++i)
		{
			cin>>a[i];
		}ans=0;
		mergesort(0,n-1);
			cout<<ans<<endl;
	}
 } 

奇数码问题

#include<bits/stdc++.h>
#define ll long long  
using namespace std;
int t[250005];
vector<int> a[2];
ll ans=0;
void merge(vector<int>&a,int l,int mid,int r)
{
	int i=l,j=mid+1;
	for(int k=l;k<=r;++k)
	{
		if(j>r||(i<=mid&&a[i]<=a[j]))
		t[k]=a[i++];
		else 
		{
			t[k]=a[j++];
			ans+=mid-i+1;
		}
	}
	for(int i=l;i<=r;++i)
	{
		a[i]=t[i];
	}
}
void mergesort(vector<int> &a,int l,int r)
{
	if(l>=r) return ;
	ll mid=(l+r)>>1;
	mergesort(a,l,mid);
	mergesort(a,mid+1,r); 
	merge(a,l,mid,r);
}
int main()
{
	int n;
	while(~scanf("%d",&n)) 
	{
		a[0].clear();a[1].clear();
		ans=0;
		for(int i=0;i<n*n;++i)
		{
		int x;scanf("%d",&x);if(x) a[0].push_back(x);
		}
		mergesort(a[0],0,a[0].size()-1);
		int ans1=ans;ans=0;
		for(int i=0;i<n*n;++i)
		{
		int x;scanf("%d",&x);if(x) a[1].push_back(x);
		}
		mergesort(a[1],0,a[1].size()-1);
		int ans2=ans;
		if(a[0].size()&&(ans1-ans2)&1)
		cout<<"NIE"<<endl;
		else cout<<"TAK"<<endl;
	}
 }