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個隨機資料的陣列進行排序，

測試結果：

其他排序方式的時間、空間複雜度表：