Ultra-QuickSort 学习归并排序（树状数组+离散化）

以前学习归并排序，只是很简单的知道其思想，(约莫大一老万讲过)就是开辟一块空间，比较两块谁小谁就拿进来

但是号程序并不仅仅是能写得出来，还要通用简易。

这道题目描述：

The algorithm processes a sequence of n distinct integers by swapping two adjacent sequence elements until the sequence is sorted in ascending order

怎么看怎么像冒泡的意思，但百度一下，意思求逆序数（自左往右看比该位置上小的数的个数）

------------（1）                 ------------（2）

-------------------------------------（3）

1 、2都已经有序且在整个序列中的顺序就是如此（1前2后），因此逆序数可以看作：当1中有比2大的数字，则2中的这个数字是1中该位置后所有数字的逆序数（都已经有序）

#include <stdio.h>

__int64 ans=0;

int a[500001],b[500001];

void mergesortnext(int low,int mid,int high)
{
	int i,j,k;
	i=low;j=mid+1;k=low;
	while(i<=mid && j<=high)
		if(a[i]<=a[j])
			b[k++]=a[i++];
		else
			b[k++]=a[j++],ans+=mid-i+1;//关键点，2中的这个数字是1中该位置后所有数字的逆序数
	while(i<=mid)
		b[k++]=a[i++];
	while(j<=high)
		b[k++]=a[j++];
	while(low<=high)
		a[high--]=b[--k];//以前没注意，开辟空间归并完后再放回去
}
void mergesort(int low,int high)
{
	int mid;
	if(low>=high)
		return;
	mid=low+high;
	mid/=2;
	mergesort(low,mid);//递归深度不会很深O(log2 n)，且一层完后才会有下一句的递归
	mergesort(mid+1,high);
	mergesortnext(low,mid,high);
}


int main()
{
	int i,j,n;
	while(scanf("%d",&n) && n)
	{
		for(i=0;i<n;i++)
			scanf("%d",a+i);
		ans=0;
		mergesort(0,n-1);
		printf("%I64d\n",ans);
	}
	return 0;
}

2014.11.2

再来一种做法：树状数组

只不过数据规模问题需要离散化，使用下标对下标离散化，用map必然超时。

思想：当一个数据过来统计比它大的数字个数（定义）

#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
#define lowbit(x) ((x)&(-(x)))
#define LL long long
LL c[500005],b[500005];//c存和，b存逆序数
int n;
struct node
{
	int value,num;
}arr[500005];
bool cmp(node x,node y)
{
	return x.value<y.value;
}
LL getsum(int pos)
{
    int x=pos;
    LL sum=0;
    for(;x>0;x-=lowbit(x))
        sum+=c[x];
    return sum;
}
void update(int pos,int value) //更新pos的值
{
    int x=pos;
    for(;x<=n;x+=lowbit(x))
        c[x]+=value;
}
int main()
{
	for(;scanf("%d",&n)&&n;)
	{
		memset(c,0,sizeof(c));
                for(int i=1;i<=n;i++)
		{
			scanf("%d",&arr[i].value);
			arr[i].num=i;
		}
		sort(arr+1,arr+1+n,cmp);
		for(int i=1;i<=n;i++)
		{
			arr[arr[i].num].value=i;//离散化
		}
		for(int i=1;i<=n;i++)
		{
			update(arr[i].value,1);
			b[i]=i-getsum(arr[i].value);
		}
		__int64 ans=0;
		for(int i=1;i<=n;++i)
			ans+=b[i];
		printf("%I64d\n",ans);
	}
	return 0;
}