基本思想
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实现,代码如下所示:
01 | public abstract class Sorter { |
02 | public abstract void sort( int [] array); |
03 | } |
04 |
05 | public class MergeSorter extends Sorter { |
06 |
07 | @Override |
08 | public void sort( int [] array) { |
09 | int [] auxArray = new int [array.length]; |
10 | mergeSort(array, auxArray, 0 , array.length - 1 ); |
11 | } |
12 |
13 | /** |
14 | * 基于分治思想,执行归并排序 |
15 | * @param low 待排序数组下标下界 |
16 | * @param high 待排序数组下标上界 |
17 | */ |
18 | private void mergeSort( int [] array, int [] auxArray, int low, int high) { |
19 | int dividedIndex = 0 ; // 分治位置索引变量 |
20 | if (low < high) { |
21 | dividedIndex = (low + high) / 2 ; // 计算分治位置(采用简单的二分思想) |
22 | mergeSort(array, auxArray, low, dividedIndex); // 左侧递归归并排序 |
23 | mergeSort(array, auxArray, dividedIndex + 1 , high); // 右侧递归归并排序 |
24 | merge(array, auxArray, low, dividedIndex, high); // 合并分治结果 |
25 | } |
26 | } |
27 |
28 | private void merge( int [] array, int [] auxArray, int low, int dividedIndex, int high) { |
29 | int i = low; // 指向左半分区数组的指针 |
30 | int j = dividedIndex + 1 ; // 指向右半分区数组的指针 |
31 | int auxPtr = 0 ; // 指向辅助区数组的指针 |
32 | // 合并两个有序数组:array[low..dividedIndex]与array[dividedIndex+1..high]。 |
33 | while (i <= dividedIndex && j <= high) { // 将两个有序的数组合并,排序到辅助数组auxArray中 |
34 | if (array[i] > array[j]) { // 左侧数组array[low..dividedIndex]中的array[i]大于右侧数组array[dividedIndex+1..high]中的array[j] |
35 | auxArray[auxPtr++] = array[j++]; |
36 | } else { |
37 | auxArray[auxPtr++] = array[i++]; |
38 | } |
39 | } |
40 | // 如果array[low..dividedIndex].length>array[dividedIndex+1..high].length,经过上面合并 |
41 | // array[low..dividedIndex]没有合并完,则直接将array[low..dividedIndex]中没有合并的元素复制到辅助数组auxArray中去 |
42 | while (i <= dividedIndex) { |
43 | auxArray[auxPtr++] = array[i++]; |
44 | } |
45 | // 如果array[low..dividedIndex].length<array[dividedIndex+1..high].length,经过上面合并 |
46 | // array[dividedIndex+1..high]没有合并完,则直接将array[dividedIndex+1..high]中没有合并的元素复制到辅助数组auxArray中去 |
47 | while (j <= high) { |
48 | auxArray[auxPtr++] = array[j++]; |
49 | } |
50 | // 最后把辅助数组auxArray的元素复制到原来的数组中去,归并排序结束 |
51 | for (auxPtr = 0 , i = low; i <= high; i++, auxPtr++) { |
52 | array[i] = auxArray[auxPtr]; |
53 | } |
54 | } |
55 | } |
归并排序算法,Python实现,代码如下所示:
01 | class Sorter: |
02 | ''' |
03 | Abstract sorter class, which provides shared methods being used by |
04 | subclasses. |
05 | ''' |
06 | __metaclass__ = ABCMeta |
07 | |
08 | @abstractmethod |
09 | def sort( self , array): |
10 | pass |
11 |
12 | class MergeSorter(Sorter): |
13 | ''' |
14 | Merge sorter |
15 | ''' |
16 | |
17 | def sort( self , array): |
18 | length = len (array) |
19 | # initialize auxiliary list |
20 | auxiliary_list = [ 0 for x in range (length)] |
21 | self .__merge_sort(array, auxiliary_list, 0 , length - 1 ) |
22 | |
23 | def __merge_sort( self , array, auxiliary_list, low, high): |
24 | dividedIndex = 0 |
25 | if low<high: |
26 | dividedIndex = (low + high) / / 2 |
27 | self .__merge_sort(array, auxiliary_list, low, dividedIndex) |
28 | self .__merge_sort(array, auxiliary_list, dividedIndex + 1 , high) |
29 | self .__merge(array, auxiliary_list, low, dividedIndex, high) |
30 | |
31 | def __merge( self , array, auxiliary_list, low, dividedIndex, high): |
32 | i = low |
33 | j = dividedIndex + 1 |
34 | pointer = 0 |
35 | while i< = dividedIndex and j< = high: |
36 | if array[i]>array[j]: |
37 | auxiliary_list[pointer] = array[j] |
38 | j = j + 1 |
39 | else : |
40 | auxiliary_list[pointer] = array[i] |
41 | i = i + 1 |
42 | pointer = pointer + 1 |
43 | while i< = dividedIndex: |
44 | auxiliary_list[pointer] = array[i] |
45 | pointer = pointer + 1 |
46 | i = i + 1 |
47 | while j< = high: |
48 | auxiliary_list[pointer] = array[j] |
49 | pointer = pointer + 1 |
50 | j = j + 1 |
51 | # copy elements in auxiliary list to the original list |
52 | pointer = 0 |
53 | i = low |
54 | while i< = high: |
55 | array[i] = auxiliary_list[pointer] |
56 | i = i + 1 |
57 | 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,我们以该数组为例,执行归并排序的具体过程,如下所示:
01 | [94,12,34,76,26,9,0,37,55,76, 37,5,68,83,90,37,12,65,76,49] |
02 | [94,12,34,76,26, 9,0,37,55,76] |
03 | [94,12,34, 76,26] |
04 | [94,12, 34] |
05 | [94, 12] |
06 | {12, 94} |
07 | {12,34, 94} |
08 | [76, 26] |
09 | {26, 76} |
10 | {12,26,34, 76,94} |
11 | [9,0,37, 55,76] |
12 | [9,0, 37] |
13 | [9, 0] |
14 | {0, 9} |
15 | {0,9, 37} |
16 | [55, 76] |
17 | {55, 76} |
18 | {0,9,37, 55,76} |
19 | {0,9,12,26,34, 37,55,76,76,94} |
20 | [37,5,68,83,90, 37,12,65,76,49] |
21 | [37,5,68, 83,90] |
22 | [37,5, 68] |
23 | [37, 5] |
24 | {5, 37} |
25 | {5,37, 68} |
26 | [83, 90] |
27 | {83, 90} |
28 | {5,37,68, 83,90} |
29 | [37,12,65, 76,49] |
30 | [37,12, 65] |
31 | [37, 12 ] |
32 | {12, 37 } |
33 | {12,37, 65 } |
34 | [76, 49 ] |
35 | {49, 76} |
36 | {12,37,49, 65,76} |
37 | {5,12,37,37,49, 65,68,76,83,90} |
38 | {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),显然它不是就地排序。
- 排序稳定性
归并排序是一种稳定的排序。