第二十章 Caché 算法与数据结构 归并排序

第二十章 Caché 算法与数据结构 归并排序

思想

归并排序通过不断的将原数组进行拆分(通常拆分成左右两项)，一直到剩下一项，然后分别将拆分的子数组进行合并，此时，两个子数组已经是排好序的，所以合并排序只需要进行一趟排序即可完成，所以此类排序需要两个步骤：

1. 拆分原数组

• 利用递归，不断得寻找左子数组和右子数组，一直到数组的长度为一

2. 合并子数组。因此此算法是经典的分治算法。

• 每次合并需要子数组A,B，并新创建一个临时数组C，同时需要三个计数器Actr，Bctr和Cctr，其中Actr和Bctr用来判断数组是否用完，如果用完，则将剩余的数组元素按顺序放入临时数组中。全部放完后，将临时数组中的已经排好顺序的元素更新到原数组中。

时间复杂度

归并排序的最坏时间复杂度和平均时间复杂度均为O(nlogn)

归并排序的应用

归并排序是所有流行的排序算法中比较次数最少的排序算法，在Java类库中的泛型排序就是使用的归并排序(因为泛型类的比较所消耗的时间占比更多),而对于Java类库中的基本类型排序则是使用的快速排序算法

算法描述

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

• 把长度为n的输入序列分成两个长度为n/2的子序列；
• 对这两个子序列分别采用归并排序；
• 将两个排序好的子序列合并成一个最终的排序序列。

完整示例

并归类

Class PHA.YX.Arithmetic.MergeSort Extends %RegisteredObject
{

Method mergeSort(array As PHA.YX.Arithmetic.Array)
{
	s array =  ..sort(array, 0, array.length() - 1)
	q array
}

Method sort(array As PHA.YX.Arithmetic.Array, left As %Integer, right As %Integer)
{
	#dim mid = (left + right) \ 2
	q:(left >= right) array
	s array = ..sort(array, left, mid)
	s array = ..sort(array, mid + 1, right)
	s array = ..merge(array, left, mid , right)
	q array
}

Method merge(array As PHA.YX.Arithmetic.Array, left As %Integer, mid As %Integer, right As %Integer)
{
	d array.output()
	#dim Actr as %Integer = left
	#dim Bctr as %Integer = mid + 1
	#dim Cctr as %Integer = 0
	#dim tmp As PHA.YX.Arithmetic.Array = ##class(PHA.YX.Arithmetic.Array).%New()
	d tmp.init(right - left + 1)
	while ((Actr <= mid) && (Bctr <= right)){
		w "Actr:" _ Actr _ " mid：" _ mid _" Bctr:" _ Bctr _ " right：" _ right,!
		if (array.get(Actr) <= array.get(Bctr)){
			d tmp.set(Cctr, array.get(Actr))
			s Cctr = Cctr +1
			s Actr = Actr +1
		}else{
			d tmp.set(Cctr, array.get(Bctr))
			s Cctr = Cctr +1
			s Bctr = Bctr +1		
		}
	}
	while(Actr <= mid){
		d tmp.set(Cctr, array.get(Actr))
		s Cctr = Cctr +1
		s Actr = Actr +1
	}
	while(Bctr <= right){
		d tmp.set(Cctr, array.get(Bctr))
		s Cctr = Cctr +1
		s Bctr = Bctr +1
	}
	for i = 0 : 1 : tmp.length() - 1{
		
		d array.set(left,tmp.get(i))
		s left = left + 1
	}
	q array
}

}

调用

/// w ##class(PHA.YX.Arithmetic).MergeSort()
ClassMethod MergeSort()
{
	#dim array as PHA.YX.Arithmetic.Array = ##class(PHA.YX.Arithmetic.Array).%New()
	d array.init(8)
	d array.insert(0,52)
	d array.insert(1,63)
	d array.insert(2,14)
	d array.insert(3,59)
	d array.insert(4,68)
	d array.insert(5,35)
	d array.insert(6,67)
	d array.insert(7,99)
	
	#dim sort as PHA.YX.Arithmetic.MergeSort = ##class(PHA.YX.Arithmetic.MergeSort).%New() 
	s array = sort.mergeSort(array)
	
	d array.output()
	
	q ""
}

输出

DHC-APP> w ##class(PHA.YX.Arithmetic).MergeSort()
52
63
14
59
68
35
67
99
 
Actr:0 mid：0 Bctr:1 right：1
52
63
14
59
68
35
67
99
 
Actr:2 mid：2 Bctr:3 right：3
52
63
14
59
68
35
67
99
 
Actr:0 mid：1 Bctr:2 right：3
Actr:0 mid：1 Bctr:3 right：3
Actr:1 mid：1 Bctr:3 right：3
14
52
59
63
68
35
67
99
 
Actr:4 mid：4 Bctr:5 right：5
14
52
59
63
35
68
67
99
 
Actr:6 mid：6 Bctr:7 right：7
14
52
59
63
35
68
67
99
 
Actr:4 mid：5 Bctr:6 right：7
Actr:5 mid：5 Bctr:6 right：7
Actr:5 mid：5 Bctr:7 right：7
14
52
59
63
35
67
68
99
 
Actr:0 mid：3 Bctr:4 right：7
Actr:1 mid：3 Bctr:4 right：7
Actr:1 mid：3 Bctr:5 right：7
Actr:2 mid：3 Bctr:5 right：7
Actr:3 mid：3 Bctr:5 right：7
14
35
52
59
63
67
68
99