寫在前面
本文描述了常見的幾種排序算法，文章可能還有很多不足，請大家諒解，歡迎大佬提意見。
本文使用到的東西
- java
1.選擇排序
1. 1 算法思想
從未排序的區間中找出最小的元素，將該元素與未排序區間中第一個元素交換，第一個元素即爲排序好的元素，再繼續比較餘下未排序的區間…
1.2 算法實現
import java.util.Arrays;
public class DSort {
public static void 選擇排序(int[] list) {
int num=1;
for(int i=0;i<list.length-1;i++) {
int min=i; //記錄最小元素的序號
for(int j=i+1;j<list.length;j++) {
if(list[min]>list[j]) {
min=j;
}
}
if(min!=i) {
int test=list[min];
list[min]=list[i];
list[i]=test;
System.out.println("第"+ num++ +"次排序："+Arrays.toString(list));
}
}
}
public static void main(String[] args) {
int[] list= {9,10,2,4,8,3,5,1,6,7};
選擇排序(list);
}
}
1.3 執行結果
第1次排序：[1, 10, 2, 4, 8, 3, 5, 9, 6, 7]
第2次排序：[1, 2, 10, 4, 8, 3, 5, 9, 6, 7]
第3次排序：[1, 2, 3, 4, 8, 10, 5, 9, 6, 7]
第4次排序：[1, 2, 3, 4, 5, 10, 8, 9, 6, 7]
第5次排序：[1, 2, 3, 4, 5, 6, 8, 9, 10, 7]
第6次排序：[1, 2, 3, 4, 5, 6, 7, 9, 10, 8]
第7次排序：[1, 2, 3, 4, 5, 6, 7, 8, 10, 9]
第8次排序：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
2.冒泡排序
2.1 算法思想
從前往後比較未排序的元素，將逆順序的元素交換，循環比較一次之後，最後一個未排序元素即爲排序好的元素，再繼續從前往後比較未排序的元素…
2.2 算法實現
public class DSort {
public static void 冒泡排序(int[] list) {
int num=1;
for(int i=0;i<list.length;i++) {
for(int j=0;j<list.length-1-i;j++) {
if(list[j]>list[j+1]) {
//交換逆序元素
int test = list[j+1];
list[j+1]=list[j];
list[j]=test;
System.out.println("第"+ num++ +"次排序："+Arrays.toString(list));
}
}
}
}
public static void main(String[] args) {
int[] list= {9,10,2,4,8,3,5,1,6,7};
冒泡排序(list);
}
}
2.3 執行結果
第1次排序：[9, 2, 10, 4, 8, 3, 5, 1, 6, 7]
第2次排序：[9, 2, 4, 10, 8, 3, 5, 1, 6, 7]
第3次排序：[9, 2, 4, 8, 10, 3, 5, 1, 6, 7]
第4次排序：[9, 2, 4, 8, 3, 10, 5, 1, 6, 7]
第5次排序：[9, 2, 4, 8, 3, 5, 10, 1, 6, 7]
第6次排序：[9, 2, 4, 8, 3, 5, 1, 10, 6, 7]
第7次排序：[9, 2, 4, 8, 3, 5, 1, 6, 10, 7]
第8次排序：[9, 2, 4, 8, 3, 5, 1, 6, 7, 10]
第9次排序：[2, 9, 4, 8, 3, 5, 1, 6, 7, 10]
第10次排序：[2, 4, 9, 8, 3, 5, 1, 6, 7, 10]
第11次排序：[2, 4, 8, 9, 3, 5, 1, 6, 7, 10]
第12次排序：[2, 4, 8, 3, 9, 5, 1, 6, 7, 10]
第13次排序：[2, 4, 8, 3, 5, 9, 1, 6, 7, 10]
第14次排序：[2, 4, 8, 3, 5, 1, 9, 6, 7, 10]
第15次排序：[2, 4, 8, 3, 5, 1, 6, 9, 7, 10]
第16次排序：[2, 4, 8, 3, 5, 1, 6, 7, 9, 10]
第17次排序：[2, 4, 3, 8, 5, 1, 6, 7, 9, 10]
第18次排序：[2, 4, 3, 5, 8, 1, 6, 7, 9, 10]
第19次排序：[2, 4, 3, 5, 1, 8, 6, 7, 9, 10]
第20次排序：[2, 4, 3, 5, 1, 6, 8, 7, 9, 10]
第21次排序：[2, 4, 3, 5, 1, 6, 7, 8, 9, 10]
第22次排序：[2, 3, 4, 5, 1, 6, 7, 8, 9, 10]
第23次排序：[2, 3, 4, 1, 5, 6, 7, 8, 9, 10]
第24次排序：[2, 3, 1, 4, 5, 6, 7, 8, 9, 10]
第25次排序：[2, 1, 3, 4, 5, 6, 7, 8, 9, 10]
第26次排序：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
3.插入排序
3.1 算法思想
最初認爲第一個元素是一個有序的元素區間，將有序元素區間中比未排序區間中第一個元素大的元素全部後移一位，再用未排序元素區間的第一個元素補充空缺。循環以上步驟，直到未排序區間爲空。
3.2 算法實現
import java.util.Arrays;
public class DSort {
public static void 插入排序(int[] list) {
int num=1;
for(int i=1;i<list.length;i++) {
int test=list[i];
int j=i-1;
while(j>=0 && list[j]>test) {
list[j+1]=list[j];
j--;
}
list[j+1]=test;
System.out.println("第"+ num++ +"次排序："+Arrays.toString(list));
}
}
public static void main(String[] args) {
int[] list= {9,10,2,4,8,3,5,1,6,7};
插入排序(list);
}
}
3.3 執行結果
第1次排序：[9, 10, 2, 4, 8, 3, 5, 1, 6, 7]
第2次排序：[2, 9, 10, 4, 8, 3, 5, 1, 6, 7]
第3次排序：[2, 4, 9, 10, 8, 3, 5, 1, 6, 7]
第4次排序：[2, 4, 8, 9, 10, 3, 5, 1, 6, 7]
第5次排序：[2, 3, 4, 8, 9, 10, 5, 1, 6, 7]
第6次排序：[2, 3, 4, 5, 8, 9, 10, 1, 6, 7]
第7次排序：[1, 2, 3, 4, 5, 8, 9, 10, 6, 7]
第8次排序：[1, 2, 3, 4, 5, 6, 8, 9, 10, 7]
第9次排序：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
4.希爾排序
4.1 算法思想
希爾排序也叫縮小增量排序，先將待排序區間分爲，多個交叉的待排序序列，每個序列執行插入排序。再將序列數量減少，直到序列數量爲1.
4.2 算法實現
import java.util.Arrays;
public class DSort {
public static void 希爾排序(int[] list) {
int num=1;
int n=list.length/2; //初始序列數
while(n>=1) {
for(int i=0;i<n;i++) { //每個序列執行插入排序
for(int j=i+n;j<list.length;j+=n) {
int test=list[j];
int k=j-n;
while(k>=0 && list[k]>test) {
list[k+n]=list[k];
k-=n;
}
list[k+n]=test;
}
System.out.println("第"+ num++ +"次排序："+Arrays.toString(list));
}
n/=2; //序列數減半
}
}
public static void main(String[] args) {
int[] list= {9,10,2,4,8,3,5,1,6,7};
希爾排序(list);
}
}
4.3 執行結果
第1次排序：[3, 10, 2, 4, 8, 9, 5, 1, 6, 7]
第2次排序：[3, 5, 2, 4, 8, 9, 10, 1, 6, 7]
第3次排序：[3, 5, 1, 4, 8, 9, 10, 2, 6, 7]
第4次排序：[3, 5, 1, 4, 8, 9, 10, 2, 6, 7]
第5次排序：[3, 5, 1, 4, 7, 9, 10, 2, 6, 8]
第6次排序：[1, 5, 3, 4, 6, 9, 7, 2, 10, 8]
第7次排序：[1, 2, 3, 4, 6, 5, 7, 8, 10, 9]
第8次排序：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
5.歸併排序
5.1 算法思想
將數組分解爲小的區間，先使小區間有序，再合併小區間。
5.2 算法實現
import java.util.Arrays;
public class DSort {
//test爲暫存數組
public static void 歸併排序(int[] list,int[] test,int start,int end) {
if(end<=start) return;
int local=(start+end)/2;
歸併排序(list,test,start,local);
歸併排序(list,test,local+1,end);
int p1=start,p2=local+1,k=start;
while(p1<=local && p2<=end) {
if(list[p1]<list[p2]) {
test[k++]=list[p1++];
}else {
test[k++]=list[p2++];
}
}
while(p1<=local) {
test[k++]=list[p1++];
}
while(p2<=end) {
test[k++]=list[p2++];
}
for(int i=start;i<=end;i++) {
list[i]=test[i];
}
System.out.println(Arrays.toString(list));
}
public static void main(String[] args) {
int[] list= {9,10,2,4,8,3,5,1,6,7};
歸併排序(list,new int[list.length],0,list.length-1);
}
}
5.3 執行結果
[9, 10, 2, 4, 8, 3, 5, 1, 6, 7]
[2, 9, 10, 4, 8, 3, 5, 1, 6, 7]
[2, 9, 10, 4, 8, 3, 5, 1, 6, 7]
[2, 4, 8, 9, 10, 3, 5, 1, 6, 7]
[2, 4, 8, 9, 10, 3, 5, 1, 6, 7]
[2, 4, 8, 9, 10, 1, 3, 5, 6, 7]
[2, 4, 8, 9, 10, 1, 3, 5, 6, 7]
[2, 4, 8, 9, 10, 1, 3, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
6.快速排序
6.1 算法思想
選擇一個數做基準，通過位移實現基準左側全部比基準小，基準右側全部比基準大。然後分別將基準左右側遞歸。
6.2 算法實現
import java.util.Arrays;
public class DSort {
public static void 快速排序(int[] list,int start,int end) {
if(start>=end) return;
int base=list[start]; //第一個數設置爲基準
int i=start,j=end;
while(i<j) {
while(i<j && list[j]>base) {
j--;
}
if(i<j) list[i++]=list[j];
while(i<j && list[i]<base) {
i++;
}
if(i<j) list[j--]=list[i];
}
list[i]=base;
System.out.println(Arrays.toString(list));
快速排序(list,start,i-1);
快速排序(list,i+1,end);
}
public static void main(String[] args) {
int[] list= {9,10,2,4,8,3,5,1,6,7};
快速排序(list,0,list.length-1);
}
}
6.3 執行結果
[7, 6, 2, 4, 8, 3, 5, 1, 9, 10]
[1, 6, 2, 4, 5, 3, 7, 8, 9, 10]
[1, 6, 2, 4, 5, 3, 7, 8, 9, 10]
[1, 3, 2, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
7.堆排序
7.1 算法思想
將數組構成一個類似完全二叉樹的堆，並初始化爲最大堆（遞增排序），再將根節點與堆的最後一個節點交換，則該節點即爲以排序節點，不再計入堆的範圍，堆長度減1。循環以上步驟，重新構建最大堆，直到堆長度爲1。
7.2 算法實現
import java.util.Arrays;
public class DSort {
public static void Adjust(int[] list,int i,int lenght) {
int max=i; //存儲最大值下標
int left=i*2+1; //i*2+1爲左孩子下標
int right=i*2+2; //i*2+2爲右孩子下標
//左孩子存在，且比父節點大
if(left<lenght && list[left]>list[max]) {
max=left;
}
//右孩子存在，且比最大值大
if(right<lenght && list[right]>list[max]) {
max=right;
}
if(max!=i) { //最大值不是父節點，交換值
int test=list[i];
list[i]=list[max];
list[max]=test;
//交換值破壞了子樹結構，遞歸構建最大堆
Adjust(list, max, lenght);
}
}
public static void 堆排序(int[] list) {
int num=1;
//list.length/2-1爲最後一個非葉子節點下標
for(int i=list.length/2-1;i>=0;i--) {
Adjust(list, i, list.length); //構建最大堆
System.out.println("第"+ num++ +"次排序："+Arrays.toString(list));
}
for(int i=list.length-1;i>0;i--) {
int test=list[i];
list[i]=list[0];
list[0]=test;
Adjust(list, 0, i); //重新構建最大堆
System.out.println("第"+ num++ +"次排序："+Arrays.toString(list));
}
}
public static void main(String[] args) {
int[] list= {9,10,2,4,8,3,5,1,6,7};
堆排序(list);
}
}
7.3 執行結果
第1次排序：[9, 10, 2, 4, 8, 3, 5, 1, 6, 7]
第2次排序：[9, 10, 2, 6, 8, 3, 5, 1, 4, 7]
第3次排序：[9, 10, 5, 6, 8, 3, 2, 1, 4, 7]
第4次排序：[9, 10, 5, 6, 8, 3, 2, 1, 4, 7]
第5次排序：[10, 9, 5, 6, 8, 3, 2, 1, 4, 7]
第6次排序：[9, 8, 5, 6, 7, 3, 2, 1, 4, 10]
第7次排序：[8, 7, 5, 6, 4, 3, 2, 1, 9, 10]
第8次排序：[7, 6, 5, 1, 4, 3, 2, 8, 9, 10]
第9次排序：[6, 4, 5, 1, 2, 3, 7, 8, 9, 10]
第10次排序：[5, 4, 3, 1, 2, 6, 7, 8, 9, 10]
第11次排序：[4, 2, 3, 1, 5, 6, 7, 8, 9, 10]
第12次排序：[3, 2, 1, 4, 5, 6, 7, 8, 9, 10]
第13次排序：[2, 1, 3, 4, 5, 6, 7, 8, 9, 10]
第14次排序：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
8.總結
對時間複雜度、空間複雜度計算還是不夠擅長，只能到時候再補充，希爾排序、堆排序稍微有些複雜，沒有圖片說明會比較難理解一些。可以複製代碼運行幫助理解。有不清楚的地方歡迎評論留言，看到的我都會回覆的。本文到此結束，有什麼不足的地方請大家不吝指正。
