归并排序和快速排序的衍生问题

前面两篇总结了常见的几种排序算法的主要思想以及C++与python两种方式的实现过程， 几种排序算法中比较重要的就是归并排序和快速排序，这两种方法的相同点就是都使用了分治的思想，现在用来解决两个具体问题。

1.分治法

  分治法就是将原问题分割成同等结构的子问题，之后将子问题逐一解决后，原问题也就得到了解决。 需要注意的是归并排序和快速排序虽然都使用了分治的思想，但它们分别代表了分治算法的两类基本思想。对于归并排序而言，它对“分”这个过程没有做太多操作，只是简单的将数组分为两部分然后递归的进行归并排序，而归并排序的关键是这样分完之后如何将它们归并起来，即merge()操作。 
  而对于快速排序来说，则是废了很大功夫放在了如何“分”这个问题上，我们是选取了一个标定点，然后使用partition()这个子过程将这个标定点移到了合适的位置，当它移到了合适的位置之后才将整个数组分成了两部分，而这样分完之后，在“合”的时候就不用做过多的考虑了，只需要一步一步递归下去就好了。 
  下面解决两个直接从归并排序和快速排序中衍生出来的具体问题的。

2.求逆序对数量

• 问题描述：在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。给定一个数组，求出这个数组中的逆序对的总数。
• 这个问题直接的做法是逐个统计，复杂度是O(n^2)，但显然是很愚蠢的方法，这里可以利用归并排序的思想，在归并排序过程中统计逆序对的个数。
• 实现思想： 
    归并排序是将数列a[l,r]分成两部分，a[l,mid]和a[mid+1,r]分别进行归并排序，然后再将这两半合并起来。在合并的过程中（设l<=i<=mid，mid+1<=j<=r），当a[i]<=a[j]时，并不产生逆序数；当a[i]>a[j]时，在前半部分中比a[i]大的数都比a[j]大，将a[j]放在a[i]前面的话，逆序数要加上mid+1-i。因此，可以在归并排序中的合并过程中计算逆序数。
• C++实现：

#include <iostream>
using namespace std;
// 计算逆序数对的结果以long long返回
// 因为对于一个大小为n的数组, 其最大的逆序数对个数为 n*(n-1)/2, 非常容易产生整型溢出
// __merge函数求出在arr[l,mid]和arr[mid+1,r]有序的基础上, arr[l,r]的逆序数对个数
long long __merge(int arr[],int l,int mid,int r){
long long res = 0;// 初始化逆序数对个数 res = 0
int aux[r - l + 1];
for(int i = l;i <= r;i++)
aux[i - l] = arr[i];
int i = l;
int j = mid + 1;
for(int k = l;k <= r;k++){
if(i > mid){
arr[k] = aux[j - l];
j ++;
}
else if(j > r){
arr[k] = aux[i - l];
i ++;
}
else if(aux[i - l] < aux[j - l]){
arr[k] = aux[i - l];
i ++;
}
else{// 左半部分所指元素 > 右半部分所指元素
arr[k] = aux[j - l];
j ++;
res += (long long) (mid - i + 1);
// 此时, 因为右半部分所指的元素小
// 这个元素和左半部分的所有未处理的元素都构成了逆序数对
// 左半部分此时未处理的元素个数为 mid - j + 1
}
}
return res;
}
// 求arr[l,r]范围的逆序数对个数
long long __inversionCount(int arr[],int l,int r){
if(l >= r)
return 0;
int mid = l + (r - l) / 2;
long long res1 = __inversionCount(arr,l,mid);// 求出 arr[l,mid] 范围的逆序数
long long res2 = __inversionCount(arr,mid + 1,r);// 求出 arr[mid+1,r] 范围的逆序数
return res1 + res2 + __merge(arr,l,mid,r);
}
long long inversionCount(int arr[],int n){
return __inversionCount(arr,0,n - 1);
}
int main(){
int a[10] = {10,9,8,7,6,5,4,3,2,1};
int n = 10;
cout<< "逆序对数量为：" << inversionCount(a,n)<<endl;
}

• Python实现：

 

def __merge(arr,l,mid,r):
res = 0
aux = []
for x in range(l,r + 1):
aux.append(arr[x])
i = l
j = mid + 1
for k in range(l,r + 1):
if i > mid:
arr[k] = aux[j - l]
j += 1
elif j > r:
arr[k] = aux[i - l]
i += 1
elif aux[i - l] < aux[j - l]:
arr[k] = aux[i - l]
i += 1
else:
arr[k] = aux[j - l]
j += 1
res += mid - i + 1
return res
def __inversionCount(arr,l,r):
if l >= r:
return 0
mid = l + (r - l) // 2
res1 = __inversionCount(arr,l,mid)
res2 = __inversionCount(arr,mid + 1,r)
return res1 + res2 + __merge(arr,l,mid,r)
def inversionCount(arr):
n = len(arr)
return __inversionCount(arr,0,n - 1)
arr = [10,9,8,7,6,5,4,3,2,1]
res = inversionCount(arr)
print('逆序对数量为：' + str(res))

3.取数组中第k大的元素

• 题目很简单，给定一个数组，求出该数组中第k大的元素。最简单的做法是直接进行排序，算法复杂度是O(nlogn)，但是这么做很明显比较低效率，因为只要求出第k大的元素，并不需要别的信息。
• 另一种方法是用快速排序的思想。快速排序每次把一个元素交换到正确的位置，同时把左边的都放上小的，右边都放上大的。这个算法每一次选取一个中心点，排序之后，查看中心点的位置。如果它的位置大于K，就说明，要在前面一个子序列中找出第K大的元素。反之，如果小于K，就说明要在后面一个序列中找出第k大的元素。
• 复杂度分析： 
    这种算法的复杂度分析稍微复杂。第一次交换，算法复杂度为O(n)，接下来的过程和快速排序不同，快速排序是要继续处理两边的数据，再合并，合并操作的算法复杂度是O(1)，于是总的算法复杂度是O(nlogn)（可以这么理解，每次交换用了n，一共logn次）。但是这里在确定中心点的相对位置（在K的左边或者右边）之后不用再对剩下的一半进行处理。也就是说第二次插入的算法复杂度不再是O(n)而是O(n/2)，然后接下来的过程是1+1/2+1/4+........<2，换句话说就是一共是O(2n)的算法复杂度也就是O(n)的算法复杂度。 
    这个算法是一种很经典的算法。原因是因为它通过努力把算法复杂度在每次递归中下降一些，最终让整个算法的复杂度下降极多，算是一种十分聪明的做法。
• C++实现：

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
int __partition(int arr[],int l,int r){
swap(arr[l],arr[rand()%(r - l + 1) + l]);
int v = arr[l];
int j = l;
for(int i = l + 1;i <= r;i++){
if(arr[i] > v){
swap(arr[i],arr[j + 1]);
j ++;
}
}
swap(arr[l],arr[j]);
return j;
}
int __selection(int arr[],int l,int r,int k){
if(l == r)
return arr[l];
int p = __partition(arr,l,r);
if(p == k)
return arr[p];
else if(p > k)
return __selection(arr,l,p - 1,k);
else
return __selection(arr,p + 1,r,k);
}
int selection(int arr[],int n,int k){
srand(time(NULL));
return __selection(arr,0,n - 1,k - 1);//索引是从0开始的
}
int main(){
int arr[10] = {10,9,8,7,6,5,4,3,2,1};
int n = 10;
cout<<"数组中第3大的元素为："<<selection(arr,n,3)<<endl;
}

• Python实现：

import random
def __partition(arr,l,r):
k = random.randint(l,r)
arr[l],arr[k] = arr[k],arr[l]
v= arr[l]
j = l
for i in range(l + 1,r + 1):
if arr[i] < v:
arr[i],arr[j + 1] = arr[j + 1],arr[i]
j += 1
arr[l],arr[j] = arr[j],arr[l]
return j
def __selection(arr,l,r,k):
if l == r:
return arr[l]
p = __partition(arr,l,r)
if p == k:
return arr[p]
elif p > k:
return __selection(arr,l,p - 1,k)
else:
return __selection(arr,p + 1,r,k)
def selection(arr,k):
n = len(arr)
return __selection(arr,0,n - 1,k - 1)
arr = [10,9,8,7,6,5,4,3,2,1]
print('数组中第2小的元素为'+ str(selection(arr,2)))

---

推荐一个良心公众号【IT资源社】：

本公众号致力于免费分享全网最优秀的视频资源，学习资料，面试经验等，前端，PHP，JAVA，算法，Python，大数据等等，你想要的这都有

IT资源社－QQ交流群：625494093

也可添加微信拉你进微信群: super1319164238

微信搜索公众号：ITziyuanshe 或者扫描下方二维码直接关注，