先上一副各個排序演算法的比較圖（重點）
思想：氣泡排序是一種簡單的排序，它不斷的從頭開始訪問整個序列，如果當前的元素比下一個大，就交換，這樣在每一趟遍歷都能把當前未排序的序列中最大的元素找到並放到最後！（這個演算法的名字由來是因為大的元素會經由交換慢慢“浮”到數列的底端。）
for (int i = 0; i < len -1; i++) { //遍歷的次數，len-1即可，最後一遍第一個元素無需在進行
for(int j = 0;j<len - 1 - i;j++){
//注意要減去i哦，畢竟每一次遍歷都能讓最後的i+1個數有序！
if(arr[j] > arr[j+1]){
temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
System.out.println("第"+(i+1)+"趟排序後:"+Arrays.toString(arr) );
}
氣泡排序演算法改進！
透過加上一個標誌位，判斷自此遍歷有無交換，若無交換，則說明當前序列儼然有序！無需再進行遍歷！這樣會導致最好情況下時間複雜度為O(n)!
#
boolean flag = false; //是否交換
for (int i = 0; i < len - 1; i++) {
//遍歷的次數，len-1即可，最後一遍第一個元素無需進行
flag = false;
for (int j = 0; j < len - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
flag = true;
}
}
if (!flag) {
break;
}
}首先，找到陣列中最小的那個元素的下標，其次，將它和陣列的第一個元素交換位置(如果第一個元素就是最小元素那麼它就和自己交換)。其次，在剩下的元素中找到最小的元素，將它與陣列的第二個元素交換位置。如此往復，直到將整個陣列排序。
int minIndex = 0;
int temp;
for (int i = 0; i < len - 1; i++) { //遍歷的次數，len-1即可，最後一個元素無需在進行
minIndex = i;
for (int j = i ; j < len; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j; // 不斷更新下標導致了該演算法的不穩定性
}
}
if(minIndex != i){ //判斷一下，是否等於自身，等於自身說明自身是最小，而無需交換
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}插入排序是一種簡單直觀的排序演算法。它的工作原理是透過構建有序序列，對於未排序資料，在已排序序列中從後向前掃描，找到相應位置並插入。
for (int i = 1; i < len; i++) { //從1開始是認定第一個元素已經有序
int cur = arr[i]; //當前要插入的元素
int pos = i - 1; //有序序列的最後一個元素下標
while (pos >= 0 && arr[pos] > cur ){
arr[pos + 1] = arr[pos];
pos--;
}
arr[pos + 1] = cur;
}歸併排序是建立在歸併操作上的一種有效的排序演算法。該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。將已有序的子序列合併，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱為2-路歸併。
過程如下圖所示
話不多說上程式碼！
public static void mergesort(int[] arr, int L, int R) {
if (L >= R) {
return;
}
int mid = L + ((R - L) >> 1); //分治，分成兩部分！
mergesort(arr, L, mid);//左半部分繼續遞迴分治
mergesort(arr, mid + 1, R);//右半部分繼續遞迴分治
merge(arr, L, R, mid);//合併！！！
}
public static void merge(int[] arr, int l, int r, int mid) {
int i = l;
int j = mid + 1;
int[] res = new int[r - l + 1]; //額外陣列空間
int index = 0;
while (i <= mid && j <= r) {
if (arr[i] > arr[j]) {
res[index++] = arr[j++];
} else {
res[index++] = arr[i++];
}
}
while (i <= mid) {
res[index++] = arr[i++];
}
while (j <= r) {
res[index++] = arr[j++];
}
for (int k = l; k <= r; k++) {
arr[k] = res[k - l];
}
}關於歸併排序的空間複雜度分析
歸併排序每次遞迴需要用到一個輔助表，長度與待排序的表相等，雖然遞迴次數是O(log2n)，但每次遞迴都會釋放掉所佔的輔助空間，所以下次遞迴的棧空間和輔助空間與這部分釋放的空間就不相關了，因而空間複雜度還是O（n）。
堆排序是利用堆這種資料結構而設計的一種排序演算法，堆排序是一種選擇排序，它的最壞，最好，平均時間複雜度均為O(nlogn)，它也是不穩定排序。
堆是具有以下性質的完全二叉樹：每個結點的值都大於或等於其左右孩子結點的值，稱為大頂堆；或者每個結點的值都小於或等於其左右孩子結點的值，稱為小頂堆。如下圖：
堆排序的基本思想是：將待排序序列構造成一個大頂堆，此時，整個序列的最大值就是堆頂的根節點。將其與末尾元素進行交換，此時末尾就為最大值。然後將剩餘n-1個元素重新構造成一個堆，這樣會得到n個元素的次小值。如此反覆執行，便能得到一個有序序列了
public void heapSort(int[] arr) {
//建堆！
for (int i = arr.length / 2 - 1; i >= 0; i--) {
//從第一個非葉子節點從下到上，從右到左建堆！
adjustHeap(arr, i, arr.length);
}
//將第一個與最後一個交換，再調整堆
for (int i = arr.length - 1; i > 0; i--) {
swap(arr, 0, i);
adjustHeap(arr, 0, i);
}
}
public void adjustHeap(int[] arr, int i, int len) {
int temp = arr[i];
for (int j = 2 * i + 1; j < len; j = 2 * j + 1) {
if (j + 1 < len && arr[j] < arr[j + 1]) {
//如果左節點小於右節點，則定位於右節點
j++;
}
if (temp < arr[j]) {
arr[i] = arr[j];
i = j;
}else{
break;
}
}
arr[i] = temp;
}
public void swap(int[] arr, int i, int j) {
int temp = arr[i] ^ arr[j];
arr[i] = arr[i] ^ temp;
arr[j] = arr[j] ^ temp;
}話不多說上程式碼!!
public void sort(int[] arr, int L, int R) {
if (L < R) {
int[] res = partition(arr, L, R);
sort(arr, 0, res[0] - 1);
sort(arr, res[1] + 1, R);
}
}
public int[] partition(int[] arr, int L, int R) { //partition過程！
if (L == R) {
return new int[]{L, L};
}
int left = L - 1;
int right = R;
int cur = L;
while (cur < right) {
if (arr[cur] < arr[R]) {
swap(arr, cur++, ++left);
} else if (arr[cur] > arr[R]) {
swap(arr, cur, --right);
} else {
cur++;
}
}
swap(arr, cur, R);
return new int[]{left + 1, cur};
}
public void swap(int[] arr, int i, int j) {
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}本作品採用《CC 協議》，轉載必須註明作者和本文連結