排序算法归纳（c语言） ⑥归并排序

归并排序

归并，顾名思义是归一，合并的意思。
具体的做法大体是：将两个有序子段归并为一个长段，重复这一过程，最终就能得到一个有序序列了。
所以，纵观整个对并过程，就像是一颗完全二叉树。由二叉树的深度可以得出，整个归并排序的执行次数是以2为底n的对数。自然，这是一个对数级的操作。
扫描整个整个序列需要耗时O(n)，所以，对并排序是一个时间复杂度为O(nlogn)。
归并中因为开取了辅助空间，空间复杂度为O(n+logn)。
重要的一点是，归并排序是一种稳定排序。
总之，归并排序是一种比较占内存，但效率高且稳定的排序算法。

待排序数据依然存放于顺序表中。
数据存放没有从0开始，而是选择从1开始。
代码参考于《大话数据结构》。

初始设定

#include<stdio.h>
#include<malloc.h>
#define MAXSIZE 20 //顺序表最大容量
#define N 10  //表中数据个数

顺序表结构体

typedef struct
{
 int data[MAXSIZE + 1];
 int len;  //已存储元素个数
}Sqlist;

输出顺序表

void Show(Sqlist L)
{
 int i;
 for (i = 1; i < L.len; ++i)
 {
  printf("%d,", L.data[i]);
 }
 printf("%d\n", L.data[i]);
}

输入函数

void Input(Sqlist* lp)
{
 int d[N] = { 9, 1, 5, 8, 3, 0, 7, 4, 6, 2 };
 for (int i = 0; i < N; i++)
  lp->data[i + 1] = d[i];
 lp->len = N;
}

递归版归并排序

void Merge(int SR[], int TR[], int i, int m, int n)
{
 //将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]
 int j, k, l;
 for (j = m + 1, k = i; i <= m && j <= n; k++)
 {
  if (SR[i] < SR[j])
   TR[k] = SR[i++];
  else
   TR[k] = SR[j++];
 }
 if (i <= m)//将剩余的SR[i..m]复制到TR
 {
  for (l = 0; l <= m - i; l++)
   TR[k + l] = SR[i + l];
 }
 if (j <= n)//将剩余的SR[j..n]复制到TR
 {
  for (l = 0; l <= n - j; l++)
   TR[k + l] = SR[j + l];
 }
}

void MSort(int SR[], int TR1[], int s, int t)
{
 //将SR[s..t]归并排序为TR1[s..t]
 int m;
 int TR2[MAXSIZE + 1];
 if (s == t)
  TR1[s] = SR[s];
 else
 {
  m = (s + t) / 2;
  MSort(SR, TR2, s, m);
  MSort(SR, TR2, m + 1, t);
  Merge(TR2, TR1, s, m, t);
 }
}

void MergeSort_Recursion(Sqlist* lp)
{
 MSort(lp->data, lp->data, 1, lp->len);
}

优化版归并排序

其中Merge函数同上

void MergePass(int SR[], int TR[], int s, int n)
{
 //将SR[]中相邻长度为s的子序列两两归并到TR[]
 int i = 1;
 int j;
 while (i <= n - 2 * s + 1)
 {
  Merge(SR, TR, i, i + s - 1, i + 2 * s - 1);
  i = i + 2 * s;
 }
 if (i < n - s + 1)
  Merge(SR, TR, i, i + s - 1, n);
 else
 for (j = i; j <= n; j++)
  TR[j] = SR[j];
}

void MergeSort_Iteration(Sqlist* lp)
{
 int* TR = (int*)malloc(lp->len * sizeof(int));
 int k = 1;
 while (k < lp->len)
 {
  MergePass(lp->data, TR, k, lp->len);
  k = 2 * k;
  MergePass(TR, lp->data, k, lp->len);
  k = 2 * k;
 }
}

系列链接

上一个排序算法：
⑤堆排序
下一个排序算法：
⑦快速排序