java实现各种排序算法(包括冒泡排序，选择排序，插入排序，快速排序（简洁版）)及性能测试

1、冒泡排序是排序里面最简单的了，但性能也最差，数量小的时候还可以，数量一多，是非常慢的。

     它的时间复杂度是O（n*n），空间复杂度是O（1）

     代码如下，很好理解。

public static void bubbleSort(int[] arr){
		for(int i=0;i<arr.length;i++){
			for(int j=0;j<arr.length-1-i;j++){
				if(arr[j]>arr[j+1]){
					int temp =arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
			
			/*System.out.print("bubblesort 第"+(i+1)+"次排序：");
			for(int m=0;m<arr.length;m++){
				System.out.print(arr[m]+"\t");
			}
			System.out.println();*/
		}
	}

2、选择排序（最慢）

     选择排序的时间复杂度还有空间复杂度跟冒泡是一样的。

     实现代码如下：

public static 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;
				}
			}
			
			/*System.out.print("choosesort 第"+(i+1)+"次排序：");
			for(int m=0;m<arr.length;m++){
				System.out.print(arr[m]+"\t");
			}
			System.out.println();*/
		}
	}

3、插入排序

     插入排序的时间复杂度也是O(n*n)，空间复杂度也是O(1)。

     实现代码如下：

public static void insertSort(int[] arr){
		for(int i=1;i<arr.length;i++){
			for(int j=0;j<i;j++){
				if(arr[i]<arr[j]){
					int temp=arr[i];
					arr[i]=arr[j];
					arr[j]=temp;
				}
			}
			
			/*System.out.print("insertSort 第"+i+"次排序：");
			for(int m=0;m<arr.length;m++){
				System.out.print(arr[m]+"\t");
			}
			System.out.println();*/
		}
	}

4、快速排序（最快）

     快速排序通常情况下是最快的，名不虚传啊~平均时间复杂度是 O(Nlog2N)，最差也是O(N*N)，空间复杂度O(Nlog2N) 

public static void quickSort(int[] arr,int head,int tail){
		int i=head,j=tail;
		if(i>j){
			return;
		}
		int key=arr[i];
		while (i<j) {
			while(i<j && key<=arr[j]){
				j--;
			}
			if(i<j){
				arr[i++]=arr[j];
			}
			while(i<j && key>=arr[i]){
				i++;
			}
			if(i<j){
				arr[j--]=arr[i];
			}
		}
		arr[j]=key;
		quickSort(arr, head, j-1);
		quickSort(arr, j+1, tail);
	}

下面就是性能测试了~

下面这个算法生成长度为100000的随机数组，然后在main方法中测排序时间。

代码如下：

public static int[] getArr(){
		int arr[]=new int[100000];
		for(int i=0;i<arr.length;i++){
			arr[i]=new Random().nextInt(arr.length)+1;
		}
		return arr;
	}

测试各排序算法所花费的时间：

public static void main(String[] args) {
	
		int arr1[]=getArr();
		int arr2[]=getArr();
		int arr3[]=getArr();
		int arr4[]=getArr();
		
		long s1=System.currentTimeMillis();
		bubbleSort(arr1);
		long e1=System.currentTimeMillis();
		System.out.println("bubbleSort:"+(e1-s1)+"毫秒");
		
		long s2=System.currentTimeMillis();
		chooseSort(arr2);
		long e2=System.currentTimeMillis();
		System.out.println("chooseSort:"+(e2-s1)+"毫秒");
		
		long s3=System.currentTimeMillis();
		insertSort(arr3);
		long e3=System.currentTimeMillis();
		System.out.println("insertSort:"+(e3-s3)+"毫秒");
		
		long s4=System.currentTimeMillis();
		quickSort(arr4, 0, arr4.length-1);
		long e4=System.currentTimeMillis();
		System.out.println("quickSort:"+(e4-s4)+"毫秒"); 
	}

测试结果如下：

可以看出快速排序是最快的十万个长度的数组仅需21毫秒，而选择排序花费31279毫秒，

31279/21=1489 选择排序所花费的时间差不多是快速排序的1489倍

不过快速排序也是付出了内存空间的代价，如果数据量过大，会出现StackOverFlow栈溢出异常哦~