歸併排序
歸併,顧名思義是歸一,合併的意思。
具體的做法大體是:將兩個有序子段歸併爲一個長段,重複這一過程,最終就能得到一個有序序列了。
所以,縱觀整個對並過程,就像是一顆完全二叉樹。由二叉樹的深度可以得出,整個歸併排序的執行次數是以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;
}
}
系列鏈接
上一個排序算法:
⑤堆排序
下一個排序算法:
⑦快速排序