求逆序对算法总结

设A[1..n]是一个包含N个非负整数的数组。如果在i〈 j的情况下，有A〉A[j]，则(i,j)就称为A中的一个逆序对。
例如，数组（3，1，4，5，2）的“逆序对”有<3,1>,<3,2><4,2><5,2>，共4个。
那么该如何求出给定一个数列包含逆序对个数？

首先最简单的方法，直接遍历，时间复杂度为O(n^2）

源码如下:

//最简单的办法，直接枚举遍历
int count_inverse_pairs(int a[],int first, int last)
{
    int count = 0;
    int i;
    while(first < last)
    {
        i = first +1;
    //    int cout_tmp = 0;
        while(i <= last)
        {
            if(a[i] <  a[first]){
                count++;
        //        ++ cout_tmp;
            }
            i++;
        }
        //cout<<cout_tmp<<endl;
        first++;
    }
    cout << count << endl;
    return count;
}

其时间复杂度比较的高。一般不值得使用，

可以根据分析插入排序的特点，重新设计，插入排序，每个数字向前移动的次数，就是以该元素为第一元素的逆序对的数目，其时间复杂度和插入排序是一样的O（n^2）,具体的源代码如下所示（直接来自于网络）：

/*************************************************
直接利用插入排序求逆序对，时间复杂度O(N^2）
Function: InsertionSort_Inversion
Description:对elems进行从小到大的排序来计算逆序对数量
Input:    elems:ElementType类型的数组
        size:elems的大小
Output: 逆序对的数量
*************************************************/
int InsertionSort_Inversion(ElementType elems[], int size)
{
    int inversion = 0;
    for (int i = 1; i < size; i++)
    {
    //    int tmp_count= 0;
        int j = i - 1;                    //j表示正在和key比较大小的数组元素的序号
        ElementType key = elems[i];
        while ( key < elems[j] && j >= 0)
        {
            elems[j + 1] = elems[j];
            j--;
            inversion++;
    //        ++tmp_count;
        }
    //    cout<<tmp_count <<endl;
        elems[j + 1] = key;
    }
    return inversion;
}

此种方法充分利用到了所学到的排序只是，但是时间复杂度依旧很大，于是很多人又想出了另一种方案，依据归并排序的特点就行求解，源代码（直接来源于网络）如下：

/*************************************************
利用归并排序求解
Function: MergeSort_Inversion
Description:对elems进行从小到大的排序来计算逆序对数量
Input:    elems:ElementType类型的数组
        begin:elems的开始序号
        end:elems的结束序号
Output: 逆序对的数量
*************************************************/
int MergeSort_Inversion(ElementType elems[], int begin, int end)
{
    int inversion = 0;
    if (end == begin)
    {
        return 0;
    }
    else if (end == begin + 1)
    {
        if (elems[begin] > elems[end])
        {
            ElementType tempElement = elems[begin];
            elems[begin] = elems[end];
            elems[end] = tempElement;
            inversion++;
        }
    }
    else
    {
        inversion += MergeSort_Inversion(elems, begin, (begin + end) / 2);
        inversion += MergeSort_Inversion(elems, (begin + end) / 2 + 1, end);
        inversion += Merge_Inversion(elems, begin, (begin + end) / 2, end);
    }
    return inversion;
}


/*************************************************
Function: Merge_Inversion
Description:对elems中begin到middle 和middle到end 两部分进行从小到大的合并，同时计算逆序对数量
Input:    elems:ElementType类型的数组
        begin:elems的开始序号
        middle:elems的分割序号
        end:elems的结束序号
Output: 逆序对的数量
*************************************************/
int Merge_Inversion(ElementType elems[], int begin, int middle, int end)
{
    int inversion = 0;
    int *tempElems = new int[end - begin + 1] ;
    int pa = begin;        //第一个子数组的开始序号
    int pb = middle + 1;    //第二个子数组的开始序号
    int ptemp = 0;        //临时数组的开始序号

    while (pa <= middle && pb <= end)
    {
        if (elems[pa] > elems[pb])
        {
            tempElems[ptemp++] = elems[pb++];
            inversion += (middle + 1 - pa);
        }
        else
        {
            tempElems[ptemp++] = elems[pa++];
        }
    }

    if (pa > middle)
    {
        for ( ; pb <= end; pb++)
        {
            tempElems[ptemp++] = elems[pb];
        }
    }
    else if(pb > end)
    {
        for ( ; pa <= middle; pa++)
        {
            tempElems[ptemp++] = elems[pa];
        }
    }
    //copy tempElems to lems
    for (int i = 0; i < end - begin + 1; i++)
    {
        elems[begin + i] = tempElems[i];
    }
    delete []tempElems;
    return inversion;
}

此外，还有气的解法，有人提出树状数组的解法，还有二分加快排的解法，自己去看吧，先说这么多了。

程序示例，所有的源代码（VS2010编译）：

// code-summary.cpp : 定义控制台应用程序的入口点。

/**************************************************************************
    * Copyright (c) 2013,  All rights reserved.
    * 文件名称    : code-summary.cpp
    * 文件标识    :
    * 摘    要    : 求逆序对个数的算法
    *
    * 当前版本    : Ver 1.0
    * 作者    : 徐冬冬
    * 完成日期    : 2013/05/10
    *
    * 取代版本    :
    * 原作者    :
    * 完成日期    :
    * 开放版权  : GNU General Public License GPLv3
*************************************************************************/
#include "stdafx.h"

#include <iostream>
#include <random>
#include <stdlib.h>
using namespace std;

typedef int ElementType;

int InsertionSort_Inversion(ElementType elems[], int size);
int MergeSort_Inversion(ElementType elems[], int begin, int end);
int Merge_Inversion(ElementType elems[], int begin, int middle, int end);

//求逆序对个数
//初始化数组
void init(int a[], int len)
{
    int i =0;
    for( i=0;  i<len ;i++)
    {
        a[i]= rand();
    }
    return ;
}
///遍历数组，打印输出
void print(int *a, int len)
{
    int i =0;
    for( i=0;  i<len; i++)
    {
        cout << a[i] <<'\t';
    }
    cout << endl;
    return ;
}
//交换两个元素
void swap(int &a, int &b)
{
    int tmp =a;
    a = b;
    b=tmp;
    return ;
}
//最简单的办法，直接枚举遍历
int count_inverse_pairs(int a[],int first, int last)
{
    int count = 0;
    int i;
    while(first < last)
    {
        i = first +1;
    //    int cout_tmp = 0;
        while(i <= last)
        {
            if(a[i] <  a[first]){
                count++;
        //        ++ cout_tmp;
            }
            i++;
        }
        //cout<<cout_tmp<<endl;
        first++;
    }
    cout << count << endl;
    return count;
}

/*************************************************
直接利用插入排序求逆序对，时间复杂度O(N^2）
Function: InsertionSort_Inversion
Description:对elems进行从小到大的排序来计算逆序对数量
Input:    elems:ElementType类型的数组
        size:elems的大小
Output: 逆序对的数量
*************************************************/
int InsertionSort_Inversion(ElementType elems[], int size)
{
    int inversion = 0;
    for (int i = 1; i < size; i++)
    {
    //    int tmp_count= 0;
        int j = i - 1;                    //j表示正在和key比较大小的数组元素的序号
        ElementType key = elems[i];
        while ( key < elems[j] && j >= 0)
        {
            elems[j + 1] = elems[j];
            j--;
            inversion++;
    //        ++tmp_count;
        }
    //    cout<<tmp_count <<endl;
        elems[j + 1] = key;
    }
    return inversion;
}

/*************************************************
利用归并排序求解
Function: MergeSort_Inversion
Description:对elems进行从小到大的排序来计算逆序对数量
Input:    elems:ElementType类型的数组
        begin:elems的开始序号
        end:elems的结束序号
Output: 逆序对的数量
*************************************************/
int MergeSort_Inversion(ElementType elems[], int begin, int end)
{
    int inversion = 0;
    if (end == begin)
    {
        return 0;
    }
    else if (end == begin + 1)
    {
        if (elems[begin] > elems[end])
        {
            ElementType tempElement = elems[begin];
            elems[begin] = elems[end];
            elems[end] = tempElement;
            inversion++;
        }
    }
    else
    {
        inversion += MergeSort_Inversion(elems, begin, (begin + end) / 2);
        inversion += MergeSort_Inversion(elems, (begin + end) / 2 + 1, end);
        inversion += Merge_Inversion(elems, begin, (begin + end) / 2, end);
    }
    return inversion;
}


/*************************************************
Function: Merge_Inversion
Description:对elems中begin到middle 和middle到end 两部分进行从小到大的合并，同时计算逆序对数量
Input:    elems:ElementType类型的数组
        begin:elems的开始序号
        middle:elems的分割序号
        end:elems的结束序号
Output: 逆序对的数量
*************************************************/
int Merge_Inversion(ElementType elems[], int begin, int middle, int end)
{
    int inversion = 0;
    int *tempElems = new int[end - begin + 1] ;
    int pa = begin;        //第一个子数组的开始序号
    int pb = middle + 1;    //第二个子数组的开始序号
    int ptemp = 0;        //临时数组的开始序号

    while (pa <= middle && pb <= end)
    {
        if (elems[pa] > elems[pb])
        {
            tempElems[ptemp++] = elems[pb++];
            inversion += (middle + 1 - pa);
        }
        else
        {
            tempElems[ptemp++] = elems[pa++];
        }
    }

    if (pa > middle)
    {
        for ( ; pb <= end; pb++)
        {
            tempElems[ptemp++] = elems[pb];
        }
    }
    else if(pb > end)
    {
        for ( ; pa <= middle; pa++)
        {
            tempElems[ptemp++] = elems[pa];
        }
    }
    //copy tempElems to lems
    for (int i = 0; i < end - begin + 1; i++)
    {
        elems[begin + i] = tempElems[i];
    }
    delete []tempElems;
    return inversion;
}


int _tmain(int argc, _TCHAR* argv[])
{
    int *arr = new int[10];
    init(arr, 10);
    print(arr, 10);
    int  count= count_inverse_pairs( arr,0,9);
    print(arr, 10 );

    print(arr, 10);
    count = InsertionSort_Inversion(arr, 10);
    cout<< count <<endl;
    print(arr, 10 );

    print(arr, 10);
    count = MergeSort_Inversion(arr, 0, 9);
    cout<< count <<endl;
    print(arr, 10 );

    system("pause");
    return 0;
}


/************************************************************************/
/**
树状数组 求解，没看到懂
http://blog.csdn.net/weiguang_123/article/details/7895848

其实这些都用不上，二分加快排最简单，时间复杂度比树状数组小得多。
详见以下：
program liujiu;
var n,m:longint;
w,s,f,pai:array[0..100010]of int64;
ans:int64;

procedure init;
var i:longint;
begin
assign(input,'snooker.in');
assign(output,'snooker.out');
reset(input);
rewrite(output);
fillchar(w,sizeof(w),0);
fillchar(s,sizeof(s),0);
fillchar(f,sizeof(f),0);
randomize;
s[0]:=0;
readln(n,m);
for i:=1 to n do
begin
read(w[i]);
w[i]:=w[i]-m;
s[i]:=s[i-1]+w[i];
end;
end;

procedure sort(l,r:longint);
var i,j,k,le:longint;
begin
i:=l;
j:=r;
k:=pai[random(r-l)+l];
while i<=j do
begin
while pai[i]<k do inc(i);
while pai[j]>k do dec(j);
if i<=j then
begin
le:=pai[i];
pai[i]:=pai[j];
pai[j]:=le;
inc(i);
dec(j);
end;
end;
if i<r then sort(i,r);
if j>l then sort(l,j);
end;


procedure   work(left,right:longint);
var i,t,j,mid:longint;
begin
mid:=(left+right)div 2;
for i:=left to right do pai[i]:=s[i];
sort(left,mid);
sort(mid+1,right);
i:=left;
j:=mid+1;
while (j<=right)and(i<=mid)do
begin
while (pai[j]>pai[i])and(j<=right)
and(i<=mid)do
begin
inc(ans,(right-j+1));
inc(i);
end;
inc(j);
end;
if left<mid then work(left,mid);
if mid+1<right then work(mid+1,right);
end;

procedure main;
var i,j,k,l:longint;
begin
ans:=0;
work(0,n);
writeln(ans);
close(input);
close(output);
end;

begin
init;
main;
end.
                            http://tieba.baidu.com/p/934583490
                */
/************************************************************************/

参考：

http://www.cnblogs.com/XiongHarry/archive/2008/11/06/1327732.html

http://blog.csdn.net/fanhj__2007/article/details/5544526

http://blog.sina.com.cn/s/blog_69dcc82d0100vnff.html

树状数组实现的网络参考（我自己还没有弄懂）；

http://www.cppblog.com/acronix/archive/2010/10/29/131753.aspx?opt=admin

http://blog.csdn.net/weiguang_123/article/details/7895848