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

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

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

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

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

主程序:

  1 import java.util.Random;
  2 import javax.swing.JFrame;
  3 
  4 public class test extends JFrame{
  5     
  6     //随机100000个生成数据
  7     public static double[] data() {
  8         Random random = new Random();
  9         double[] arr=new double[100000];
 10         for(int i=0;i<100000;i++) {
 11             arr[i]=random.nextDouble();
 12         }
 13         return arr;
 14     }
 15     
 16     //冒泡排序
 17     public static void bubbleSort(double[] arr) {
 18         double temp;//定义一个临时变量
 19         for(int i=0;i<arr.length-1;i++){//趟数
 20             for(int j=0;j<arr.length-i-1;j++){
 21                 //若后面个数据小,则交换两个元素
 22                 if(arr[j+1]<arr[j]){
 23                     temp = arr[j];
 24                     arr[j] = arr[j+1];
 25                     arr[j+1] = temp;
 26                 }
 27             }
 28         }
 29     }
 30     
 31     //选择排序
 32     public static void selectionSort(double[] arr) {
 33         for(int i=0; i<arr.length; i++) {
 34             int minIndex = i;//最小数索引
 35             for(int j=i; j<arr.length; j++) {
 36                 //找最小数,并记录最小数的索引
 37                 if(arr[j] < arr[minIndex]) {
 38                     minIndex = j;
 39                 }
 40             }
 41             //交换符合条件的数
 42             double tmp = arr[i];
 43             arr[i] = arr[minIndex];
 44             arr[minIndex] = tmp;
 45         }
 46     }
 47     
 48     //插入排序
 49     public static void insertionSort(double[] arr) {
 50         int j=0;
 51         for(int i=1;i<arr.length;i++) {
 52             double temp=arr[i]; //temp存放将要插入的数据
 53             if(arr[i]<arr[i-1]) {
 54                 for( j=i-1;j>=0&&arr[j]>temp;j--) {
 55                     arr[j+1]=arr[j];
 56                     //temp的位置空出来,把第j个的值赋给第j+1个;
 57                 }
 58                 arr[j+1]=temp;
 59             }
 60         }
 61     }
 62     
 63     //自底向上归并排序
 64     public static void sortDownToUp(double[] arr) {
 65         double[] aux = new double[arr.length];
 66         for (int sz = 1; sz < arr.length; sz *= 2) {
 67             for (int start = 0; start < arr.length - sz; start += 2 * sz) {
 68                 int end=Math.min(start + 2 * sz - 1, arr.length - 1);
 69                 int mid=start + sz - 1;
 70                 //按照长度归并回arr数组,归并后长度翻倍
 71                 for (int k = start; k <= end; k++) {
 72                     aux[k] = arr[k];
 73                 }
 74                 int i = start, j = mid + 1;
 75                 //[start,mid] [mid+1, end]
 76                 for (int k = start; k <= end; k++) {
 77                     if (i > mid) {
 78                         arr[k] = aux[j++];
 79                     } else if (j > end) {
 80                         arr[k] = aux[i++];
 81                     } else if (aux[j] < aux[i]) {
 82                         arr[k] = aux[j++];
 83                     } else {
 84                         arr[k] = aux[i++];
 85                     }
 86                 }
 87             }
 88         }
 89     }
 90 
 91 //    主函数
 92     public static void main(String[] args) {
 93         // TODO Auto-generated method stub
 94         
 95         double starttime,endtime;
 96         double[] arr=data();//生成数据
 97 
 98         //3次运行对比
 99         double[] b_time=new double[3];
100         double[] s_time=new double[3];
101         double[] i_time=new double[3];
102         double[] d_time=new double[3];
103         double[] avartime=new double[4];//平均运行时间
104 
105         for(int i=0;i<3;i++) {
106             double[] b_arr=arr.clone();
107             double[] s_arr=arr.clone();
108             double[] i_arr=arr.clone();
109             double[] d_arr=arr.clone();
110 
111             starttime=System.currentTimeMillis();
112             bubbleSort(b_arr);//冒泡排序
113             endtime=System.currentTimeMillis();
114             b_time[i]=(endtime-starttime)/1000.0;//耗时
115             
116             starttime=System.currentTimeMillis();
117             selectionSort(s_arr);//选择排序
118             endtime=System.currentTimeMillis();
119             s_time[i]=(endtime-starttime)/1000.0;//耗时
120             
121             starttime=System.currentTimeMillis();
122             insertionSort(i_arr);//插入排序
123             endtime=System.currentTimeMillis();
124             i_time[i]=(endtime-starttime)/1000.0;//耗时
125             
126             starttime=System.currentTimeMillis();
127             sortDownToUp(d_arr);//自底向上归并排序
128             endtime=System.currentTimeMillis();
129             d_time[i]=(endtime-starttime)/1000.0;//耗时
130         }
131         //平均运行时间
132         avartime[0]=(b_time[0]+b_time[1]+b_time[2])/3;
133         avartime[1]=(s_time[0]+s_time[1]+s_time[2])/3;
134         avartime[2]=(i_time[0]+i_time[1]+i_time[2])/3;
135         avartime[3]=(i_time[0]+i_time[1]+i_time[2])/3;
136 
137         System.out.println("冒泡排序\t选择排序\t插入排序\t归并排序");
138         for(int j=0;j<3;j++) {
139             System.out.println(b_time[j]+"s\t"+s_time[j]+"s\t"+i_time[j]+"s\t"+d_time[j]+"s");
140         }
141         System.out.println("平均时间:");
142 
143             System.out.println(avartime[0]+"s\t"+avartime[1]+"s\t"+avartime[2]+"s\t"+avartime[3]+"s\t");
144 
145 
146 
147     }
148 
149 }

运行结果(每次运行都不同):

 

 

 

可视化图表程序(Echarts图表库):

  1 var posList = [
  2     'left', 'right', 'top', 'bottom',
  3     'inside',
  4     'insideTop', 'insideLeft', 'insideRight', 'insideBottom',
  5     'insideTopLeft', 'insideTopRight', 'insideBottomLeft', 'insideBottomRight'
  6 ];
  7 
  8 app.configParameters = {
  9     rotate: {
 10         min: -90,
 11         max: 90
 12     },
 13     align: {
 14         options: {
 15             left: 'left',
 16             center: 'center',
 17             right: 'right'
 18         }
 19     },
 20     verticalAlign: {
 21         options: {
 22             top: 'top',
 23             middle: 'middle',
 24             bottom: 'bottom'
 25         }
 26     },
 27     position: {
 28         options: echarts.util.reduce(posList, function (map, pos) {
 29             map[pos] = pos;
 30             return map;
 31         }, {})
 32     },
 33     distance: {
 34         min: 0,
 35         max: 100
 36     }
 37 };
 38 
 39 app.config = {
 40     rotate: 90,
 41     align: 'left',
 42     verticalAlign: 'middle',
 43     position: 'insideBottom',
 44     distance: 15,
 45     onChange: function () {
 46         var labelOption = {
 47             normal: {
 48                 rotate: app.config.rotate,
 49                 align: app.config.align,
 50                 verticalAlign: app.config.verticalAlign,
 51                 position: app.config.position,
 52                 distance: app.config.distance
 53             }
 54         };
 55         myChart.setOption({
 56             series: [{
 57                 label: labelOption
 58             }, {
 59                 label: labelOption
 60             }, {
 61                 label: labelOption
 62             }, {
 63                 label: labelOption
 64             }]
 65         });
 66     }
 67 };
 68 
 69 var labelOption = {
 70     normal: {
 71         show: true,
 72         position: app.config.position,
 73         distance: app.config.distance,
 74         align: app.config.align,
 75         verticalAlign: app.config.verticalAlign,
 76         rotate: app.config.rotate,
 77         formatter: '{c}  {name|{a}}',
 78         fontSize: 16,
 79         rich: {
 80             name: {
 81                 textBorderColor: '#fff'
 82             }
 83         }
 84     }
 85 };
 86 
 87 option = {
 88     color: ['#003366', '#006699', '#4cabce', '#e5323e'],
 89     tooltip: {
 90         trigger: 'axis',
 91         axisPointer: {
 92             type: 'shadow'
 93         }
 94     },
 95     legend: {
 96         data: ['Forest', 'Steppe', 'Desert', 'Wetland']
 97     },
 98     toolbox: {
 99         show: true,
100         orient: 'vertical',
101         left: 'right',
102         top: 'center',
103         feature: {
104             mark: {show: true},
105             dataView: {show: true, readOnly: false},
106             magicType: {show: true, type: ['line', 'bar', 'stack', 'tiled']},
107             restore: {show: true},
108             saveAsImage: {show: true}
109         }
110     },
111     calculable: true,
112     xAxis: [
113         {
114             type: 'category',
115             axisTick: {show: false},
116             data: ['冒泡排序', '选择排序', '插入排序', '归并排序']
117         }
118     ],
119     yAxis: [
120         {
121             type: 'value'
122         }
123     ],
124     series: [
125         {
126             name: '第一次',
127             type: 'bar',
128             barGap: 0,
129             label: labelOption,
130             data: [28.834, 6.102, 1.32, 0.024]
131         },
132         {
133             name: '第二次',
134             type: 'bar',
135             label: labelOption,
136             data: [24.789, 7.305, 1.21, 0.012]
137         },
138         {
139             name: '第三次',
140             type: 'bar',
141             label: labelOption,
142             data: [19.88, 2.661, 2.412,0.023]
143         },
144         {
145             name: '平均时间',
146             type: 'bar',
147             label: labelOption,
148             data: [24.501, 5.356, 1.6473]
149         }
150 ]
151 };

图表:

 

 

 

优缺点比较:

 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较大,并且要求排序稳定,则可以选择归并排序; 

posted @ 2019-10-14 20:00  匹诺曹云  阅读(879)  评论(0编辑  收藏  举报