println!("bucketSort1 with negative numbers:");

if arr.len() <= 1 {

println!("{:?}", arr);

return arr.clone();

}

// 第一步：计算数组最大值和最小值（取绝对值）

let mut max = arr[0];

let mut min = arr[0];

for &item in arr.iter() {

if item.abs() > max.abs() {

max = item;

}

if item.abs() < min.abs() {

min = item;

}

}

// 第二步：计算桶的数量和大小

let min_abs = if min.abs() == 0 { 1 } else { min.abs() }; // 防止除零

let bucket_count = (max.abs() - min_abs) / min_abs + 2; // +2是为了包含负数桶

let bucket_size = min_abs;

// 第三步：初始化桶

let mut buckets: Vec<Vec<i32>> = Vec::with_capacity(bucket_count as usize);

for _ in 0..bucket_count {

buckets.push(Vec::new());

}

// 第四步：将元素分配到对应桶中

for &item in arr.iter() {

let bucket_index = if item < 0 {

0 // 负数统一放在第1个桶

} else {

((item - min) / bucket_size + 1) as usize // 正数从第2个桶开始

};

// 边界检查

let bucket_index = bucket_index.min(buckets.len() - 1);

// 插入排序到桶中

let bucket = &mut buckets[bucket_index];

let pos = bucket.iter().position(|&x| x > item).unwrap_or(bucket.len());

bucket.insert(pos, item);

}

// 第五步：合并所有桶的元素

let mut output = Vec::new();

for bucket in buckets {

for item in bucket {

output.push(item);

}

}

println!("{:?}", output);

output

println!("bucketSort2 positive numbers only:");

if arr.len() <= 1 {

println!("{:?}", arr);

return arr.clone();

}

// 第一步：计算数组最大值和最小值

let mut max = arr[0];

let mut min = arr[0];

for &item in arr.iter() {

if item > max {

max = item;

}

if item < min {

min = item;

}

}

// 第二步：计算桶的数量和大小

let min_positive = if min <= 0 { 1 } else { min }; // 防止除零

let bucket_count = ((max - min_positive) / min_positive + 1) as usize;

let bucket_size = min_positive;

// 第三步：初始化桶

let mut buckets: Vec<Vec<i32>> = Vec::with_capacity(bucket_count);

for _ in 0..bucket_count {

buckets.push(Vec::new());

}

// 第四步：将元素分配到对应桶中

for &item in arr.iter() {

let mut bucket_index = if item < 0 {

0 // 负数统一放在第1个桶

} else {

((item - min_positive) / bucket_size + 1) as usize // 正数从第2个桶开始

};

// 边界检查

bucket_index = bucket_index.min(bucket_count - 1);

// 插入排序到桶中

let bucket = &mut buckets[bucket_index];

let pos = bucket.iter().position(|&x| x > item).unwrap_or(bucket.len());

bucket.insert(pos, item);

}

// 第五步：合并所有桶的元素

let mut output = Vec::new();

for bucket in buckets {

for item in bucket {

output.push(item);

}

}

println!("{:?}", output);

output

println!("bucketSort3 with move sorting:");

if arr.len() <= 1 {

println!("{:?}", arr);

return arr.clone();

}

// 第一步：计算数组最大值和最小值

let mut max = arr[0];

let mut min = arr[0];

for &item in arr.iter() {

if item > max {

max = item;

}

if item < min {

min = item;

}

}

// 第二步：计算桶的数量和大小

let bucket_count = arr.len(); // 桶数量等于数组长度

let bucket_size = (max - min) / bucket_count as i32 + 1;

// 第三步：初始化桶

let mut buckets: Vec<Vec<i32>> = Vec::with_capacity(bucket_count);

for _ in 0..bucket_count {

buckets.push(Vec::new());

}

// 第四步：将元素分配到对应桶中

for &item in arr.iter() {

let mut bucket_index = ((item - min) / bucket_size) as usize;

// 边界检查

bucket_index = bucket_index.min(bucket_count - 1);

// 挪动插入到桶中

let bucket = &mut buckets[bucket_index];

let pos = bucket.iter().position(|&x| x > item).unwrap_or(bucket.len());

bucket.insert(pos, item);

}

// 第五步：合并所有桶的元素

let mut output = Vec::new();

for bucket in buckets {

for item in bucket {

output.push(item);

}

}

println!("{:?}", output);

output

println!("bucketSort4 separate negative sorting:");

if arr.len() <= 1 {

println!("{:?}", arr);

return arr.clone();

}

// 第一步：分离正数和负数

let mut positive = Vec::new();

let mut negative = Vec::new();

for &item in arr.iter() {

if item >= 0 {

positive.push(item);

} else {

negative.push(-item); // 负数转为正数

}

}

// 第二步：分别排序正数和负数

if !positive.is_empty() {

positive = bucket_sort1(&mut positive);

}

if !negative.is_empty() {

negative = bucket_sort1(&mut negative);

}

// 第三步：合并结果（负数要逆序并还原符号）

let mut output = Vec::new();

for &item in negative.iter().rev() {

output.push(-item);

}

for &item in positive.iter() {

output.push(item);

}

println!("{:?}", output);

output

println!("bucketSort5 real-time bubble sorting:");

if arr.len() <= 1 {

println!("{:?}", arr);

return arr.clone();

}

// 第一步：计算数组最大值和最小值

let mut max = arr[0];

let mut min = arr[0];

for &item in arr.iter() {

if item > max {

max = item;

}

if item < min {

min = item;

}

}

// 第二步：计算桶的数量和大小

let min_positive = if min <= 0 { 1 } else { min }; // 防止除零

let bucket_count = ((max - min_positive) / min_positive + 1) as usize;

let bucket_size = min_positive;

// 第三步：初始化桶

let mut buckets: Vec<Vec<i32>> = Vec::with_capacity(bucket_count);

for _ in 0..bucket_count {

buckets.push(Vec::new());

}

// 第四步：将元素分配到对应桶中，实时冒泡排序

for &item in arr.iter() {

let mut bucket_index = if item < 0 {

0 // 负数统一放在第1个桶

} else {

((item - min_positive) / bucket_size + 1) as usize // 正数从第2个桶开始

};

// 边界检查

bucket_index = bucket_index.min(bucket_count - 1);

// 直接添加到桶末尾

let bucket = &mut buckets[bucket_index];

bucket.push(item);

// 实时冒泡排序

let mut j = bucket.len() - 1;

while j > 0 && bucket[j] < bucket[j - 1] {

bucket.swap(j, j - 1);

j -= 1;

}

}

// 第五步：合并所有桶的元素

let mut output = Vec::new();

for bucket in buckets {

for item in bucket {

output.push(item);

}

}

println!("{:?}", output);

output

println!("bucketSort6 original standard version:");

if arr.is_empty() {

println!("{:?}", arr);

return arr.clone();

}

let max_val = *arr.iter().max().unwrap();

let min_val = *arr.iter().min().unwrap();

let range = (max_val - min_val) as usize + 1;

// 创建桶

let mut buckets: Vec<Vec<i32>> = vec![Vec::new(); range];

// 将元素放入对应的桶中

for &item in arr.iter() {

let idx = (item - min_val) as usize;

buckets[idx].push(item);

}

// 对每个桶进行排序，并合并结果

let mut output = Vec::new();

for bucket in buckets.iter_mut() {

bucket.sort();

for &item in bucket.iter() {

output.push(item);

}

}

println!("{:?}", output);

output

println!("bucketSort7 original flag version:");

if arr.is_empty() || arr.len() == 0 {

println!("{:?}", arr);

return arr.clone();

}

let max_val = *arr.iter().max().unwrap();

let min_val = *arr.iter().min().unwrap();

let range = (max_val - min_val) as f64;

let bucket_size = (range / 5.0).ceil() as i32 + 1; // 使用5个桶

// 创建指定数量的桶

let mut buckets: Vec<Vec<i32>> = vec![Vec::new(); 5];

// 将元素放入对应的桶中

for &item in arr.iter() {

let mut idx = ((item - min_val) / bucket_size) as usize;

idx = idx.min(4); // 确保索引在0-4范围内

buckets[idx].push(item);

}

// 对每个桶进行排序，并合并结果

let mut output = Vec::new();

for bucket in buckets.iter_mut() {

bucket.sort();

for &item in bucket.iter() {

output.push(item);

}

}

println!("{:?}", output);

output

println!("=== 桶排序算法演示 ===\n");

println!("arrData origin: {:?}", test_data);

// 测试1: bucket_sort1

let start = Instant::now();

let result1 = bucket_sort1(&mut test_data.clone());

let elapsed1 = start.elapsed();

println!("bucketSort1: {:.3}ms", elapsed1.as_millis());

println!("排序结果: {:?}", result1);

println!("\n");

// 测试2: bucket_sort2

let start = Instant::now();

println!("arrData origin: {:?}", test_data);

let result2 = bucket_sort2(&mut test_data.clone());

let elapsed2 = start.elapsed();

println!("bucketSort2: {:.3}ms", elapsed2.as_millis());

println!("排序结果: {:?}", result2);

println!("\n");

// 测试3: bucket_sort3

let start = Instant::now();

println!("arrData origin: {:?}", test_data);

let result3 = bucket_sort3(&mut test_data.clone());

let elapsed3 = start.elapsed();

println!("bucketSort3: {:.3}ms", elapsed3.as_millis());

println!("排序结果: {:?}", result3);

println!("\n");

// 测试4: bucket_sort4

let start = Instant::now();

println!("arrData origin: {:?}", test_data);

let result4 = bucket_sort4(&mut test_data.clone());

let elapsed4 = start.elapsed();

println!("bucketSort4: {:.3}ms", elapsed4.as_millis());

println!("排序结果: {:?}", result4);

println!("\n");

// 测试5: bucket_sort5

let start = Instant::now();

println!("arrData origin: {:?}", test_data);

let result5 = bucket_sort5(&mut test_data.clone());

let elapsed5 = start.elapsed();

println!("bucketSort5: {:.3}ms", elapsed5.as_millis());

println!("排序结果: {:?}", result5);

println!("\n");

// 测试6: bucket_sort6

let start = Instant::now();

println!("arrData origin: {:?}", test_data);

let result6 = bucket_sort6(&mut test_data.clone());

let elapsed6 = start.elapsed();

println!("bucketSort6: {:.3}ms", elapsed6.as_millis());

println!("排序结果: {:?}", result6);

println!("\n");

// 测试7: bucket_sort7

let start = Instant::now();

println!("arrData origin: {:?}", test_data);

let result7 = bucket_sort7(&mut test_data.clone());

let elapsed7 = start.elapsed();

println!("bucketSort7: {:.3}ms", elapsed7.as_millis());

println!("排序结果: {:?}", result7);

println!("\n=== 算法对比总结 ===");

println!("1. 支持负数版本：bucketSort1 - 使用绝对值计算，负数统一处理");

println!("2. 正数专用版本：bucketSort2 - 桶分配精确，性能较好");

println!("3. 挪动排序版本：bucketSort3 - 使用挪动插入，保持排序稳定性");

println!("4. 负数单独版本：bucketSort4 - 负数单独优化，排序更精确");

println!("5. 实时冒泡版本：bucketSort5 - 插入即排序，实时保持有序");

println!("6. 原版标准版本：bucketSort6 - 原版标准桶排序实现，直接排序");

println!("7. 原版标志位版本：bucketSort7 - 原版标志位实现，固定桶数量");

let arr_data = vec![20, 11, 0, -10, 9, 6, 30, 15, 13, 80];

performance_test(&arr_data);