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

小说:矿工游戏网赚作者:石安侯更新时间:2018-09-22字数:20008

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


前面两篇总结了常见的几种排序算法的主要思想以及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 或者扫描下方二维码直接关注,

 

 

当前文章:http://www.leetaemin.cn/html_75977.html

发布时间:2018-09-22 16:28:25

坚果云官网 在网上怎么样能赚钱吗 手机看新闻赚钱的软件 store排行榜 热血侠网游单机论坛 手机淘宝如何无痕浏览 电脑机箱电源排 倒卖什么东西最挣钱 dash 微信一天能发多少红包

62009 57673 36734 27119 38287 2948656247 43732 36789

我要说两句: (0人参与)

发布