内部排序算法:归并排序
来源:互联网 发布:智能时代的数据化企业 编辑:程序博客网 时间:2024/05/18 03:13
基本思想
n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果:
初始状态:无序区为R[1..n],有序区为空。
第1趟排序: 在无序区R[1..n]中选出关键字最小的记录R[k],将它与无序区的第1个记录R[1] 交换,使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
……
第i趟排序: 第i趟排序开始时,当前有序区和无序区分别为R[1..i-1]和R[i..n](1≤i≤n-1)。 该趟排序从当前无序区中选出关键字最小的记录R[k],将它与无序区的第1个记录R[i]交换,使R[1..i] 和R[i+1..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
这样,n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。
算法实现
归并排序算法,Python实现,代码如下所示:
排序过程
假设待排序数组为array = {94,12,34,76,26,9,0,37,55,76,37,5,68,83,90,37,12,65,76,49},数组大小为20,我们以该数组为例,执行归并排序的具体过程,如下所示:
算法分析
时间复杂度
对长度为n的文件,需进行FLOOR(logn) 趟二路归并,每趟归并的时间为O(n),故其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlgn)。
空间复杂度
需要一个辅助向量来暂存两有序子文件归并的结果,故其辅助空间复杂度为O(n),显然它不是就地排序。
排序稳定性
归并排序是一种稳定的排序。
n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果:
初始状态:无序区为R[1..n],有序区为空。
第1趟排序: 在无序区R[1..n]中选出关键字最小的记录R[k],将它与无序区的第1个记录R[1] 交换,使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
……
第i趟排序: 第i趟排序开始时,当前有序区和无序区分别为R[1..i-1]和R[i..n](1≤i≤n-1)。 该趟排序从当前无序区中选出关键字最小的记录R[k],将它与无序区的第1个记录R[i]交换,使R[1..i] 和R[i+1..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
这样,n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。
算法实现
归并排序算法,Java实现,代码如下所示:
public abstract class Sorter { public abstract void sort(int[] array);}public class MergeSorter extends Sorter { @Override public void sort(int[] array) { int[] auxArray = new int[array.length]; mergeSort(array, auxArray, 0, array.length - 1); } /** * 基于分治思想,执行归并排序 * @param low 待排序数组下标下界 * @param high 待排序数组下标上界 */ private void mergeSort(int[] array, int[] auxArray, int low, int high) { int dividedIndex = 0; // 分治位置索引变量 if (low < high) { dividedIndex = (low + high) / 2; // 计算分治位置(采用简单的二分思想) mergeSort(array, auxArray, low, dividedIndex); // 左侧递归归并排序 mergeSort(array, auxArray, dividedIndex + 1, high); // 右侧递归归并排序 merge(array, auxArray, low, dividedIndex, high); // 合并分治结果 } } private void merge(int[] array, int[] auxArray, int low, int dividedIndex, int high) { int i = low; // 指向左半分区数组的指针 int j = dividedIndex + 1; // 指向右半分区数组的指针 int auxPtr = 0; // 指向辅助区数组的指针 // 合并两个有序数组:array[low..dividedIndex]与array[dividedIndex+1..high]。 while (i <= dividedIndex && j <= high) { // 将两个有序的数组合并,排序到辅助数组auxArray中 if (array[i] > array[j]) { // 左侧数组array[low..dividedIndex]中的array[i]大于右侧数组array[dividedIndex+1..high]中的array[j] auxArray[auxPtr++] = array[j++]; } else { auxArray[auxPtr++] = array[i++]; } } // 如果array[low..dividedIndex].length>array[dividedIndex+1..high].length,经过上面合并 // array[low..dividedIndex]没有合并完,则直接将array[low..dividedIndex]中没有合并的元素复制到辅助数组auxArray中去 while (i <= dividedIndex) { auxArray[auxPtr++] = array[i++]; } // 如果array[low..dividedIndex].length<array[dividedIndex+1..high].length,经过上面合并 // array[dividedIndex+1..high]没有合并完,则直接将array[dividedIndex+1..high]中没有合并的元素复制到辅助数组auxArray中去 while (j <= high) { auxArray[auxPtr++] = array[j++]; } // 最后把辅助数组auxArray的元素复制到原来的数组中去,归并排序结束 for (auxPtr = 0, i = low; i <= high; i++, auxPtr++) { array[i] = auxArray[auxPtr]; } }}
归并排序算法,Python实现,代码如下所示:
class Sorter: ''' Abstract sorter class, which provides shared methods being used by subclasses. ''' __metaclass__ = ABCMeta @abstractmethod def sort(self, array): passclass MergeSorter(Sorter): ''' Merge sorter ''' def sort(self, array): length = len(array) # initialize auxiliary list auxiliary_list = [0 for x in range(length)] self.__merge_sort(array, auxiliary_list, 0, length - 1) def __merge_sort(self, array, auxiliary_list, low, high): dividedIndex = 0 if low<high: dividedIndex = (low + high) // 2 self.__merge_sort(array, auxiliary_list, low, dividedIndex) self.__merge_sort(array, auxiliary_list, dividedIndex + 1, high) self.__merge(array, auxiliary_list, low, dividedIndex, high) def __merge(self, array, auxiliary_list, low, dividedIndex, high): i = low j = dividedIndex + 1 pointer = 0 while i<=dividedIndex and j<=high: if array[i]>array[j]: auxiliary_list[pointer] = array[j] j = j + 1 else: auxiliary_list[pointer] = array[i] i = i + 1 pointer = pointer + 1 while i<=dividedIndex: auxiliary_list[pointer] = array[i] pointer = pointer + 1 i = i + 1 while j<=high: auxiliary_list[pointer] = array[j] pointer = pointer + 1 j = j + 1 # copy elements in auxiliary list to the original list pointer = 0 i = low while i<=high: array[i] = auxiliary_list[pointer] i = i + 1 pointer = pointer + 1
排序过程
假设待排序数组为array = {94,12,34,76,26,9,0,37,55,76,37,5,68,83,90,37,12,65,76,49},数组大小为20,我们以该数组为例,执行归并排序的具体过程,如下所示:
[94,12,34,76,26,9,0,37,55,76, 37,5,68,83,90,37,12,65,76,49][94,12,34,76,26, 9,0,37,55,76][94,12,34, 76,26][94,12, 34][94, 12]{12, 94}{12,34, 94}[76, 26]{26, 76}{12,26,34, 76,94}[9,0,37, 55,76][9,0, 37][9, 0]{0, 9}{0,9, 37}[55, 76]{55, 76}{0,9,37, 55,76}{0,9,12,26,34, 37,55,76,76,94}[37,5,68,83,90, 37,12,65,76,49][37,5,68, 83,90][37,5, 68][37, 5]{5, 37}{5,37, 68}[83, 90]{83, 90}{5,37,68, 83,90}[37,12,65, 76,49][37,12, 65][37, 12 ]{12, 37 }{12,37, 65 }[76, 49 ]{49, 76}{12,37,49, 65,76}{5,12,37,37,49, 65,68,76,83,90}{0,5,9,12,12,26,34,37,37,37, 49,55,65,68,76,76,76,83,90,94}上面示例的排序过程中,方括号表示“分解”操作过程中,将原始数组进行递归分解,直到不能再继续分割为止;花括号表示“归并”的过程,将上一步分解后的数组进行归并排序。因为采用递归分治的策略,所以从上面的排序过程可以看到,“分解”和“归并”交叉出现。
算法分析
时间复杂度
对长度为n的文件,需进行FLOOR(logn) 趟二路归并,每趟归并的时间为O(n),故其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlgn)。
空间复杂度
需要一个辅助向量来暂存两有序子文件归并的结果,故其辅助空间复杂度为O(n),显然它不是就地排序。
排序稳定性
归并排序是一种稳定的排序。
阅读全文
0 0
- 内部排序算法:归并排序
- 图解"数据结构--内部排序算法"----归并排序
- 内部排序算法之归并排序
- 常用内部排序算法之一:归并排序
- 内部排序算法4(归并排序)
- 内部排序之归并排序
- 八大内部排序 -- 归并排序
- 内部排序—归并排序
- 内部排序之 归并排序
- Python实现经典内部排序算法(归并排序)
- 排序算法-归并排序
- 排序算法------归并排序
- 排序算法-归并排序
- 排序算法---归并排序
- 排序算法--归并排序
- 排序算法--归并排序
- 排序算法-归并排序
- 排序算法--归并排序
- window 习惯
- 一名3年工作经验的程序员应该具备的技能(写得很好,果断转)
- Fragment 的使用
- MyBatis 介绍
- slightPHP关于访问到控制器无任何显示、无任何返回的情况
- 内部排序算法:归并排序
- 【个人笔记重点,不作为参考】主题:angular2-jwt
- 不错的技术网站
- 数据库主主复制不起作用解决办法
- 常用数据结构-二叉树的链式存储、建立和遍历
- Istio介绍
- 关于Android 5.1限制外置SD卡写入权限的破解方法
- git图形化工具GitKraken的使用——初始化项目
- MFC ActiveX (ocx)控件的开发的一些注意点