.
冒泡排序：
通過相鄰的兩個數的比較, 根據需要決定是否將兩個數互換位置, 然后將比較往前(或往后)推進. 最簡單的排序算法，直接上代碼。
for(i=0;i<length-1;i++) for(j=i+1;j<length;j++) if(arrayVal[i]>arrayVal[j]) { //置換位置 temp=arrayVal[i]; arrayVal[i]=arrayVal[j]; arrayVal[j]=temp; } }
選擇排序：
"選擇排序"就是第0個逐步和后面全部的比,比完0位置就得到最小的數,緊接着再從1位置對比后面的元素,以此類推,逐步得到從小到大的值.
for(int i = 0; i < arr.length - 1; i++) { int k = i; for(int j = k + 1; j < arr.length; j++){ if( arr[j] < arr[k]){ k =j; } //在內層循環結束，也就是找到本輪循環的最小的數以后，再進行交換 if( i != k) { int temp= arr[i]; arr[i] = arr[k]; arr[k] = temp; }
插入排序：
首先對數組的前兩個數據進行從小到大的排序。
接着將第三個數據與排好序的兩個數據比較，將第三個數據插入合適的位置。
然后將第四個數據插入到已排好序的前3個數據中。
....
// 第1個數肯定是有序的，從第2個數開始遍歷，依次插入有序序列
public static void insertionSort(int[] a){ for(int i = 1 ; i < a.length; i++){ int temp = a[i]; int j = i - 1; while( j >= 0 && temp < a[j]){ a[j+1] = a[j]; j--; } a[j+1] = temp; }
Shell排序算法：（希爾排序、縮小增量排序）：
Shell排序是基於插入排序的思想。
1.將有n個元素的數組分成n/2個數字序列，第1個數據和第n/2+1個數據為一對，...
2.一次循環使每一個序列對排好順序。
3.然后，變為n/4個序列，在次排序。
4.直到序列變為1個。
//希爾排序
public static void shellSort(int a[]){ for(int r = a.length/2 ; r >= 1; r/=2 ){ for(int i = r; i < a.length ; i++){ int temp = a[i]; int j = i - r; while(j >= 0 && temp < a[j]){ a[j+r] = a[j]; j -= r; } a[j+r] = temp; } } }
快速排序算法
1.在待排序的元素任取一個元素作為基准(通常選第一個元素，但最的選擇方法是從待排序元素中隨機選取一個作為基准)，稱為基准元素；
2.將待排序的元素進行分區，比基准元素大的元素放在它的右邊，比其小的放在它的左邊；
3.對左右兩個分區重復以上步驟直到所有元素都是有序的。
public static void quickSort3(int arr[],int _left,int _right){ int left = _left; int right = _right; int temp = 0; if(left <= right){ //待排序的元素至少有兩個的情況
temp = arr[left]; //待排序的第一個元素作為基准元素
while(left != right){ //從左右兩邊交替掃描，直到left = right
while(right > left && arr[right] >= temp){ right --; //從右往左掃描，找到第一個比基准元素小的元素
} arr[left] = arr[right]; while(left < right && arr[left] <= temp){ left ++; //從左往右掃描，找到第一個比基准元素大的元素
} arr[right] = arr[left]; } arr[right] = temp; //基准元素歸位
quickSort3(arr,_left,left-1); //對基准元素左邊的元素進行遞歸排序
quickSort3(arr, right+1,_right); //對基准元素右邊的進行遞歸排序
} }
堆排序算法
堆排序是利用堆這種數據結構而設計的一種排序算法，堆排序是一種選擇排序，它的最壞，最好，平均時間復雜度均為O(nlogn)，它也是不穩定排序。首先簡單了解下堆結構。
堆：
堆是具有以下性質的完全二叉樹：
每個結點的值都大於或等於其左右孩子結點的值，稱為大頂堆；或者每個結點的值都小於或等於其左右孩子結點的值，稱為小頂堆。
堆排序的基本思想：將待排序序列構造成一個大頂堆，此時，整個序列的最大值就是堆頂的根節點。將其與末尾元素進行交換，此時末尾就為最大值。然后將剩余n-1個元素重新構造成一個堆，這樣會得到n個元素的次小值。如此反復執行，便能得到一個有序序列了。
堆排序的基本步驟：
1.構造初始堆。將給定無序序列構造成一個大頂堆（一般升序采用大頂堆，降序采用小頂堆)。
2.將堆頂元素與末尾元素進行交換，使末尾元素最大。然后繼續調整堆，再將堆頂元素與末尾元素交換，得到第二大元素。如此反復進行交換、重建、交換。
public class HeapSort { public static void main(String []args){ int []arr = {9,8,7,6,5,4,3,2,1}; sort(arr); System.out.println(Arrays.toString(arr)); } public static void sort(int []arr){ //1.構建大頂堆
for(int i=arr.length/2-1;i>=0;i--){
adjustHeap(arr,i,arr.length); }
for(int j=arr.length-1;j>0;j--){ swap(arr,0,j);
adjustHeap(arr,0,j);
} } // 調整大頂堆
public static void adjustHeap(int []arr,int i,int length){ int temp = arr[i];
for(int k=i*2+1;k<length;k=k*2+1){
if(k+1<length && arr[k]<arr[k+1]){
k++; } if(arr[k] >temp){//如果子節點大於父節點，將子節點值賦給父節點
arr[i] = arr[k]; i = k; }else{ break; } } arr[i] = temp;
} //交換元素
public static void swap(int []arr,int a ,int b){ int temp=arr[a]; arr[a] = arr[b]; arr[b] = temp; } }
歸並排序
歸並排序（MERGE-SORT）是利用歸並的思想實現的排序方法，該算法采用經典的分治（divide-and-conquer）策略（分治法將問題分(divide)成一些小的問題然后遞歸求解，而治(conquer)的階段則將分的階段得到的各答案"修補"在一起，即分而治之)。
public class MergeSort { public static void main(String []args){ int []arr = {9,8,7,6,5,4,3,2,1}; sort(arr); System.out.println(Arrays.toString(arr)); } public static void sort(int []arr){ int []temp = new int[arr.length];//在排序前，先建好一個長度等於原數組長度的臨時數組，避免遞歸中頻繁開辟空間
sort(arr,0,arr.length-1,temp); } private static void sort(int[] arr,int left,int right,int []temp){ if(left<right){ int mid = (left+right)/2; sort(arr,left,mid,temp);//左邊歸並排序，使得左子序列有序
sort(arr,mid+1,right,temp);//右邊歸並排序，使得右子序列有序
merge(arr,left,mid,right,temp);//將兩個有序子數組合並操作
} } private static void merge(int[] arr,int left,int mid,int right,int[] temp){ int i = left;
int j = mid+1;
int t = 0;
while (i<=mid && j<=right){ if(arr[i]<=arr[j]){ temp[t++] = arr[i++]; }else { temp[t++] = arr[j++]; } } while(i<=mid){
temp[t++] = arr[i++]; } while(j<=right){
temp[t++] = arr[j++]; } t = 0; //將temp中的元素全部拷貝到原數組中
while(left <= right){ arr[left++] = temp[t++]; } } }
各個排序算法比較：
| 排序算法 | 平均速度 | 最壞情況 | 是否穩定 |
| 冒泡排序 | O( n^2) | O( n^2) | 穩定 |
| 快速排序 | O(nlogn) | O( n^2) | 不穩定 |
| 選擇排序 | O( n^2) | O( n^2) | 不穩定 |
| 插入排序 | O( n^2) | O( n^2) | 穩定 |
| 堆排序 | O(nlogn) | O(nlogn) | 不穩定 |
| Shell排序 | O( n^(3/2) ) | O( n^2) | 不穩定 |
| 合並排序 | O(nlogn) | O(nlogn) | 穩定 |