算法导论复习（2） 归并排序

归并排序时间复杂度
平均： θ(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）。

累了，暂时先发布，有时间再修改~！