白话经典算法系列之九 从归并排序到数列的逆序数对(微软笔试题)

首先来看看原题

 

微软2010年笔试题

在一个排列中,如果一对数的前后位置与大小顺序相反,即前面的数大于后面的数,那么它们就称为一个逆序数对。一个排列中逆序的总数就称为这个排列的逆序数。如{2,4,3,1}中,2和1,4和3,4和1,3和1是逆序数对,因此整个数组的逆序数对个数为4,现在给定一数组,要求统计出该数组的逆序数对个数。

 

计算数列的逆序数对个数最简单的方便就最从前向后依次统计每个数字与它后面的数字是否能组成逆序数对。代码如下:

[cpp]  view plain  copy
  1. #include <stdio.h>  
  2. int main()  
  3. {  
  4.     printf("     数列的逆序数对 \n");      
  5.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");      
  6.   
  7.     const int MAXN = 8;  
  8.     int a[MAXN] = {1, 7, 2, 9, 6, 4, 5, 3};  
  9.       
  10.     int nCount = 0;  
  11.     int i, j;  
  12.     for (i = 0; i < MAXN; i++)  
  13.         for (j = i + 1; j < MAXN; j++)  
  14.             if (a[i] > a[j])  
  15.                 nCount++;  
  16.   
  17.     printf("逆序数对为: %d\n", nCount);  
  18. }  

运行结果如下:

这种方法用到了双循环,时间复杂度为O(N^2),是一个不太优雅的方法。因此我们尝试用其它方法来解决。

 

在《白话经典算法系列之五归并排序的实现》中观察归并排序——合并数列(135)(24)的时候:

1.先取出前面数列中的1

2.然后取出后面数列中的2明显!这个2和前面的35都可以组成逆序数对即3252都是逆序数对。

3.然后取出前面数列中的3

4.然后取出后面数列中的4同理,可知这个4和前面数列中的5可以组成一个逆序数对。

这样就完成了逆序数对的统计,归并排序的时间复杂度是O(N * LogN),因此这种从归并排序到数列的逆序数对的解法的时间复杂度同样是O(N * LogN),下面给出代码:

[cpp]  view plain  copy
  1. //从归并排序到数列的逆序数对  
  2. #include <stdio.h>  
  3. int g_nCount;  
  4. void mergearray(int a[], int first, int mid, int last, int temp[])  
  5. {  
  6.     int i = first, j = mid + 1;  
  7.     int m = mid,   n = last;  
  8.     int k = 0;  
  9.   
  10.     while (i <= m && j <= n) //a[i] 前面的数  a[j] 后面的数  
  11.     {  
  12.         if (a[i] < a[j])  
  13.             temp[k++] = a[i++];  
  14.         else  
  15.         {  
  16.             temp[k++] = a[j++];  
  17.             //a[j]和前面每一个数都能组成逆序数对  
  18.             g_nCount += m - i + 1;  
  19.         }  
  20.     }  
  21.   
  22.     while (i <= m)  
  23.         temp[k++] = a[i++];  
  24.   
  25.     while (j <= n)  
  26.         temp[k++] = a[j++];  
  27.   
  28.     for (i = 0; i < k; i++)  
  29.         a[first + i] = temp[i];  
  30. }  
  31. void mergesort(int a[], int first, int last, int temp[])  
  32. {  
  33.     if (first < last)  
  34.     {  
  35.         int mid = (first + last) / 2;  
  36.         mergesort(a, first, mid, temp);    //左边有序  
  37.         mergesort(a, mid + 1, last, temp); //右边有序  
  38.         mergearray(a, first, mid, last, temp); //再将二个有序数列合并  
  39.     }  
  40. }  
  41.   
  42. bool MergeSort(int a[], int n)  
  43. {  
  44.     int *p = new int[n];  
  45.     if (p == NULL)  
  46.         return false;  
  47.     mergesort(a, 0, n - 1, p);  
  48.     return true;  
  49. }  
  50.   
  51. int main()  
  52. {  
  53.     printf("     从归并排序到数列的逆序数对 \n");      
  54.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");      
  55.   
  56.     const int MAXN = 8;  
  57.     int a[MAXN] = {1, 7, 2, 9, 6, 4, 5, 3};  
  58.   
  59.     g_nCount = 0;  
  60.     MergeSort(a, MAXN);  
  61.     printf("逆序数对为: %d\n", g_nCount);  
  62.     return 0;  
  63. }  

运行结果:

 

 

好了,介绍到这里后,相信大家对如何求数列的逆序数对已经有了很好的认识,文章中所用到的“知识迁移”这种方法还是不错的,值得大家掌握。

 

 

转载请标明出处,原文地址:http://blog.csdn.net/morewindows/article/details/8029996

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值