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

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

桶排序

1. 桶排序是稳定的。
2. 桶排序是常见排序算法中最快的一种，大多数情况下比快排和归并排序还要快。
3. 桶排序非常快但是也非常消耗空间，典型的以空间换时间，基本上是最耗内存的一种排序算法。

步骤

桶排序中：无序数组有个要求,就是成员隶属于固定(有限的)的区间,如范围为0-9

例如待排数字[6 2 4 1 5 9]

准备10个空桶,最大数个空桶

[6 2 4 1 5 9] 待排数组

[0 0 0 0 0 0 0 0 0 0] 空桶

[0 1 2 3 4 5 6 7 8 9] 桶编号(实际不存在)

1. 顺序从待排数组中取出数字,首先6被取出,然后把6入6号桶,这个过程类似这样:空桶[ 待排数组[ 0 ] ] = 待排数组[ 0 ]

[6 2 4 1 5 9] 待排数组

[0 0 0 0 0 0 6 0 0 0] 空桶

[0 1 2 3 4 5 6 7 8 9] 桶编号(实际不存在)

2.顺序从待排数组中取出下一个数字,此时2被取出,将其放入2号桶,是几就放几号桶

[6 2 4 1 5 9] 待排数组

[0 0 2 0 0 0 6 0 0 0] 空桶

[0 1 2 3 4 5 6 7 8 9] 桶编号(实际不存在)

3. 剩余步骤，重复，全部入桶后变成下边这样

[6 2 4 1 5 9] 待排数组

[0 1 2 0 4 5 6 0 0 9] 空桶

[0 1 2 3 4 5 6 7 8 9] 桶编号(实际不存在)

4. 0表示空桶,跳过,顺序取出即可:1 2 4 5 6 9

时间复杂度

时间复杂度为O(n+m)

完整示例

桶类

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

Property bucket As PHA.YX.Arithmetic.Array;

Method sort(array As PHA.YX.Arithmetic.Array)
{
	/* 得到数列的最大值和最小值 */
	#dim max as %Decimal = array.get(0)
	#dim min as %Decimal = array.get(0)
	for i = 1 : 1 : (array.length() - 1) {
		if (array.get(i) > max){
			s max = array.get(i)
		}
		if (array.get(i) < min){
			s min = array.get(i)
		}
	}
	
	/* 算出需要开辟多少个空间 */
	s ..bucket = ##class(PHA.YX.Arithmetic.Array).%New()
	d ..bucket.init(max - min + 1)
	w "max - min + 1:" _ (max - min + 1),!
	for i = 0 : 1 : array.length() - 1 {
		s ele = array.get(i)
		s bucktet = ..bucket.get(ele)
		w "ele：" _ ele _ " bucktet:" _ bucktet,!
		d ..bucket.set(ele, bucktet + 1)
	}
	

	
	q ..bucket
}

}

调用

/// w ##class(PHA.YX.Arithmetic).BucketSort()
ClassMethod BucketSort()
{
	#dim array as PHA.YX.Arithmetic.Array = ##class(PHA.YX.Arithmetic.Array).%New()
	d array.init(8)
	d array.insert(0,3)
	d array.insert(1,1)
	d array.insert(2,5)
	d array.insert(3,9)
	d array.insert(4,6)
	d array.insert(5,5)
	d array.insert(6,0)
	d array.insert(7,10)	
	#dim sort as PHA.YX.Arithmetic.BucketSort = ##class(PHA.YX.Arithmetic.BucketSort).%New() 
	s array = sort.sort(array)
	
	/* 遍历桶，并得到每个桶中数n，并输出n次该桶下标 */
	for i = 0 : 1 : array.length() {
		for j = 0 : 1 : array.get(i) - 1{
			w i,!
		}
	}

	q ""
}

DHC-APP>w ##class(PHA.YX.Arithmetic).BucketSort()
max - min + 1:11
ele：3 bucktet:
ele：1 bucktet:
ele：5 bucktet:
ele：9 bucktet:
ele：6 bucktet:
ele：5 bucktet:1
ele：0 bucktet:
ele：10 bucktet:
0
1
3
5
5
6
9
10