算法和数据结构篇---计数排序、桶排序

计数排序

思想：遍历数列，将数列中每个元素的值放在数组对应的下标中，出现几次那数组对应下标值就是几。
举个例子
待排序数列：1，4，6，2，3，1，5
数组下标从0-6

数组下标	0	1	2	3	4	5	6
数组值	0	2	1	1	1	1	1

然后输出这个数组的下标，数组值是多少就输出多少次数组下标
得到排序数列1，1，2，3，4，5，6

---

优化
但是这种方法有缺陷，我们创建的计数数组长度都是由最大元素决定，如果数列都很大，前面的值都是0，那就浪费了很多空间。所以我们可以得到数列中的最小最大值，再得到二者差值作为数组大小。另外，遇到相同的元素不知道谁先谁后，这样就需要从第二个下标开始每个下标都加上前面的下标的值的和，那就可以让相同的元素也能区分先后顺序。

实现代码

package 计数排序;

import java.util.Arrays;

//建立数组，将数列中出现的值对应在数组的下标中并计数，最终输出数组元素及次数即可
public class 计数排序 {
    //基本的计数排序
    public static int[] countsort(int[] array)
    {
        //首先得到数组中的最大值
        int max=array[0];
        for(int i=1;i<array.length;i++)
        {
            if(array[i]>max)
                max=array[i];
        }
        //根据得到的最大值建立计数数组
        int[] countarray=new int[max+1];

        //填充计数数组
        for(int i=0;i<array.length;i++)
        {
            countarray[array[i]]++;
        }

        //输出结果
        int index=0;
        int[] sortedarray=new int[array.length];
        for(int i=0;i<countarray.length;i++)
        {
            for(int j=0;j<countarray[i];j++)
            {
                sortedarray[index++]=i;
            }
        }
        return sortedarray;
    }

    //改进版计数排序
    public static int[] Countsort(int[] array)
    {
        //得到最大值和最小值，计算差值建立计数数组
        int max=array[0],min=array[0];
        for(int i=1;i<array.length;i++)
        {
            if(array[i]>max)
                max=array[i];
            if(array[i]<min)
                min=array[i];
        }
        int d=max-min;
        int[] countarray=new int[d+1];

        //对应元素统计
        for(int i=0;i<array.length;i++)
        {
            countarray[array[i]-min]++;
        }

        //对计数数组变形，对应到每一个数
        for(int i=1;i<countarray.length;i++)
        {
            countarray[i]+=countarray[i-1];
        }

        //倒序遍历数组，输出结果
        int[] sortedarray=new int[array.length];
        for(int i=array.length-1;i>=0;i--)
        {
            sortedarray[countarray[array[i]-min]-1]=array[i];
            countarray[array[i]-min]--;
        }
        return sortedarray;
    }

    public static void main(String[] args) {
        int[] arr=new int[]{4,6,5,3,2,8,1,7,0,10};
        int[] array=new int[]{95,94,91,98,99,90,93,91,92};
        int[] sortedarray=countsort(arr);
        int[] Sortedarray=Countsort(array);
        System.out.println(Arrays.toString(sortedarray));
        System.out.println(Arrays.toString(Sortedarray));
    }
}

结果

桶排序

桶排序的大致思想和计数排序一样，可是又有优化的地方。因为计数排序所用的是数组下标，所以它能排序的数列都必须是整数，而桶排序就可以完美的解决这个问题，它的桶是一个区间，所以能将小数也进行排序。

桶排序步骤：

• 创建桶
• 遍历数列，将元素放入对应的桶中
• 对每个桶内部先排序，然后遍历所有桶，得到有序数列

创建桶：一般桶的数量就是数列元素的数量，区间大小就是（最大值-最小值）/（桶数量-1）
一般桶内部排序用的是归并排序，用已给的sort函数就可以了。
实现代码

package 桶排序;

import java.util.*;

public class 桶排序 {
    public static double[] bucketsort(double[] array)
    {
        //首先获取最大最小值，得到差值d
        double max=array[0];
        double min=array[0];
        for(int i=1;i<array.length;i++)
        {
            if(array[i]>max)
                max=array[i];
            if(array[i]<min)
                min=array[i];
        }
        double d=max-min;

        //建立桶，用链表结构
        int bucketnum=array.length;
        ArrayList<LinkedList<Double>> bucketlist=new ArrayList<LinkedList<Double>>(bucketnum);
        for(int i=0;i<bucketnum;i++)
        {
            bucketlist.add(new LinkedList<Double>());
        }


        //将数列元素放入桶内
        for(int i=0;i<array.length;i++)
        {
            int num=(int)((array[i]-min)*(bucketnum-1)/d);
            bucketlist.get(num).add(array[i]);
        }

        //对每个桶内的元素排序
        for(int i=0;i<bucketlist.size();i++)
        {
            Collections.sort(bucketlist.get(i));
        }

        //桶内元素的输出
        double[] sortedarray=new double[array.length];
        int index=0;
        for(LinkedList<Double> list:bucketlist)
        {
            for(double element:list)
            {
                sortedarray[index]=element;
                index++;
            }
        }

        return sortedarray;
    }


    public static void main(String[] args) {
        double[] array=new double[]{4.12,6.421,0.0023,3.0,2.123,8.122,4.12,10.09};
        double[] sortedarray=bucketsort(array);
        System.out.println(Arrays.toString(sortedarray));
    }
}

结果