冒泡，选择，插入，快速排序在Java中的实现

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

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

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

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

 /**
  * 作者：曹家铭
  * 日期：2016，4，7
  * 功能：演示冒泡，选择，插入，快速排序的时间快慢程度比较
  */
 package com.Paixu;

 import java.util.Calendar;

 public class Paixu {

     public static void main(String[] args) {
         // TODO Auto-generated method stub

         int N=100000;
         int arr[]=new int[N];
         for(int i=0;i<N;i++)
         {
             int m=(int)(Math.random()*1000);
             arr[i]=m;
         }
         Bubble bubble=new Bubble();
         Select select=new Select();
         Insert insert=new Insert();
         Quick quick=new Quick();
         Calendar calendar=Calendar.getInstance();//打印当前系统时间
         //冒泡排序所用时间
         System.out.println("冒泡排序前的时间为："+calendar.getTime());
         bubble.sort(arr);
         calendar=Calendar.getInstance();
         System.out.println("冒泡排序后的时间为："+calendar.getTime());//打印排序后的时间*/
         //选择排序所用时间
         System.out.println("选择排序前的时间为："+calendar.getTime());
         select.sort(arr);
         calendar=Calendar.getInstance();
         System.out.println("选择排序后的时间为："+calendar.getTime());//打印排序后的时间*/
         //插入排序所用时间
         System.out.println("插入排序前的时间为："+calendar.getTime());
         insert.sort(arr);
         calendar=Calendar.getInstance();
         System.out.println("插入排序后的时间为："+calendar.getTime());//打印排序后的时间*/
         //快速排序所用时间
         System.out.println("快速排序前的时间为："+calendar.getTime());
         quick.sort(0, arr.length-1, arr);
         calendar=Calendar.getInstance();
         System.out.println("快速排序后的时间为："+calendar.getTime());//打印排序后的时间
         //冒泡排序后的结果
         bubble.sort(arr);
         System.out.println("冒泡排序之后的数组顺序为：");
         for(int i=0;i<arr.length;i++)
         {
             System.out.print(arr[i]+" ");
         }
         System.out.println();
         //选择排序后的结果
         select.sort(arr);
         System.out.println("选择排序之后的数组顺序为：");
         for(int i=0;i<arr.length;i++)
         {
             System.out.print(arr[i]+" ");
         }
         System.out.println();
         //插入排序的结果
         insert.sort(arr);
         System.out.println("插入排序之后的数组顺序为：");
         for(int i=0;i<arr.length;i++)
         {
             System.out.print(arr[i]+" ");
         }
         System.out.println();
         //快速排序的结果
         quick.sort(0, arr.length-1, arr);
         System.out.println("快速排序之后的数组顺序为：");
         for(int i=0;i<arr.length;i++)
         {
             System.out.print(arr[i]+" ");
         }
     }

 }
 //快速排序
 class Quick{
     public void sort(int fist,int last,int arry[]){
         int f=fist;
         int l=last;
         int mid=arry[(fist+last)/2];
         int temp=0;
         while(f<l){
             while(arry[f]<mid) f++;
             while(arry[l]>mid) l--;
             if(f>=l) break;
             temp=arry[f];
             arry[f]=arry[l];
             arry[l]=temp;
             if(arry[f]==mid) --l;
             if(arry[l]==mid) ++f;
             }
         if(f==l){
             f++;
             l--;
         }
         //利用递归快速排序
         if(fist<l) sort(fist,l,arry);
         if(last>f) sort(f,last,arry);
     }
 }
 //插入排序
 class Insert{
     public void sort(int arry[]){
         for(int i=1;i<arry.length;i++)
         {
             int InsertNum=arry[i];
             int Index=i-1;
             while(Index>=0&&InsertNum<arry[Index])
             {
                 arry[Index+1]=arry[Index];//将前一个数复制给后一个比他小的数
                 Index--;
             }
             arry[Index+1]=InsertNum;//将该插入的数复制给前一个较小的数
         }
     }
 }
 //冒泡排序
 class Bubble{
     public void sort(int arry[]){
         int temp=0;
         for(int i=0;i<arry.length-1;i++)
         {
             for(int j=0;j<arry.length-i-1;j++)
             {
                 if(arry[j]>arry[j+1])
                 {
                     temp=arry[j];
                     arry[j]=arry[j+1];
                     arry[j+1]=temp;
                 }
             }
         }
     }
 }
 //选择排序
 class Select{
     public void sort(int arry[]){
         int temp=0;
         for(int i=0;i<arry.length-1;i++)
         {
             int min=arry[i];
             int minIndex=i;
             for(int j=i+1;j<arry.length-1;j++)
             {
                 if(min>arry[j])
                 {
                     min=arry[j];
                     minIndex=j;
                 }
             }
             temp=arry[i];
             arry[i]=arry[minIndex];
             arry[minIndex]=temp;
         }
     }
 }