排序算法实现与分析（冒泡排序，选择排序，插入排序，自底向上归并排序），Echarts可视化结果

要求：随机生成排序所用100000个实数，生成的数以数组的形式存储

　　　记录各排序方法所需排序时间

　　　重复进行3次运算后取出平均耗时做比较

　　　以柱状图的形式展示结果，分析结果

主程序：

import java.util.Random;
import javax.swing.JFrame;

public class test extends JFrame{
    
    //随机100000个生成数据
    public static double[] data() {
        Random random = new Random();
        double[] arr=new double[100000];
        for(int i=0;i<100000;i++) {
            arr[i]=random.nextDouble();
        }
        return arr;
    }
    
    //冒泡排序
    public static void bubbleSort(double[] arr) {
        double temp;//定义一个临时变量
        for(int i=0;i<arr.length-1;i++){//趟数
            for(int j=0;j<arr.length-i-1;j++){
                //若后面个数据小，则交换两个元素
                if(arr[j+1]<arr[j]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
    
    //选择排序
    public static void selectionSort(double[] arr) {
        for(int i=0; i<arr.length; i++) {
            int minIndex = i;//最小数索引
            for(int j=i; j<arr.length; j++) {
                //找最小数，并记录最小数的索引
                if(arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            //交换符合条件的数
            double tmp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = tmp;
        }
    }
    
    //插入排序
    public static void insertionSort(double[] arr) {
        int j=0;
        for(int i=1;i<arr.length;i++) {
            double temp=arr[i]; //temp存放将要插入的数据
            if(arr[i]<arr[i-1]) {
                for( j=i-1;j>=0&&arr[j]>temp;j--) {
                    arr[j+1]=arr[j];
                    //temp的位置空出来，把第j个的值赋给第j+1个；
                }
                arr[j+1]=temp;
            }
        }
    }
    
    //自底向上归并排序
    public static void sortDownToUp(double[] arr) {
        double[] aux = new double[arr.length];
        for (int sz = 1; sz < arr.length; sz *= 2) {
            for (int start = 0; start < arr.length - sz; start += 2 * sz) {
                int end=Math.min(start + 2 * sz - 1, arr.length - 1);
                int mid=start + sz - 1;
                //按照长度归并回arr数组，归并后长度翻倍
                for (int k = start; k <= end; k++) {
                    aux[k] = arr[k];
                }
                int i = start, j = mid + 1;
                //[start,mid] [mid+1, end]
                for (int k = start; k <= end; k++) {
                    if (i > mid) {
                        arr[k] = aux[j++];
                    } else if (j > end) {
                        arr[k] = aux[i++];
                    } else if (aux[j] < aux[i]) {
                        arr[k] = aux[j++];
                    } else {
                        arr[k] = aux[i++];
                    }
                }
            }
        }
    }

//    主函数
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        double starttime,endtime;
        double[] arr=data();//生成数据

        //3次运行对比
        double[] b_time=new double[3];
        double[] s_time=new double[3];
        double[] i_time=new double[3];
        double[] d_time=new double[3];
        double[] avartime=new double[4];//平均运行时间

        for(int i=0;i<3;i++) {
            double[] b_arr=arr.clone();
            double[] s_arr=arr.clone();
            double[] i_arr=arr.clone();
            double[] d_arr=arr.clone();

            starttime=System.currentTimeMillis();
            bubbleSort(b_arr);//冒泡排序
            endtime=System.currentTimeMillis();
            b_time[i]=(endtime-starttime)/1000.0;//耗时
            
            starttime=System.currentTimeMillis();
            selectionSort(s_arr);//选择排序
            endtime=System.currentTimeMillis();
            s_time[i]=(endtime-starttime)/1000.0;//耗时
            
            starttime=System.currentTimeMillis();
            insertionSort(i_arr);//插入排序
            endtime=System.currentTimeMillis();
            i_time[i]=(endtime-starttime)/1000.0;//耗时
            
            starttime=System.currentTimeMillis();
            sortDownToUp(d_arr);//自底向上归并排序
            endtime=System.currentTimeMillis();
            d_time[i]=(endtime-starttime)/1000.0;//耗时
        }
        //平均运行时间
        avartime[0]=(b_time[0]+b_time[1]+b_time[2])/3;
        avartime[1]=(s_time[0]+s_time[1]+s_time[2])/3;
        avartime[2]=(i_time[0]+i_time[1]+i_time[2])/3;
        avartime[3]=(i_time[0]+i_time[1]+i_time[2])/3;

        System.out.println("冒泡排序	选择排序	插入排序	归并排序");
        for(int j=0;j<3;j++) {
            System.out.println(b_time[j]+"s	"+s_time[j]+"s	"+i_time[j]+"s	"+d_time[j]+"s");
        }
        System.out.println("平均时间：");

            System.out.println(avartime[0]+"s	"+avartime[1]+"s	"+avartime[2]+"s	"+avartime[3]+"s	");



    }

}

运行结果（每次运行都不同）：

可视化图表程序（Echarts图表库）：

var posList = [
    'left', 'right', 'top', 'bottom',
    'inside',
    'insideTop', 'insideLeft', 'insideRight', 'insideBottom',
    'insideTopLeft', 'insideTopRight', 'insideBottomLeft', 'insideBottomRight'
];

app.configParameters = {
    rotate: {
        min: -90,
        max: 90
    },
    align: {
        options: {
            left: 'left',
            center: 'center',
            right: 'right'
        }
    },
    verticalAlign: {
        options: {
            top: 'top',
            middle: 'middle',
            bottom: 'bottom'
        }
    },
    position: {
        options: echarts.util.reduce(posList, function (map, pos) {
            map[pos] = pos;
            return map;
        }, {})
    },
    distance: {
        min: 0,
        max: 100
    }
};

app.config = {
    rotate: 90,
    align: 'left',
    verticalAlign: 'middle',
    position: 'insideBottom',
    distance: 15,
    onChange: function () {
        var labelOption = {
            normal: {
                rotate: app.config.rotate,
                align: app.config.align,
                verticalAlign: app.config.verticalAlign,
                position: app.config.position,
                distance: app.config.distance
            }
        };
        myChart.setOption({
            series: [{
                label: labelOption
            }, {
                label: labelOption
            }, {
                label: labelOption
            }, {
                label: labelOption
            }]
        });
    }
};

var labelOption = {
    normal: {
        show: true,
        position: app.config.position,
        distance: app.config.distance,
        align: app.config.align,
        verticalAlign: app.config.verticalAlign,
        rotate: app.config.rotate,
        formatter: '{c}  {name|{a}}',
        fontSize: 16,
        rich: {
            name: {
                textBorderColor: '#fff'
            }
        }
    }
};

option = {
    color: ['#003366', '#006699', '#4cabce', '#e5323e'],
    tooltip: {
        trigger: 'axis',
        axisPointer: {
            type: 'shadow'
        }
    },
    legend: {
        data: ['Forest', 'Steppe', 'Desert', 'Wetland']
    },
    toolbox: {
        show: true,
        orient: 'vertical',
        left: 'right',
        top: 'center',
        feature: {
            mark: {show: true},
            dataView: {show: true, readOnly: false},
            magicType: {show: true, type: ['line', 'bar', 'stack', 'tiled']},
            restore: {show: true},
            saveAsImage: {show: true}
        }
    },
    calculable: true,
    xAxis: [
        {
            type: 'category',
            axisTick: {show: false},
            data: ['冒泡排序', '选择排序', '插入排序', '归并排序']
        }
    ],
    yAxis: [
        {
            type: 'value'
        }
    ],
    series: [
        {
            name: '第一次',
            type: 'bar',
            barGap: 0,
            label: labelOption,
            data: [28.834, 6.102, 1.32, 0.024]
        },
        {
            name: '第二次',
            type: 'bar',
            label: labelOption,
            data: [24.789, 7.305, 1.21, 0.012]
        },
        {
            name: '第三次',
            type: 'bar',
            label: labelOption,
            data: [19.88, 2.661, 2.412,0.023]
        },
        {
            name: '平均时间',
            type: 'bar',
            label: labelOption,
            data: [24.501, 5.356, 1.6473]
        }
]
};

图表：

优缺点比较：

 1.胃泡排序

　　(1)基本原理

　　　　在要排序的一-组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较，让
　　较大的数往下沉，较小的往上冒。即:每当两相邻的数比较后发现他们的排序与排序要求相反时，就将他们互换。

　　(2)优缺点
　　　　优点:稳定性小
　　　　缺点:慢，每次只能移动两个相邻的数据;

2.简单选择排序
　　(1)基本思想
　　　　第一趟:从第一个记录开始，将后面n-1个记录进行比较，找到其中最小的记录和第一一个记录进行交换; 
　　　　第二趟:从第二个记录开始，将后面n-2个记录进行比较，找到其中最小的记录和第2个记录进行交换; 
　　　　第i趟:从第i个记录开始，将后面n-i个记录进行比较，找到其中最小的记录和第i个记录进行交换; 
　　　　以此类推，经过n-1趟比较，将n-1个记录排到位，剩下一个最大记录直接排在最后; 

 

3.插入排序4
　　(1)基本思想
　　　　将一个记录插入到已排序好的有序表中，从而得到一个新的，记录数增1的有序表。即先将序列的第一个
　　　　记录看成是一个有序的子序列，然后从第二个记录逐个进行插入，直至整个序列有序为止。
　　(2)优缺点
　　　　优点:稳定，快
　　　　缺点:比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是数据量庞大的时候

4.归并排序
　　(1)基本思想
　　　　首先将初始序列的n个记录看成是n个有序的子序列，每个子序列的长度为1,然后两两归并，得到n/2个

　　　　长度为2的有序子序列，在此基础上，再对长度为2的有序子序列进行两两归并，得到若干个长度为4的
　　　　有序子序列，以此类推，直到得到一个长度为n的有序序列为止;小
　　(2)适用场景
　　　　若n较大，并且要求排序稳定，则可以选择归并排序;