各种排序算法总结

本篇文章针对现有常用的排序算法进行比较，并计算出排序所用的时间。

待排序的个数：100000

待排序数值的范围：0~1000

1  简化版桶排序法

import java.util.Random;

/*对0~10000之间的100000个数从小到大排序
 * 简化桶排序法
 * 祁俊辉  17.5.2
 * */
public class Tong {
    static int a[]=new int[100000];//定义存储100000个待排序数的数组
    static int b[]= new int[100001];//定义桶，范围0~100000，所以共10001个桶
    //定义一个简易桶排序的方法
    static void BarrelSort(int[] Dai,int[] Tou){//传入待排序数组、桶数组
        for(int i=0;i<Dai.length;i++){
            Tou[Dai[i]]++;
        }
    }
    //生成随机数
    static int RandomMM(int min,int max){
        Random random = new Random();
        int s = random.nextInt(max)%(max-min+1) + min;
        return s;
    }
    //主方法
    public static void main(String[] args) {
        long starTime=System.currentTimeMillis();//当前时间赋给一个变量
        for(int i=0;i<a.length;i++){
            a[i] = RandomMM(0,10000);
        }
        BarrelSort(a,b);//桶排序调用
        //输出排序后的结果
        //遍历桶，为0的不打印（说明没出现过），1以上的循环打印（防止同一个数多次出现）
        for(int i=0;i<b.length;i++){
            for(int j=1;j<=b[i];j++){
                System.out.println(i);
            }
        }
        long endTime=System.currentTimeMillis();//当前时间赋给一个变量
        long time=endTime-starTime;//计算所用时间
        System.out.println("对100000个“0~10000”范围的整数排序（冒泡排序法）："+time+"ms");//输出时间
    }
}

2  冒泡排序法

import java.util.Random;

/*对0~10000之间的100000个数从小到大排序
 * 冒泡法
 * 祁俊辉  17.5.2
 * */
public class Mao {
    static int a[]=new int[100000];//定义存储100000个待排序数的数组
    //定义一个冒泡排序的方法
    static void BubbleSort(int[] Dai){
        for(int i=1;i<Dai.length;i++){//n个数排序，只需进行n-1趟操作（一次操作只将1个数归位）
            for(int j=0;j<Dai.length-i;j++){//第一趟比较n-1次，第二趟比较n-2次。。。
                if(Dai[j]>Dai[j+1]){//不满足条件，交换
                    int temp=a[j];
                    Dai[j]=Dai[j+1];
                    Dai[j+1]=temp;
                }
            }
        }
    }
    //生成随机数
    static int RandomMM(int min,int max){
        Random random = new Random();
        int s = random.nextInt(max)%(max-min+1) + min;
        return s;
    }
    //主方法
    public static void main(String[] args) {
        long starTime=System.currentTimeMillis();//当前时间赋给一个变量
        for(int i=0;i<a.length;i++){
            a[i] = RandomMM(0,10000);
        }
        BubbleSort(a);//冒泡排序调用
        //输出排序后的结果
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
        long endTime=System.currentTimeMillis();//当前时间赋给一个变量
        long time=endTime-starTime;//计算所用时间
        System.out.println("对100000个“0~10000”范围的整数排序（冒泡排序法）："+time+"ms");//输出时间
    }
}

3  快速排序法

import java.util.Random;

/*对0~10000之间的100000个数从小到大排序
 * 快速排序法
 * 祁俊辉  17.5.2
 * */
public class Kuai {
    static int a[]=new int[100000];//定义存储100000个待排序数的数组
    //定义一个快速排序的方法
    static void QuickSort(int[] Dai,int left,int right){//传入待排序数组、左右下标
        int i,j,t,temp;
        if(left>right)//如果越界，则表示出错，直接退出
            return;
        temp=Dai[left];//存储基准数
        i=left;
        j=right;
        while(i!=j){
            while(Dai[j]>=temp && i<j)//注意顺序，先从右往左，要不然会落下一个数
                j--;
            while(Dai[i]<=temp && i<j)//再从左往右
                i++;
            if(i<j){//没有相遇，则交换
                t=Dai[i];
                Dai[i]=Dai[j];
                Dai[j]=t;
            }
        }
        //运行到这里，说明左右相遇了，将基准数归位
        Dai[left]=Dai[i];
        Dai[i]=temp;
        //左右递归运算
        QuickSort(Dai,left,i-1);//继续处理左边的，递归
        QuickSort(Dai,i+1,right);//继续处理右边的，递归
    }
    //生成随机数
    static int RandomMM(int min,int max){
        Random random = new Random();
        int s = random.nextInt(max)%(max-min+1) + min;
        return s;
    }
    //主方法
    public static void main(String[] args) {
        long starTime=System.currentTimeMillis();//当前时间赋给一个变量
        for(int i=0;i<a.length;i++){
            a[i] = RandomMM(0,10000);
        }
        QuickSort(a,0,a.length-1);//快速排序调用
        //输出排序后的结果
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
        long endTime=System.currentTimeMillis();//当前时间赋给一个变量
        long time=endTime-starTime;//计算所用时间
        System.out.println("对100000个“0~10000”范围的整数排序（快速排序法）："+time+"ms");//输出时间
    }
}

4  堆排序法（完全二叉树）

import java.util.Random;

/*对0~10000之间的100000个数从小到大排序
 * 堆排序法（堆：完全二叉树）
 * 祁俊辉  17.5.2
 * */
public class Dui {
    static int a[]=new int[100001];//定义存储100000个待排序数的数组，下标从1~100000
    static int n=a.length-1;//待排序个数，也就是堆的大小
    //交换函数，用来交换堆中两个元素的值
    static void swap(int[]Dai,int x,int y){
        int temp;
        temp=Dai[x];
        Dai[x]=Dai[y];
        Dai[y]=temp;
    }
    //向下调整函数
    static void siftdown(int[] Dai,int i){//传入待排数组和需要向下调整的下标
        int t,flag=0;//flag用来标记是否需要继续向下调整
        //当i结点有儿子（左）并且有需要继续调整的时候循环执行
        while(i*2<=n && flag==0){
            //首先判断左边，并用t记录值较小的结点编号
            if(Dai[i] > Dai[i*2])
                t=i*2;
            else
                t=i;
            //如果它有左边，在对右边进行讨论
            if(i*2+1 <= n){
                if(Dai[t] > Dai[i*2+1])
                    t=i*2+1;
            }
            //如果发现最小的结点编号不是自己，说明子结点中有比父结点更小的
            if(t!=i){
                swap(Dai,t,i);//交换它们
                i=t;//更新i
            }else{
                flag=1;//否则说明当前父结点已经比它的子节点小，不需要进行调整
            }
        }
    }
    //建立堆的函数
    static void creat(int[] Dai){
        //从最后一个非页结点到第一个结点依次进行向下调整
        for(int i=n/2;i>=1;i--)
            siftdown(Dai,i);
    }
    //删除最大的元素
    static int deletemax(int[] Dai){
        int t=Dai[1];//用一个临时变量记录堆的顶点的值
        Dai[1]=Dai[n];//将堆的最后一个点赋值到堆顶
        n--;//堆的元素减1
        siftdown(Dai,1);//向下调整
        return t;//返回之前记录的堆的顶点的最大值
    }    
    //生成随机数
    static int RandomMM(int min,int max){
        Random random = new Random();
        int s = random.nextInt(max)%(max-min+1) + min;
        return s;
    }
    //主函数
    public static void main(String[] args) {
        long starTime=System.currentTimeMillis();//当前时间赋给一个变量
        for(int i=0;i<a.length;i++){
            a[i] = RandomMM(0,10000);
        }
        creat(a);//建堆
        //删除顶部元素，连续删除n次，其实就是从小到大把数输出来
        for(int i=1;i<=n;i++)
            System.out.println(deletemax(a));
        long endTime=System.currentTimeMillis();//当前时间赋给一个变量
        long time=endTime-starTime;//计算所用时间
        System.out.println("对100000个“0~10000”范围的整数排序（快速排序法）："+time+"ms");//输出时间
    }
}

5  总结

以上只对四种排序方法进行比较，后期将持续更新。

简化版桶排序主要针对数值范围小、待排序个数多的数进行排序，因为数值范围直接影响它要设置多少个桶。

冒泡排序只是一种思想，在实际应用中不会应用，因为不管何种情况，效率太慢！

快速排序是一个值得推荐的排序方法。

堆排序法是从最小堆（完全二叉树）中扩展出来的，排序过程也是非常快速（也可以用最大堆进行排序，可以避免建立堆的过程，可能会更优化）。