1. 程式人生 > >java實現各種排序演算法(包括氣泡排序,選擇排序,插入排序,快速排序(簡潔版))及效能測試

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棧溢位異常哦~