2-4 逆序对
设A[1...n]是一个包含n个不同数的数组。如果在i<j的情况下,有A[i]>A[j],则(i,j)就称为A中的一个逆序对。
(1)列出数组{2,3,8,6,1}的五个逆序。
(2)如果数组的元素取自{1,2...,n},那么,怎样的数组含有最多的逆序对?
(3)插入排序的时间与输入数组中逆序对的数量之间有怎样的关系?
(4)给出一个算法,能用Θ(n㏒n)的最坏运行时间,确定n个元素的任何排列中逆序对的数目。(提示:修改合并排序)
解答:
(1) 略
(2)逆序数组
(3)插入排序的时间与输入数组中逆序对的数量呈线性正相关关系。通过观察插入排序的算法伪码可知,算法的运行步骤主要取决于内层循环中元素移动的次数,而每次移动就意味着数组的逆序数减一,当排序结束时逆序数为零。
(4)依据分治法,如果我们将数组分解成两个子序列,分别求出两个子序列的逆序数,再求出两个子序列之间元素的逆序数,就可以得出整个数组的逆序数了。可以做以下考虑:
分解:将问题分成前后两个规模为n/2的数组
解决:分别求解各自的逆序对数。如果子问题规模为2或1,可直接求解。
合并:此时虽然知道两个子序列各自的逆序对数,但两个子序列之间的逆序对数无法轻易获知,如果进行两两比较的话,合并操作的时间复杂度就是n2 ,分治法没有意义。
再考虑上述“合并”的问题,如果此时两个子序列都是有序的话,则通过修改合并排序的MERG过程就可以得出子序列之间的逆序数:在MERG对两个子序列的第一个元素之间进行选则时,如果前一个序列的首元素被选中,则逆序数不变——该元素不会和后一个序列中的剩下元素构成逆序对,如果第二个序列的首元素被选中,则逆序数增加“第一个序列剩下的元素数”——该元素和前一序列中剩下的每个元素构成逆序对,MERG后这些逆序对消除。按着这个思路分治算法重新设计如下:
分解:将问题分成前后两个规模为n/2的数组
解决:分别进行递归合并排序,并记录累加排序所消除的的逆序对数。如果子问题规模为2或1,可直接求解。
合并:通过合并排序的MERG进行合并,在MERG过程中按上述方法累加逆序数。
PS:
(1)如果没有要求最坏情况下时间复杂度为nlogn的话,这个问题还可以用直接插入排序解决。直接插入排序会将每个等待插入合适位置的数(待插数)与它前面的数挨个比较,直到找到某个数X比待插数小,从而X的后一位就是待插数应当插入的地方(假定要求按从小到大的顺序来排)。这一过程实际就是查找并消除逆序对的过程,待插数与它”跨过“的每个数都构成一个逆序对,当待插数”跨过“这些数后,相应逆序对就被消除,因此每次插入时待插数向前”跨过“了几个数,相应的就少了几个逆序对,因此每”跨一次“,也就是待插数前面的数每后移一次,让计数器加一。直到所有数排序完成,这时得到的逆序对总数就是原始序列中的逆序对数。
而且由于直接插入排序是每个数依次、连续比较,所以不存在遗漏,上述方法可行。
(2)但要注意,不能用希尔排序。虽然本质仍是插排,但希尔排序是跳跃式的排序,有可能一次跳过多个能与待插数够成逆序对的数,但计数器还是只能加一。比如初始序列为5 4 3 2 1,若取初始步长为2,则第一次比较(即”跨第一次“)之后,变为3 4 5 2 1,计数器加一,但少了三个逆序对5,4、5,3、4,3。
(3)在最初用分治法考虑问题(4)时,排序的作用在一开并不那么明显,但通过对“合并”的分析,要求对子问题的求解需要产生“排序”的副作用。这种”副作用“在分治法中是值得注意的。
代码(java):
import java.util.Arrays;
public class Test {
public static int count = 0;
public static void main(String[] args) {
int arr[] = { 6, 5, 4, 3, 2, 1 };
int[] result = sort_and_count(arr);
System.out.println("逆序数:"+count);
for(int i=0;i<result.length;i++){
System.out.print(result[i]+" ");
}
}
private static int[] sort_and_count(int[] arr) {
if (arr.length == 1) {
return arr;
}
int length = arr.length;
int alength = length / 2;
int A[] = Arrays.copyOfRange(arr, 0, alength);
int B[] = Arrays.copyOfRange(arr, alength, length);
A = sort_and_count(A);
B = sort_and_count(B);
arr = merge_and_count(A, B);
return arr;
}
//此函数有两个功能:
//(1)归并排序中的归并
//(2)计算逆序数
private static int[] merge_and_count(int[] a, int[] b) {
int i = 0;
int j = 0;
int result[] = new int[a.length+b.length];
int current = 0;
while (i < a.length && j < b.length) {
if(a[i]<b[j]){
result[current++] = a[i];
i++;
}
if(a[i]>b[j]){
result[current++] = b[j];
count += (a.length - i);
j++;
}
}
if(i==a.length){
for(;j<b.length;j++){
result[current++] = b[j];
}
}
if(j==b.length){
for(;i<a.length;i++){
result[current++] = a[i];
}
}
return result;
}
}
(C++):
//归并排序求逆序对数
#include <iostream>
using namespace std;
int cnt=0;
// 归并排序中的合并算法
void Merge(int a[], int left, int center, int len)
{
int *t = (int *) malloc((len-left+1) * sizeof(int)); //申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列
int i = left;
int j = center;
int k = 0;
while (i<center && j<len) //比较两个指针所 指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置
{
if (a[i] <= a[j])
t[k++] = a[i++];
else
{
t[k++] = a[j++];
//如果后面的数要前移,说明前半部分的后面的数原先是大于后半部分的那个数的,等于center-i,
//因为每部分数组是有序的。
cnt+=center-i;
}
}
while (i < center) //若第一个序列有剩余,直接拷贝出来粘到合并序列尾
t[k++] = a[i++];
while (j < len) //若第二个序列有剩余,直接拷贝出来粘到合并序列尾
t[k++] = a[j++];
//将排序好的序列拷贝回数组中
for (i=left,k=0; i<len; i++,k++)
a[i] = t[k];
free(t);
}
// 归并排序
void MSort(int a[], int left, int right)
{
if (left < right)
{
int center = (left + right) / 2;
// 对前半部分进行排序
MSort(a, left, center);
// 对后半部分进行排序
MSort(a, center+1, right);
// 合并前后两部分
Merge(a, left, center+1, right+1);
}
}
void MergeSort(int a[], int n)
{
MSort(a, 0, n-1);
//=================================
for(int i=0;i<n;i++)
{
if(i%5==0)
cout<<endl;
cout<<a[i]<<" ";
}
cout<<endl;
}
int main()
{
FILE *fin=fopen("8.1.2.txt","r");
int num[80],i=0;
while(fscanf(fin,"%d",&num[i])!=EOF)
i++;
MergeSort(num,i);
cout<<cnt<<endl;
fclose(fin);
return 0;
}