算法导论复习(2) 归并排序

原创 2017年04月28日 21:14:03

归并排序时间复杂度
平均: θ(nlgn) 最好: O (nlgn) 最坏:O(nlgn)
空间复杂度:O(1)
课本在讲归并排序之前,先大致介绍了分治法。其中列出了分治模式在每层递归时的三个步骤

分解(将原问题分解成多个子问题)
解决(对子问题进行求解)
合并(将子问题解合并成原问题解)

随后,已上文三个步骤为模板,分析了归并排序的分治策略

  1. n元素序列分为n/2个元素的两个子序列
  2. 使用归并排序递归排序子序列
  3. 合并子序列得到答案

代码分析:
1.子问题的伪代码

MERGE(A,p,q,r)  (A:被排序的数组p:数组头q:数组中r:数组尾)
n1=q-p+1
n2=r-q
//let L[1..n+1]and R[1..n2+1]be new array  (创建子问题数组)
for i =1 to n1
L[i]=A[p+i-1]                  
for j=1 to n2
R[j]=A[q+j]
L[n1+1]=∞            
L[n2+1]=∞ 
i=1
j=1
for k=p to r
if L[i]<=R[j]
else A[k]=R[j]
j+=1 

主体归并伪代码
MERGE-SORT(A,p,r)
if(p<r)
q=(p+r)/2下界
MERGE-SORT(A,p,q)             (左半子问题)           
MERGE-SORT(A,q+1,r)          (右半子问题)
MERGE(A,p,q,r)           (归并子问题)

实现代码(C++)

#include <iostream>
using namespace std;
void sort(int*&a, int p, int q, int r)
{
  int* left =new int[q - p +1];
  int* right =new int[r - q];
  for(int i =0; i < q - p +1; i++)
    left[i] = a[p + i];
  for(int i =0; i < r - q; i++)
    right[i] = a[q + i +1];

  int m =0;
  int n =0;
  for(int i = p; i <= r; i++) {
    if(left[m] <= right[n]) {
      a[i] = left[m];
      if(m++== q-p)
      {
        for(int j = i +1; j <= r; j++)
          a[j] = right[n++];
        break;
      }
    } 
    else {
      a[i] = right[n];
      if(n++== r-q-1) {
    for(int j = i +1; j <= r; j++)
      a[j] = left[m++];
    break;
      }
    }
  }

  delete[] left;
  delete[] right;
}
void merge(int*&a, int m, int n)
{
    int i;
  if(m < n) {
    int q = (m + n)/2;
    merge(a, m, q);
    merge(a, q+1, n);
    sort(a, m, q, n); 
  }
}
int main()
{
    int n;
    int j;
    cin>>n;
    int* b =new int[100];
    int* a =new int[100];
    for(int i =0; i <n; i++)
    cin>>a[i];
    merge(a, 0, n-1);
    for(j=0;j<n;j++)
    {
        cout<<a[j]<<" ";
        b[j]=a[j];
    }
    cout<<endl;
  return 0;
}

算法分析
1.分解运行时间
分解:O(1)
解决:子问题规模为(n/2) 消耗 2T(n/2)运行时间
合并:n个元素进行MERGE需要θ(n)时间
2.递归式
这里写图片描述
画出递归树可以看到,树高lgn 每一层代价c(n),然后树根代价c(n),总代价cnlgn+cn 所以时间复杂度θ(nlgn)。

累了,暂时先发布,有时间再修改~!

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/JackHui141/article/details/70941183

算法导论学习:归并排序法的实现

上回学习了最简单也是最直接的插入排序。插入排序在小数据量时是很高效的,但是遇到大数据时,便显得无力了,今天来介绍归并排序,在大数据排序时,时间短,但同时它的空间使用率就显得高了。 第二章...
  • qq_17256847
  • qq_17256847
  • 2016-04-14 16:13:03
  • 344

【算法导论】归并排序

归并排序算法分析,欢迎拍砖!
  • cyp331203
  • cyp331203
  • 2014-12-02 21:42:55
  • 1111

算法导论:归并排序java实现

这是归并排序的部分代码,个人认为归并排序作为算法课的前导算法算是一个比较难的问题因为他涉及到了我们都比较恐惧的递归运算。说到递归我们都是非常头疼的,但是递归较其他用迭代来实现的算法又算是理解起来比较简...
  • xidian_db
  • xidian_db
  • 2015-03-30 16:33:09
  • 423

算法导论第二章总结:插入排序、归并排序

算法导论第二章总结                             这一章简要介绍了一个贯穿全书的框架。对于这个框架,我的理解就是算法的流程吧。         (1)   问题:算法需要实...
  • LuckyJune34
  • LuckyJune34
  • 2015-05-21 19:27:51
  • 1521

算法导论——归并排序

算法的设计有很多思想,之前的插入排序使用的是增量的方法,即在排好的子数组A中,将元素A[j]插入,形成新的子数组A。 这次将实现另一种排序——归并排序,归并排序采用了“分治法”(divide-and-...
  • Anger_Coder
  • Anger_Coder
  • 2013-09-30 11:16:46
  • 2781

算法导论程序2--归并排序(Python)

归并排序: def merge(A,p,q,r): n1 = q-p+1 n2 = r-q L = [] R = [] for i in range(n1)...
  • zhang_xiaomeng
  • zhang_xiaomeng
  • 2017-05-06 22:05:59
  • 192

算法导论期末复习(一)

冒泡排序: for循环从第一个元素开始遍历直到n-1,for循环从index+1开始到n-1将元素和后面的元素比较,遇到大的就交换直到遍历到最后一个,将最沉的交换到最后面,index + 1 蛮力法 ...
  • mr_guo_lei
  • mr_guo_lei
  • 2017-12-20 18:51:04
  • 111

跟着《算法导论》学习——插入排序与归并排序

读前声明:本人所写帖子主要为了记录本人学习的一个过程,无他想法,由于内容比较肤浅,如有雷同,非常正常!!! 本文内容: 本文主要是参考《算法导论》这本书,完成部分算法编写,可能编程习惯或者风格比较...
  • wangjiangah
  • wangjiangah
  • 2013-12-20 13:52:09
  • 553

学习算法导论过程的汇总

算法导论的学习安排
  • actanble
  • actanble
  • 2016-06-19 11:52:38
  • 512

《算法导论》--归并排序

#include using namespace std; void merge(int *arr, int left, int mid, int right) { int i, j,k; in...
  • u013018651
  • u013018651
  • 2017-05-16 23:00:33
  • 130
收藏助手
不良信息举报
您举报文章:算法导论复习(2) 归并排序
举报原因:
原因补充:

(最多只允许输入30个字)