java 归并排序 非递归_归并排序-递归及非递归的JAVA实现

归并排序介绍

平均时间复杂度： O(NLogN)

最好情况时间复杂度： O(NLogN)

最差情况时间复杂度： O(NLogN)

所需要额外空间： 递归：O(N + LogN)， 非递归：O(N)

稳定性： 稳定

归并排序基于分治(快排也是)，利用归并来实现排序，其基本思想是：

如果一个数组有n个数据，则可以把这个数组看作n个有序的子序列，每个子序列的长度为1，然后两两归并，就能得到[n/2]个长度为2(或者1，落单的)的字序列，再不断地两两归并，直到得到一个长度为n的有序数组。

这里选择Merge就能比较直观地看到归并排序的过程。

使用递归的归并排序

理解这个基本思想后，就不难写出归并排序的代码，只要递归地进行归并就行了.

其中归并函数merge也很好理解，就是合并两个有序数组为一个有序数组即可。

package com.yenghye.sort;

public class Sort {

public static void MergeSort(int[] arr, int low, int high)

{

//使用递归的方式进行归并排序，所需要的空间复杂度是O(N+logN)

int mid = (low + high)/2;

if(low < high)

{

//递归地对左右两边进行排序

MergeSort(arr, low, mid);

MergeSort(arr, mid+1, high);

//合并

merge(arr, low, mid, high);

}

}

//merge函数实际上是将两个有序数组合并成一个有序数组

//因为数组有序，合并很简单，只要维护几个指针就可以了

private static void merge(int[] arr, int low, int mid, int high)

{

//temp数组用于暂存合并的结果

int[] temp = new int[high - low + 1];

//左半边的指针

int i = low;

//右半边的指针

int j = mid+1;

//合并后数组的指针

int k = 0;

//将记录由小到大地放进temp数组

for(; i <= mid && j <= high; k++)

{

if(arr[i] < arr[j])

temp[k] = arr[i++];

else

temp[k] = arr[j++];

}

//接下来两个while循环是为了将剩余的(比另一边多出来的个数)放到temp数组中

while(i <= mid)

temp[k++] = arr[i++];

while(j <= high)

temp[k++] = arr[j++];

//将temp数组中的元素写入到待排数组中

for(int l = 0; l < temp.length; l++)

arr[low + l] = temp[l];

}

}

归并排序的优化(非递归归并排序)

但是,使用递归的归并排序需要深度为LogN的栈空间，虽然代码很简单易懂，但是会造成时间和空间上的性能损耗，为了优化归并排序，我们可以使用迭代代替递归。

package com.yenghye.sort;

public class Sort {

public static void MergeSort2(int[] arr)

{

//使用非递归的方式来实现归并排序

int len = arr.length;

int k = 1;

while(k < len)

{

MergePass(arr, k, len);

k *= 2;

}

}

//MergePass方法负责将数组中的相邻的有k个元素的字序列进行归并

private static void MergePass(int[] arr, int k, int n)

{

int i = 0;

int j;

//从前往后,将2个长度为k的子序列合并为1个

while(i < n - 2*k + 1)

{

merge(arr, i, i + k-1, i + 2*k - 1);

i += 2*k;

}

//这段代码保证了，将那些“落单的”长度不足两两merge的部分和前面merge起来。

if(i < n - k )

{

merge(arr, i, i+k-1, n-1);

}

}

//merge函数实际上是将两个有序数组合并成一个有序数组

//因为数组有序，合并很简单，只要维护几个指针就可以了

private static void merge(int[] arr, int low, int mid, int high)

{

//temp数组用于暂存合并的结果

int[] temp = new int[high - low + 1];

//左半边的指针

int i = low;

//右半边的指针

int j = mid+1;

//合并后数组的指针

int k = 0;

//将记录由小到大地放进temp数组

for(; i <= mid && j <= high; k++)

{

if(arr[i] < arr[j])

temp[k] = arr[i++];

else

temp[k] = arr[j++];

}

//接下来两个while循环是为了将剩余的(比另一边多出来的个数)放到temp数组中

while(i <= mid)

temp[k++] = arr[i++];

while(j <= high)

temp[k++] = arr[j++];

//将temp数组中的元素写入到待排数组中

for(int l = 0; l < temp.length; l++)

arr[low + l] = temp[l];

}

}

非递归而是迭代的归并排序很直观，就是从前往后从最小的序列开始归并，直到完成即可。

但是这里边界条件不太好想，要注意不要出错。