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

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 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[n]中选出最小的记录，将它与r[1]交换；

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

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

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

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

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

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

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

测试结果：

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

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

猜你喜欢