算法 排序算法之归并排序

归并排序

归并排序主要是二路归并排序

基本思想

设数组a中存放了n个数据元素

初始时把它们看成n个长度为1的有序子数组，然后从第一个子数组开始，把相邻子数组两两合并，得到n/2的整数上界个长度为2的新的有序子数组（当n为奇数时最后一个新的有序子数组的长度为1）

对这些新的有序子数组再两两合并，直到最后长度为n的有序数组位置

排序过程

以数组{50,10,90,30,70,40,80,60,20}为例

代码实现

void Merge(DataType a[], int n, DataType swap[], int k) {
/*k为有序子数组的长度，一次二路归并排序后的有序子序列放在数组swap中*/
int m = 0, u1, l2, i, j, u2;

/*第一个有序子数组下界为0*/
int l1 = 0;
while (l1 + k <= n - 1) {
l2 = l1 + k;//计算第二个有序子数组下界
u1 = l2 - 1;//计算第一个有序子数组上界
u2 = (l2 + k - 1 <= n - 1) ? l2 + k - 1 : n - 1;//计算第二个有序子数组上界

/*两个有序子数组合并*/
for (i = l1, j = l2; i <= u1 && j <= u2; m++) {
if (a[i] <= a[j]) {
swap[m] = a[i];
i++;
} else {
swap[m] = a[j];
j++;
}
}

/*子数组2已归并完，将数组1中剩余的元素放到数组swap中*/
while (i <= u1) {
swap[m] = a[i];
m++;
i++;
}

/*子数组1已归并完，将数组2中剩余的元素放到数组swap中*/
while (j <= u2) {
swap[m] = a[j];
m++;
j++;
}
l1 = u2 + 1;
}
/*将原始数组中只够一组的元素顺序放到数组swap中*/
for (i = l1; i < n; i++, m++) {
swap[m] = a[i];
}
}

void MergeSort(DataType a[], int n) {
int i, k = 1;//归并长度从1开始
DataType * swap;

swap = (DataType *) malloc(sizeof(DataType) * n);

while (k < n) {
Merge(a, n, swap, k);
for (i = 0; i < n; i++) {
a[i] = swap[i];
}
k = 2 * k;
}
free(swap);
}

java实现

public static void mergeSort(int[] arr) {
mergeSort(arr, 0, arr.length - 1);
}

private static void mergeSort(int[] arr, int low, int high) {
int mid = (low + high) / 2;
if (low < high) {
//左边
mergeSort(arr, low, mid);
//右边
mergeSort(arr, mid + 1, high);
//左右归并
merge(arr, low, mid, high);
}
}

private static void merge(int[] arr, int low, int mid, int high) {
int[] temp = new int[high - low + 1];
int left = low;//左指针
int right = mid + 1;//右指针
int k = 0;
//把较小的数先移动到新数组中
while (left <= mid && right <= high) {
if (arr[left] < arr[right]) {
temp[k++] = arr[left++];
} else {
temp[k++] = arr[right++];
}
}
//把左边剩余的数移入数组
while (left <= mid) {
temp[k++] = arr[left++];
}

//把右边剩余的数移入数组
while (right <= high) {
temp[k++] = arr[right++];
}

//把新数组中的数覆盖nums数组
for (int k2 = 0; k2 < temp.length; k2++) {
arr[k2 + low] = temp[k2];
}
}

算法分析

时间复杂度

一次二路归并排序归并的次数log2n 每次比较次数n-1 故时间复杂度是O(nlog2n)

空间复杂度

使用了n个临时内存单元存放数据 空间复杂度O(n)

稳定性

归并排序是一种比较占内存，但却效率高且稳定的算法