线性排序算法-- 计数排序,基数排序,桶排序

package sort;

import java.util.Arrays;

/**
 * 计数排序, 假设输入的数据是在某一个较小的范围内, 比如输入的数字为从0~k,
 * 时间复杂度为O(k+n), 当k=O(n)时, 时间复杂度为O(n), 但是需要额外的空间复杂度为O(n)
 * 属于非原址排序, 对于内存较为宝贵的排序不是很适合
 * 稳定排序
 */
public class CountingSort
{
    /**
     *
     * @param a : 待排序的数组
     * @param k : a内元素的个数为[0,k]
     */
    public static void sort(int[] a , int k)
    {
        int[] b = new int[a.length] ;
        countingSort(a , b , k+1) ;
    }

    private static void countingSort(int[] a , int[] b , int k)
    {
        int[] count = new int[k+1] ;
        for(int i=0 ; i<a.length ; i++)
        {
            count[a[i]+1]++ ;
        }

        for(int i=0 ; i<count.length-1 ; i++)
        {
            count[i+1] += count[i] ;
        }

        for(int i=0 ; i<a.length ; i++)
        {
            int pos = count[a[i]]++ ;
            b[pos] = a[i] ;
        }

        for(int i=0 ; i<a.length ; i++)
        {
            a[i] = b[i] ;
        }
    }

    public static void main(String[] args) {
        int[] a = new int[]{
                6,0,2,0,1,3,4,6,1,3,2
        } ;

        sort(a , 6) ;

        System.out.println(Arrays.toString(a));
    }
}

基数排序是基于计数排序思想的一种排序算法, 根据从排序开始的顺序不同分为LSD(低位优先)和MSD(高位优先)

LSD:

package sort.radixSort;

import java.util.Arrays;

/**
 * 低位优先的基数排序, 对于位数一致的字符串或者数字进行排序比较有效
 * 对于给定n个d位数, 其中每一个数字有k种选择, 也就是每一种数字的范围是[0,k], 基数排序的时间复杂度为O(d*(n*k))
 * 当k=O(n)时, 基数排序的时间复杂度为O(n) ;
 * 额外需要O(n)的空间复杂度
 * 属于稳定排序, 非原址排序
 */
public class LSD
{
    /**
     *
     * @param a : a为待排序的数组
     * @param d : 最高位为d位, 第一位为最低位
     */
    public static void sort(int[] a , int d)
    {
        int[] b = new int[a.length] ;
        for(int time=0 ; time<d ; time++)
        {
            int[] count = new int[11] ; //0~9 一共10个数字+1
            for(int i=0 ; i<a.length ; i++)
            {
                int pos = get(a[i] , time+1) ;
                count[pos+1]++ ;
            }

            for(int i=0 ; i<count.length-1 ; i++)
            {
                count[i+1] += count[i] ;
            }

            for(int i=0 ; i<a.length ; i++)
            {
                int pos = get(a[i] , time+1) ;
                int p = count[pos]++ ;
                b[p] = a[i] ;
            }

            for(int i=0 ; i<a.length ; i++)
            {
                a[i] = b[i] ;
            }
        }
    }

    //返回num的第k位, 最低位为第1位
    private static int get(int num , int k)
    {
        int n = (int)Math.pow(10 , k) ;

        return (num-num/n*n)*10/n ;
    }
    public static void main(String[] args)
    {
        int[] num = new int[]{
                329 , 457 , 657 , 839 , 436 , 720 , 355
        } ;

        sort(num , 3) ;

        System.out.println(Arrays.toString(num));
    }
}

MSD:

package sort.radixSort;

import java.util.Arrays;

/**
 * 高位优先的基数排序算法,
 * 主要性质和LSD类似, 唯一不同的地方在于MSD适用于键长不一样的数据排序
 * 而且MSD的性能主要依赖于输入的数据, 当输入的数据之间重复的公共部分很少时, 可以在线性时间内完成
 * 当输入的数据之间公共部分很多时, 性能会急速下降.
 * 当输入的数据每一位有k种选择, 那么对于输入N个数据, 时间复杂度约为Nlogr的N, 与键长无关
 * 对于有大量重复的情况, 可以通过在小数组切换排序算法进行处理.
 */
public class MSD
{
    private static int R = 256 ;
    private static String[] aux ;
    public static int charAt(String str , int i)
    {
        return i>= str.length() ? -1 : str.charAt(i)-97 ;
    }
    public static void sort(String[] str)
    {
        aux = new String[str.length] ;
        sort(str , 0 , str.length-1 , 0) ;
    }

    private static void sort(String[] str , int lo , int hi , int d)
    {
        if(lo >= hi)
            return ;
        int[] count = new int[R+2] ;//多一个-1表示这位不存在 再多1

        for(int i=lo ; i<=hi ; i++)
        {
            count[charAt(str[i] , d)+2]++ ;
        }

        for(int i=0 ; i<count.length-1 ; i++)
            count[i+1] += count[i] ;
        for(int i=lo ; i<=hi ; i++)
        {
            int pos = count[charAt(str[i] , d)+1]++ ;
            aux[pos] = str[i] ;
        }

        for(int i=lo ; i<=hi ; i++)
        {
            str[i] = aux[i-lo] ;
        }

        for(int i=0 ; i<count.length-1 ; i++)
            sort(str , lo+count[i] , lo+count[i+1]-1 , d+1) ;
    }

    public static void main(String[] args) {

        String[] str = new String[]{
                "she" ,
                "sells" ,
                "seashells" ,
                "by" ,
                "the" ,
                "sea" ,
                "shore" ,
                "the" ,
                "shells" ,
                "she" ,
                "shel" ,
                "sells" ,
                "are" ,
                "surely" ,
                "seashells"
        } ;

        sort(str);
        System.out.println(Arrays.toString(str));
    }
}

桶排序: 网上很多资料的桶排序和基数排序相混淆, 实际上两种排序算法还是有区分的, 基数排序是把数据从高位到低位的顺序或者从低位到高位的顺序进行计数排序的, 而桶排序则是把数据按大小划分成若干个桶, 然后将每个桶按照某种排序算法排序, 然后依次取出形成最终的排序后的数据.

package sort;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * 桶排序
 * 假设输入的数据服从均匀分布, 那么排序的平均时间复杂度为O(N)
 * 将[0,1)分成N个大小相同的区间, 将N个数据放入相应的区间(桶)中, 然后将各个桶进行排序, 最后合并n个桶
 * 算法导论里面是N个元素就N个桶, 我看网上博客具体桶的个数依具体情况而定.
 * 这里我的实现使用的是算法导论中的
 * 当输入的元素不满足均匀分布时, 只要所有桶的大小的平方与元素的个数呈线性关系,桶排序也可以在O(N)完成(这句话不是很理解,为什么桶的元素个数会固定呢)
 * 最坏情况下桶排序的时间复杂度取决于桶内使用的排序算法的时间复杂度, 如果桶内使用的是插入排序, 那么时间复杂度最坏为O(N^2)
 * 桶内使用的如果是快排, 那么时间复杂度为O(NlogN)
 * 非原址排序
 * 稳定性依赖于桶内的排序算法, 空间复杂度为O(N)
 */
public class BucketSort
{
    public static void sort(int[] a ,int maxNum)
    {
        int N = a.length ;
        ArrayList<Integer>[] bucket = new ArrayList[N] ;

        for(int i=0 ; i<bucket.length ; i++)
        {
            bucket[i] = new ArrayList<>() ;
        }
        for(int i=0 ; i<a.length ; i++)
        {
            int pos = a[i]/maxNum*N ;
            bucket[pos].add(a[i]) ;
        }

        int num = 0 ;
        for(int i=0 ; i<bucket.length ; i++)
        {
            Integer[] arr = bucket[i].toArray(new Integer[0]) ;
            quickSort(arr);

            for(int n : arr)
                a[num++] = n ;
        }

    }

    private static void quickSort(Integer[] arr)
    {
        quickSort(arr , 0 , arr.length-1);
    }

    private static void quickSort(Integer[] arr , int lo , int hi)
    {
        if(lo >= hi)
            return ;

        int mid = partition(arr , lo , hi) ;
        quickSort(arr , lo , mid-1) ;
        quickSort(arr , mid+1 , hi) ;
    }

    private static int partition(Integer[] arr , int lo , int hi)
    {
        int mid = median(arr , lo , hi) ;
        int left = lo-1 ;
        int right = mid ;

        while (true)
        {
            while (arr[++left] < arr[mid])
                ;
            while (arr[--right] > arr[mid])
                ;

            if(left < right)
                swap(arr , left ,right);
            else
                break ;
        }

        swap(arr , left , mid);

        return left ;
    }

    private static int median(Integer[] arr , int lo , int hi)
    {
        int mid = lo+(hi-lo)/2 ;
        if(arr[lo] > arr[mid])
            swap(arr , lo , mid);
        if(arr[lo] > arr[hi])
            swap(arr , lo , hi) ;
        if(arr[mid] > arr[hi])
            swap(arr , mid , hi) ;

        swap(arr , mid , hi-1) ;

        return hi-1 ;
    }

    private static void swap(Integer[] arr , int p , int q)
    {
        int temp = arr[p] ;
        arr[p] = arr[q] ;
        arr[q] = temp ;
    }

    public static void main(String[] args)
    {
        int[] a = new int[]{
                78 , 17 ,39, 26 ,72 , 94 , 21 , 12 , 23 , 68
        } ;

        sort(a , 100);

        System.out.println(Arrays.toString(a));
    }
}

//如果有什么不正确的地方，欢迎指出