排序
- 排序:把某个乱序的数组变成升序或降序的数组 (这里用数组来做举例)
桶排序
- 根据元素的取值范围,创建多个桶, 每个桶代表一个区间范围
- 创建桶的数量和范围需要尽可能保证元素能够被均匀分布
- 接下来将元素放进对应的桶中,分别对每个桶中的元素进行排序
- 桶内采用的排序算法可自行决定
- 均匀分布后,每个桶内元素数量不会很多
- 最后,按顺序将桶里的元素取出就完成了排序
- 桶排序用的并不多,主要体现在对于桶排序的应用: 计数排序和基数排序
- 核心思想
- 基于最小值和最大值算出一个差值,基于差值确定桶的数量和范围
- 之后遍历数组中的每个元素,来分配到不同的桶中
- 对每一个桶进行单独的排序
- 最后整合所有的桶,即可
Typescript 版算法实现
1 )定义桶数,均匀分布
// 获取当前在第几个桶里
function getIndex(period: number, currentDist: number) {
if (currentDist <= period) return 0;
return Math.floor(currentDist / period);
}
// 桶排序 主函数 list 待排序数组, n是定义的桶数量
function bucketSort(list: number[], n: number = 2) {
// 计算最大值和最小值
const max: number = Math.max.apply(null, list);
const min: number = Math.min.apply(null, list);
const dist: number = max - min; // 最大值和最小值两者差距
let buckets: number[][] = []; // 用于存放多个桶的总数组
// n个桶, 每个桶内存放范围 dist / n 每个桶的间隔
const period: number = Math.ceil(dist / n);
// 将列表中的数据分配到不同的桶里
list.forEach((current: number) => {
const d: number = current - min; // 当前与最小值的差距,用于计算当前数据应该填充在哪个桶内
const index: number = getIndex(period, d); // 基于桶数和当前值,算出应该存放到第几个桶内
// 基于 index 来填充到对应的桶内
!buckets[index] ? (buckets[index] = [current]) : buckets[index].push(current);
});
// 对 buckets 中的每个桶进行排序
buckets = buckets.map((bucket: number[]) => {
bucket.sort((a: number, b: number) => a - b); // 这个使用默认的排序,其实内部可以使用任意的排序算法
return bucket;
});
// 对 buckets 中的每个桶进行合并 (拍平)
/*
const result = buckets.toString().split(',');
return result.map(item => Number(item));
*/
// 可能桶内存在空元素的桶被过滤掉,之后拍平处理
const result = buckets.filter(bucket => bucket).flat();
return result;
}
const list = [102, 103, 108, 107, 101, 102, 102, 102, 107, 103, 109, 108, 102, 101, 104, 102, 104, 106, 109, 102];
const result = bucketSort(list, 5);
console.log(result); // [101, 101, 102, 102, 102, 102, 102, 102, 102, 103, 103, 104, 104, 106, 107, 107, 108, 108, 109, 109]
Python3 版算法实现
1 ) 方案1
def get_index(period, current_dist):
if current_dist <= period:
return 0
return current_dist // period
def bucket_sort(lst, n=2):
if len(lst) < 2:
return lst
# 计算最大值和最小值
max_val = max(lst)
min_val = min(lst)
dist = max_val - min_val # 最大值和最小值的差距
if dist == 0:
return lst # 如果所有元素都相同,直接返回
# 初始化桶数组,确保有足够的桶
buckets = [[] for _ in range(n)]
# 计算每个桶的间隔
period = (dist + 1) // n
# 将列表中的数据分配到不同的桶里
for current in lst:
d = current - min_val # 当前与最小值的差距
index = get_index(period, d) # 基于桶数和当前值,算出应该存放到第几个桶内
if index >= n:
index = n - 1 # 确保索引不超过桶数组的范围
buckets[index].append(current)
# 对 buckets 中的每个桶进行排序
for bucket in buckets:
bucket.sort() # 可以使用任意的排序算法
# 对 buckets 中的每个桶进行合并 (拍平)
result = [item for sublist in buckets for item in sublist]
return result
def test_bucket_sort():
test_cases = [
[102, 103, 108, 107, 101, 102, 102, 102, 107, 103, 109, 108, 102, 101, 104, 102, 104, 106, 109, 102], # 一般情况
[5, 4, 3, 2, 1], # 逆序
[1, 2, 3, 4, 5], # 已经有序
[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5], # 随机顺序
[], # 空数组
[1], # 单元素数组
[-2, 1, 0, -9, 1, 3, 9, 99, 9, -30, -100, 100, 88, 88, 20, 1, 0, 3, 4, 5, -20], # 复杂情况
]
for test_case in test_cases:
copy_list = test_case[:]
sorted_list = bucket_sort(copy_list, 5)
print(f"Original: {test_case}, Sorted: {sorted_list}")
if __name__ == "__main__":
test_bucket_sort()
Golang 版算法实现
1 ) 方案1
package main
import (
"fmt"
"math"
"sort"
)
// 获取当前在第几个桶里
func getIndex(period int, currentDist int) int {
if currentDist <= period {
return 0
}
return currentDist / period
}
// 桶排序 主函数 list 待排序数组, n是定义的桶数量
func bucketSort(list []int, n int) []int {
if len(list) < 2 {
return list
}
// 计算最大值和最小值
maxVal := list[0]
minVal := list[0]
for _, num := range list {
if num > maxVal {
maxVal = num
}
if num < minVal {
minVal = num
}
}
dist := maxVal - minVal // 最大值和最小值的差距
if dist == 0 {
return list // 如果所有元素都相同,直接返回
}
// 初始化桶数组,确保有足够的桶
buckets := make([][]int, n)
// 计算每个桶的间隔
period := int(math.Ceil(float64(dist) / float64(n)))
// 将列表中的数据分配到不同的桶里
for _, current := range list {
d := current - minVal // 当前与最小值的差距
index := getIndex(period, d) // 基于桶数和当前值,算出应该存放到第几个桶内
if index >= n {
index = n - 1 // 确保索引不超过桶数组的范围
}
buckets[index] = append(buckets[index], current)
}
// 对 buckets 中的每个桶进行排序
for _, bucket := range buckets {
sort.Ints(bucket) // 可以使用任意的排序算法
}
// 对 buckets 中的每个桶进行合并 (拍平)
var result []int
for _, bucket := range buckets {
result = append(result, bucket...)
}
return result
}
func testBucketSort() {
testCases := [][]int{
{102, 103, 108, 107, 101, 102, 102, 102, 107, 103, 109, 108, 102, 101, 104, 102, 104, 106, 109, 102}, // 一般情况
{5, 4, 3, 2, 1}, // 逆序
{1, 2, 3, 4, 5}, // 已经有序
{3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}, // 随机顺序
{}, // 空数组
{1}, // 单元素数组
{-2, 1, 0, -9, 1, 3, 9, 99, 9, -30, -100, 100, 88, 88, 20, 1, 0, 3, 4, 5, -20}, // 复杂情况
}
for _, testCase := range testCases {
copyList := make([]int, len(testCase))
copy(copyList, testCase)
sortedList := bucketSort(copyList, 5)
fmt.Printf("Original: %v, Sorted: %v\n", testCase, sortedList)
}
}
func main() {
testBucketSort()
}
总结
- 桶排序的时间复杂度 在 O(n) ~ O(n2n^2n2)
- 普通桶排序并不普遍应用是拆分为桶后,在每个桶内还需要排序,意义就不大了
- 而且要考虑每个桶内用什么样的数据结构来存储(考虑到内部排序)
- 如果还用数组就极大浪费了空间(需使用最大的空间, 不同语言有区别)
- 一般可以使用链表,但是对链表排序又开始麻烦了
- 桶排序优化空间,时间上就会增加;优化时间空间上又会增多, 取一个时间和空间的平衡
- 而且要考虑每个桶内用什么样的数据结构来存储(考虑到内部排序)
- buckets.map 基本是常数级别,这里实际上不怎么会消耗时间, 具体的sort算法可以使用任意的排序算法实现
- 关于怎么处理和分配桶,上述算法基于用户自行填入的桶数,来均匀处理, 也可传入所有桶的范围分布列表
- 那算法的细节实现就会不一样,但基本思想是一致的
- 虽然上述算法意义不大, 但是桶排序的意义在于其思想:分而治之, 分配处理, 桶作为基本单位
- 这个桶排序算法在开发中是比较重要的一种思想
1477



被折叠的 条评论
为什么被折叠?



