Java 距离排序mysql java排序效率最高

     近几天再重新看数据结构的书时，根据各种排序的空间复杂度，发现快速排序所用时间是最短的，也即是说快速排序的速度最快。因此想验证一下具体这几个排序发的快慢，所以在Java中得以实现，同时在运行时，发现虽然快速排序的速度很快，但是它所消耗的内存是最大的。这也说明了当我们追求速度时，也必须要付出其他方面的代价。以下是几种方法的具体实现，及其所消耗的时间。

首先在Java中随机生成20个1000以内的数，然后使用四种排序法分别进行排序，验证四种排序程序的无误，以下是具体结果：

通过以上结果证明四种排序方法均可以达到排序目的，以下是对四种排序法时间的测试，观看各个测试时间的长短，具体结果如下所示：

以上是对随机生成的10万个数进行排序时所需时间，从上显然可看出冒泡所需时间为27秒，选择排序为8秒，而插入排序为5秒，冒泡排序时间为0秒。所以冒泡是最慢的而选择居其次，快速排序是最快的。以下是具体代码：

1 /**
  2  * 作者：曹家铭
  3  * 日期：2016，4，7
  4  * 功能：演示冒泡，选择，插入，快速排序的时间快慢程度比较
  5  */
  6 package com.Paixu;
  7 
  8 import java.util.Calendar;
  9 
 10 public class Paixu {
 11 
 12     public static void main(String[] args) {
 13         // TODO Auto-generated method stub
 14 
 15         int N=100000;
 16         int arr[]=new int[N];
 17         for(int i=0;i<N;i++)
 18         {
 19             int m=(int)(Math.random()*1000);
 20             arr[i]=m;
 21         }
 22         Bubble bubble=new Bubble();
 23         Select select=new Select();
 24         Insert insert=new Insert();
 25         Quick quick=new Quick();
 26         Calendar calendar=Calendar.getInstance();//打印当前系统时间
 27         //冒泡排序所用时间
 28         System.out.println("冒泡排序前的时间为："+calendar.getTime());
 29         bubble.sort(arr);
 30         calendar=Calendar.getInstance();
 31         System.out.println("冒泡排序后的时间为："+calendar.getTime());//打印排序后的时间*/
 32         //选择排序所用时间
 33         System.out.println("选择排序前的时间为："+calendar.getTime());
 34         select.sort(arr);
 35         calendar=Calendar.getInstance();
 36         System.out.println("选择排序后的时间为："+calendar.getTime());//打印排序后的时间*/
 37         //插入排序所用时间
 38         System.out.println("插入排序前的时间为："+calendar.getTime());
 39         insert.sort(arr);
 40         calendar=Calendar.getInstance();
 41         System.out.println("插入排序后的时间为："+calendar.getTime());//打印排序后的时间*/
 42         //快速排序所用时间
 43         System.out.println("快速排序前的时间为："+calendar.getTime());
 44         quick.sort(0, arr.length-1, arr);
 45         calendar=Calendar.getInstance();
 46         System.out.println("快速排序后的时间为："+calendar.getTime());//打印排序后的时间
 47         //冒泡排序后的结果
 48         bubble.sort(arr);
 49         System.out.println("冒泡排序之后的数组顺序为：");
 50         for(int i=0;i<arr.length;i++)
 51         {
 52             System.out.print(arr[i]+" ");
 53         }
 54         System.out.println();
 55         //选择排序后的结果
 56         select.sort(arr);
 57         System.out.println("选择排序之后的数组顺序为：");
 58         for(int i=0;i<arr.length;i++)
 59         {
 60             System.out.print(arr[i]+" ");
 61         }
 62         System.out.println();
 63         //插入排序的结果
 64         insert.sort(arr);
 65         System.out.println("插入排序之后的数组顺序为：");
 66         for(int i=0;i<arr.length;i++)
 67         {
 68             System.out.print(arr[i]+" ");
 69         }
 70         System.out.println();
 71         //快速排序的结果
 72         quick.sort(0, arr.length-1, arr);
 73         System.out.println("快速排序之后的数组顺序为：");
 74         for(int i=0;i<arr.length;i++)
 75         {
 76             System.out.print(arr[i]+" ");
 77         }
 78     }
 79 
 80 }
 81 //快速排序
 82 class Quick{
 83     public void sort(int fist,int last,int arry[]){
 84         int f=fist;
 85         int l=last;
 86         int mid=arry[(fist+last)/2];
 87         int temp=0;
 88         while(f<l){
 89             while(arry[f]<mid) f++;
 90             while(arry[l]>mid) l--;
 91             if(f>=l) break;
 92             temp=arry[f];
 93             arry[f]=arry[l];
 94             arry[l]=temp;
 95             if(arry[f]==mid) --l;
 96             if(arry[l]==mid) ++f;
 97             }
 98         if(f==l){
 99             f++;
100             l--;
101         }
102         //利用递归快速排序
103         if(fist<l) sort(fist,l,arry);
104         if(last>f) sort(f,last,arry);
105     }
106 }
107 //插入排序
108 class Insert{
109     public void sort(int arry[]){
110         for(int i=1;i<arry.length;i++)
111         {
112             int InsertNum=arry[i];
113             int Index=i-1;
114             while(Index>=0&&InsertNum<arry[Index])
115             {
116                 arry[Index+1]=arry[Index];//将前一个数复制给后一个比他小的数
117                 Index--;
118             }
119             arry[Index+1]=InsertNum;//将该插入的数复制给前一个较小的数
120         }
121     }
122 }
123 //冒泡排序
124 class Bubble{
125     public void sort(int arry[]){
126         int temp=0;
127         for(int i=0;i<arry.length-1;i++)
128         {
129             for(int j=0;j<arry.length-i-1;j++)
130             {
131                 if(arry[j]>arry[j+1])
132                 {
133                     temp=arry[j];
134                     arry[j]=arry[j+1];
135                     arry[j+1]=temp;
136                 }
137             }
138         }
139     } 
140 }
141 //选择排序
142 class Select{
143     public void sort(int arry[]){
144         int temp=0;
145         for(int i=0;i<arry.length-1;i++)
146         {
147             int min=arry[i];
148             int minIndex=i;
149             for(int j=i+1;j<arry.length-1;j++)
150             {
151                 if(min>arry[j])
152                 {
153                     min=arry[j];
154                     minIndex=j;
155                 }
156             }
157             temp=arry[i];
158             arry[i]=arry[minIndex];
159             arry[minIndex]=temp;
160         }
161     }
162 }