氣泡排序

氣泡排序的主要的思想是：比較兩個相鄰的元素，如果左邊大於右邊的話就交換兩個元素的位置。
這樣的背景下：需要兩層迴圈，外層迴圈根據陣列中數目的多少確定迴圈次數，而內層的迴圈根據每次比較的次數確定迴圈次數。這樣做的時間複雜度為O（n^2）

	public class BubbleSort {
	public static void bubbleSort(int[] arr){
		if(arr == null )return ;
		for(int i=0;i<arr.length;i++){
			for(int j=0;j<arr.length-i-1;j++){
				if(arr[j]>arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
	}
	public static void main(String[] args){
		int[] arr = {3,4,2,1,7,6};
		bubbleSort(arr);
		System.out.println(Arrays.toString(arr));
	}
}
 

插入排序

插入排序的優點在於：插入排序可以減少我們的空間複雜度都是在原地上進行插入的所以空間複雜度比較低。
主要的思想是：每個當前元素的數跟其下一個元素進行比較，如果小於下一個元素，則把下個元素拿出來挨個與上面的元素進行比較，然後把上面的元素依次下沉一個位置。
時間複雜度也為O(n^2)，我看到的一個很好的解釋的圖如下所示，參考的博文的地址如下。

https://www.cnblogs.com/kkun/archive/2011/11/23/2260265.html
上面是參考的博文的地址。
具體的程式碼實現

	import java.util.Arrays;

public class InsertSort {
	public static void insertSort(int[] arr){
		if(arr == null ) return;
		for(int i=0;i<arr.length-1;i++){
//			int temp = arr[i];
			if(arr[i] > arr[i+1]){
				int j = i;
				int temp = arr[i+1];
				while(j>=0 && arr[j]  > temp){
					arr[j+1] = arr[j];
					j--;
				}
				arr[j+1] = temp;
			}
		}
	}
	public static void main(String[] args){
		int[] arr = {3,4,1,2,5,7};
		insertSort(arr);
		System.out.println(Arrays.toString(arr));
	}
}
 

快速排序

快速排序：排序演算法跟名字一樣，快速排序時間複雜度為O（nlogn）。
主要的思想在於：

1. 設定一個初始的參考值，然後設定一個前指標和一個後指標進行比較
2. 如果後指標指向的數字小於參考值的話，那麼便交換前指標和後指標的值，然後考慮前指標
3. 如果前指標指向的數字大於參考值的，那麼同理也交換前指標和後指標的值。再考後指標
4. 這樣迴圈指導前指標與後指標重合，讓當前指標的數字賦值為參考值，這樣便得到一個數組在index前面都小於參考值，在index後面都大於當前值。通過二分的方法把指標變換就能得到一個排序的陣列。
   程式碼實現如下所示

import java.util.Arrays;

public class QuickSort {
   public static void quickSort(int[] arr,int start,int end){
   	if(start >= end){
   		return;
   	}
   	int index = partation(arr,start,end);
   	quickSort(arr,start,index-1);
   	quickSort(arr,index+1,end);
   }
   public static int  partation(int[] arr,int start,int end){	
   	int key = arr[start];//base參考值
   	while(start < end){
   		while(arr[end] > key && start < end){
   			end--;
   		}
   		arr[start] = arr[end];
   		while(arr[start] <= key && start < end){
   			start++;
   		}
   		arr[end] = arr[start];
   	}
   	int index = end;
   	arr[end] = key;
   	return index;
   }
   public static void main(String[] args){
   	int[] arr = {3,4,2,1,7,6};
   	quickSort(arr,0,arr.length-1);
   	System.out.println(Arrays.toString(arr));
   }
}
 

歸併排序

遞迴排序的時間複雜度是O(nlogn),空間複雜度是O(n)
歸併排序的主要的思想是分為兩步：
1：先把所有的數字且分到最小的粒度，即兩個數字
2：然後歸併，遞迴的歸併。
如圖所示：參考的部落格的地址
https://www.cnblogs.com/chengxiao/p/6194356.html

具體的程式碼實現如下：

public class MergeSort {
	public static void sort(int[] arr,int start,int end,int[] temp){//利用temp陣列來儲存排序以後的陣列。
		if(start < end){
			int mid = (end + start)/2;
			sort(arr,start,mid,temp);
			sort(arr,mid+1,end,temp);
			mergeSort(arr,start,mid,end,temp);
		}
	}
	public static void mergeSort(int[] arr,int start,int mid,int end,int[] temp){
		int i=start;
		int j=mid+1;
		int t=0;
		while(i<=mid && j<=end){
			if(arr[i]<=arr[j]){
				temp[t++] = arr[i++];
			}else{
				temp[t++] = arr[j++];
			}
		}
		while(i<=mid){
			temp[t++] = arr[i++];
		}
		while(j<=end){
			temp[t++] = arr[j++];
		}
		t=0;
		while(start<=end){
			arr[start++] = temp[t++];
		}
	}
	public static void main(String[] args){
        int []arr = {9,8,7,6,5,4,3,2,1};
        int[] temp = new int[arr.length];
        sort(arr,0,arr.length-1,temp);
        System.out.println(Arrays.toString(arr));
	}
}

堆排序明天再寫