先上一副各個排序演算法的比較圖（重點）
思想：氣泡排序是一種簡單的排序，它不斷的從頭開始訪問整個序列，如果當前的元素比下一個大，就交換，這樣在每一趟遍歷都能把當前未排序的序列中最大的元素找到並放到最後！（這個演算法的名字由來是因為大的元素會經由交換慢慢“浮”到數列的底端。）
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];
}
}話不多說上程式碼!!
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 協議》，轉載必須註明作者和本文連結