冒泡排序、选择排序、插入排序、快速排序算法耗时测试

import java.util.*;
public class Test1
{
public static void main(String[] args) throws Exception{

int[] arr1=new int[20000];
for(int i=0;i<arr1.length;i++){
arr1[i]=new Random().nextInt(20000);
}
int[] arr2=new int[20000];
for(int i=0;i<arr2.length;i++){
arr2[i]=new Random().nextInt(20000);
}
int[] arr3=new int[20000];
for(int i=0;i<arr3.length;i++){
arr3[i]=new Random().nextInt(20000);
}
int[] arr4=new int[20000];
for(int i=0;i<arr4.length;i++){
arr4[i]=new Random().nextInt(20000);
}
int []arr5=new int[20000];
for(int i=0;i<arr5.length;i++){
arr5[i]=new Random().nextInt(20000);
}
int []arr6=new int[20000];
for(int i=0;i<arr6.length;i++){
arr6[i]=new Random().nextInt(20000);
}
MySortTest t=new MySortTest();
long tm1=System.currentTimeMillis();
t.bubbleSort(arr1);
long tm2=System.currentTimeMillis();
System.out.println("冒泡排序耗时："+(tm2-tm1)+"ms");
long tm3=System.currentTimeMillis();
t.chooseSort(arr2);
long tm4=System.currentTimeMillis();
System.out.println("选择排序耗时："+(tm4-tm3)+"ms");
long tm5=System.currentTimeMillis();
t.insertSort(arr4);
long tm6=System.currentTimeMillis();
System.out.println("插入排序耗时："+(tm6-tm5)+"ms");
long tm7=System.currentTimeMillis();
t.quickSort(arr3, 0, arr3.length-1);
long tm8=System.currentTimeMillis();
System.out.println("快速排序耗时："+(tm8-tm7)+"ms");
long tm9=System.currentTimeMillis();
t.whatSort(arr5);
long tm10=System.currentTimeMillis();
System.out.println("这是啥排序耗时:"+(tm10-tm9)+"ms");
long tm11=System.currentTimeMillis();
Arrays.sort(arr6);
long tm12=System.currentTimeMillis();
System.out.println("JAVA自带的排序耗时:"+(tm12-tm11)+"ms");

}
}
class MySortTest
{
//冒泡排序
public void bubbleSort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-i-1;j++){
if(arr[j]>arr[j+1]){
int temp=arr[j+1];
arr[j+1]=arr[j];
arr[j]=temp;
}
}
}

}
//选择排序
public void chooseSort(int[] arr){
for(int i=0;i<arr.length;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
}
//插入排序
public void insertSort(int[] arr){
for(int j=1;j<arr.length;j++){
for(int
4000
i=0;i<j;i++){
if(arr[i]>arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
}
//快速排序
public void quickSort(int[] arr,int left,int right){
int i=left;
int j=right;
if(i > j){
return;
}
int temp=arr[i];
while(i<j){
while(i<j && temp<=arr[j]){
j--;
}
if(i<j){
arr[i++]=arr[j];
}
while(i<j && temp>=arr[i]){
i++;
}
if(i<j){
arr[j--]=arr[i];
}
}
arr[j]=temp;
quickSort(arr,left,j-1);
quickSort(arr,j+1,right);
}
//这是啥排序
public void whatSort(int[] arr){
for(int i=0;i<arr.length;i++){
for(int j=arr.length-1;j>i;j--){
if(arr[i]>arr[j]){
int temp=arr[j];
arr[j]=arr[i];
arr[i]=temp;
}
}
}
}
}

冒泡排序： 1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
   
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

选择排序：    第1趟，在待排序记录r[1]~r
中选出最小的记录，将它与r[1]交换；

第2趟，在待排序记录r[2]~r
中选出最小的记录，将它与r[2]交换；

以此类推，第i趟在待排序记录r[i]~r
中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。

插入排序： 插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开
始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素
相等的，那么插入元素把想插入的元素放在相等元素的后面。

快速排序： 首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速
排序，整个排序过程可以递归进行。

最后一个： i从左往右遍历，j从右往左遍历，若i对应的数字比j对应的数字大，则交换，直到i和j相等，则排序完成。

这是啥排序呢？估计就是上面其中一个排序，换了个循环方式，我就不认得它了，哎。

对包含20000个随机数据的数组进行排序，

测试结果：



其他排序方式的时间、空间复杂度表：