拜托，别再问我桶排序了！！！

Posted 2021-04-13 程序员的进击之路

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了拜托，别再问我桶排序了！！！相关的知识，希望对你有一定的参考价值。

拜托，别再问我桶排序了！！！

桶排序（Bucket sort）或所谓的箱排序，是一个排序算法。

桶排序(Bucket sort),工作的原理是将数组分到有限数量的桶里。每个桶再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：

在额外空间充足的情况下，尽量增大桶的数量.
使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中.

主要思路

设置固定的空桶数目
将原始数组数据放到对应的空桶Bucket x中
将每个不为空的桶采用稳定排序算法进行排序
拼接不为空的桶中的数据，就可以得到最终的结果了

关键步骤

扫描待排序数据A[N]，对于元素A[i]，放入对应的桶X
A[i]放入桶X，如果桶X已经有了若干元素，可以使用插入排序，将arr[i]放到桶内合适的位置

详细步骤

设置一个定量桶的个数BucketNum，并使用这个数初始化一个数组，元素的类型可以是链表或者数组。
计算出待排序数组的最大值Max和最小值Min
使用最大值减去最小数除以桶的个数并向上求整，得到划分区间的divider( 即(Max-Min+1)/BucketNum)
遍历待排序数组，取每个元素除以divider并向下取整，放入对应的桶里面
遍历桶数组，对每个桶进行排序，这里排序算法不限，可以采用计数排序，快排，插入都可以。
最终顺序合并每个桶数组，便得到整体有序的数组。

过程描述

假设一组数据(20长度)为:

[63,157,189,51,101,47,141,121,157,156,194,117,98,139,67,133,181,13,28,109]

现在需要按5个分桶，进行桶排序，实现步骤如下:

找到数组中的最大值194和最小值13，然后根据桶数为5，计算出每个桶中的数据范围为(194-13+1)/5=36.4
遍历原始数据，(以第一个数据63为例)先找到该数据对应的桶序列Math.floor(63 - 13) / 36.4) =1，然后将该数据放入序列为1的桶中(从0开始算)
当向同一个序列的桶中第二次插入数据时，判断桶中已存在的数字与新插入的数字的大小，按从左到右，从小打大的顺序插入。如第一个桶已经有了63，再插入51，67后，桶中的排序为(51,63,67) 一般通过链表来存放桶中数据,当然也可以使用数组
全部数据装桶完毕后，按序列，从小到大合并所有非空的桶(如0,1,2,3,4桶)
合并完之后就是已经排完序的数据

实现

伪代码

bucketSort(array[]){ 
     for i =1 to len(array){ 
        将array[i]放入对应的桶B[X]; 
     } 
     for i= 1 to len(Bucket){
        采用某种排序算法,对该桶内元素进行排序  
     }
     将B[X]中的所有元素，按顺序合并，排序完毕; 
}

代码实现

桶采用数组的实现方式

下面是我的实现代码:

package sort

import (
 "fmt"
 "math"
)

// 遍历一次获取一个数组中的最大值和最小值
func getMaxAndMin(array []int) (max int, min int) {
 max = array[0]
 min = array[0]
 for _, v := range array {
  if v > max {
   max = v
  }
  if v < min {
   min = v
  }
 }
 return
}

// 采用数组实现
func BucketSort(array []int) {
 arrayLen := len(array)
 if arrayLen < 1 {
  return
 }

 // 设置桶数量
 bucketNum := 5
 bucketArray := make([][]int, bucketNum)

 //获取数组的最大值和最小值
 max, min := getMaxAndMin(array)
 if max == min {
  return
 }
 // 计算出每个桶的值区间大小,记得+1
 bucketSpace := float64(max-min+1) / float64(bucketNum)
 // 遍历原始数组,按范围把数组元素一次放入对应的桶中
 for _, v := range array {
  // 向下取整
  bucketId := int(math.Floor((float64)(v-min) / float64(bucketSpace)))
  bucketArray[bucketId] = append(bucketArray[bucketId], v)
 }

 //对每个桶采用排序算法进行排序,并且合并
 var sortArray = make([]int, 0)
 for index, bucket := range bucketArray {
  // 这里我们采用插入排序算法
  InsertSort(bucket)
  sortArray = append(sortArray, bucket...)
 }
 //替换原数组
 copy(array, sortArray)
 return
}

桶采用链表的实现方式

下面是我实现的代码:

package sort

import (
 "fmt"
 "math"
)

// 遍历一次获取一个数组中的最大值和最小值
func getMaxAndMin(array []int) (max int, min int) {
 max = array[0]
 min = array[0]
 for _, v := range array {
  if v > max {
   max = v
  }
  if v < min {
   min = v
  }
 }
 return
}

// 桶采用链表实现
func BucketSort1(array []int) {
 arrayLen := len(array)
 if arrayLen < 1 {
  return
 }
 // 设置桶数量,并且初始化每个桶
 bucketNum := 5
 bucketArray := make([]*LinkNode, bucketNum)
 for i := 0; i < bucketNum; i++ {
  bucketArray[i] = &LinkNode{} //初始化头指针
 }

 //获取数组的最大值和最小值
 max, min := getMaxAndMin(array)
 if max == min {
  return
 }
 // 计算出每个桶的值区间大小,记得+1
 bucketSpace := float64(max-min+1) / float64(bucketNum)
 // 遍历原始数组,按范围把数组元素一次放入对应的桶中
 for _, v := range array {
  // 向下取整
  bucketId := int(math.Floor((float64)(v-min) / float64(bucketSpace)))
  linkHead := bucketArray[bucketId] //取出链表头指针
  curNode := linkHead.Next
  curNodePreNode := linkHead
  if linkHead.Next == nil {
   linkHead.Next = &LinkNode{Data: v}
   continue
  }
  //遍历进行比较并插入
  var find = false
  for curNode != nil {
   if v >= curNode.Data {
    curNodePreNode = curNode
    curNode = curNode.Next
    continue
   }
   newNode := &LinkNode{Data: v}
   curNodePreNode.Next = newNode
   newNode.Next = curNode
   find = true
   break
  }
  if !find {
   curNodePreNode.Next = &LinkNode{Data: v}
  }
 }

 //合并桶
 var sortArray = make([]int, 0)
 for _, bucketLink := range bucketArray {
  var tmp []int
  // 遍历链表
  curNode := bucketLink.Next
  for curNode != nil {
   tmp = append(tmp, curNode.Data)
   curNode = curNode.Next
  }
  //fmt.Printf("bucketId:%v | array is:%v\n", bucketId, tmp)
  sortArray = append(sortArray, tmp...)
 }
 copy(array, sortArray)
 return
}