基本思想
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):
pass
class 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),显然它不是就地排序。
排序稳定性
归并排序是一种稳定的排序。