数据结构---桶排序

复习数据结构常见的排序时才发现以往都忽略了桶排序---这一非常巧妙的排序方法。桶排序有两个基本的特征：

1、待排序的数值应该是一个可枚举的范围（既是你不能对一个不可枚举范围的数值采用这种排序方法吧）；

2、待排序列所在的这个枚举范围不能太大，否则开销会很大。

 

 

例如待排数字[0 2 3 1 5 9]

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

[0 2 3 1 5 9]           待排数组

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

[0 1 2 3 4 5 6 7 8 9]   桶编号(假设编号)

 

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

[0 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]   桶编号(假设编号)

 

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

[0 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]   桶编号(假设编号)

 

4,1,5,9省略,过程一样,全部入桶后变成下边这样

[0 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]   桶编号(假设编号)

 

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

 

----------------------------------------------------------------------------------------------

import java.util.Arrays;

public class BucketSort {
 public static void buckSort(DataWrap [] data, int min,int max){
  System.out.println("排序开始：");
  //arrayLength记录待排序数组的长度
  int arrayLength = data.length;
  DataWrap [] tmp = new DataWrap[arrayLength];
  //buckets数组相当于定义了max-min个桶
  //buckets数组用于记录待排序元素的信息
  int [] buckets = new int[max - min];
  //计算每个元素在序列出现的次数
  for(int i = 0;i<arrayLength;i++){
   //buckets数组记录了DataWrap出现的次数
   buckets[data[i].data-min]++;
   
  }
  System.out.println(Arrays.toString(buckets));
  //计算“落入”各桶内的元素在有序序列中的位置
  for(int i = 1;i<max-min;i++){
   buckets[i] = buckets[i] + buckets[i-1];
  }
  System.out.println(Arrays.toString(buckets));
  System.arraycopy(data, 0, tmp, 0, arrayLength);
  //根据buckets数组中的信息将待排序列的各元素放入相应的位置
  for(int k = arrayLength-1;k>= 0 ;k--){
   data[--buckets[tmp[k].data-min]] = tmp[k];
  }
 }
 public static void main(String[] args) {
  DataWrap [] data = {
    new DataWrap(0,""),
    new DataWrap(2,""),
    new DataWrap(4,""),
    new DataWrap(1,""),
    new DataWrap(5,""),
    new DataWrap(9,""),
    
  };
  System.out.println("排序之前\n"+Arrays.toString(data));
  buckSort(data,-3,10);
  System.out.println("排序之后\n"+Arrays.toString(data));
 }
}

 

---------------------------------------------------------------

public class DataWrap implements Comparable<DataWrap>{
 int data;
 String flag;
 public DataWrap(int data,String flag){
  this.data = data;
  this.flag = flag;
 }
 
 public String toString(){
  return data+flag;
 }

 @Override
 //根据data实例变量来决定两个DataWrap的大小
 public int compareTo(DataWrap o) {
  
  return this.data>o.data?1 : (this.data==o.data?0 : -1);
 }
}

 

 

-------------------------------------

排序开始：
[0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1]
[0, 0, 0, 1, 2, 3, 3, 4, 5, 5, 5, 5, 6]
排序之后
[0, 1, 2, 4, 5, 9]

转载于:https://my.oschina.net/meilingchen/blog/469903