簡單排序算法：冒泡排序，選擇排序，插入排序

一、冒泡排序

1.1 原理：

從第一個數據開始，與第二個數據相比較，如果第二個數據小于第一個數據，則交換兩個數據的位置

指針由第一個數據移向第二個數據，第二個數據與第三個數據相比較，如果第三個數據小于第二個數據，則交換兩個數據的位置

依此類推，完成第一輪排序。第一輪排序結束后，最大的元素被移到了最右面

依照上面的過程進行第二輪排序，將第二大的排在倒數第二的位置

重復上述過程，沒排完一輪，比較次數就減少一次

1.2 例子：

待排序數據：7, 6, 9, 8, 5,1

第一輪排序過程：

指針先指向7，7和6比較，6<7，交換6和7的位置，結果為：6,7,9,8,5,1

指針指向第二個元素7，7和9比較，9>7，不用交換位置，結果仍為：6,7,9,8,5,1

指針指向第三個元素9，比較9和8，8<9，交換8和9的位置，結果為：6,7,8,9,5,1

指針指向第四個元素9，比較9和5，5<9，交換5和9，結果為：6,7,8,5,9,1

指針指向第五個元素9，比較9和1，1<9，交換1和9的位置，結果為6,7,8,5,1,9

第一輪排序結束后，最大的數字9被移到了最右邊。

進行第二輪排序，過程同上，只是由于最大的9已經放在最右邊了，因此不用在比較9了，少了一次比較，
第二輪結束的結果為：6,7,5,1,8,9

第三輪結果：6,5,1,7,8,9

第四輪比較結果：5,1,6,7,8,9

第五輪比較結果：1,5,6,7,8,9

最終排序結果為：1,5,6,7,8,9，由上可知N個數據排序，需要進行N-1輪排序；第i輪排序需要的比較次數為N-i次。

1.3 代碼實現

//1.冒泡排序(默認升序)O(n*n) public void bobSort(int [] arr) {if(arr == null || arr.length<2) {return;}int temp=0, len = arr.length;for(int i=0;i<len;i++) {for(int j=i+1;j<len;j++) {if(arr[i] > arr[j]) {temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}} }

二、選擇排序

選擇排序是對冒泡排序的改進，它的比較次數與冒泡排序相同，但交換次數要小于冒泡排序。當數據量較大時，效率會有很大的提升，但時間復雜度仍為O(n*n)

2.1 原理：

從第一個元素開始，分別與后面的元素向比較，找到最小的元素與第一個元素交換位置

從第二個元素開始，分別與后面的元素相比較，找到剩余元素中最小的元素，與第二個元素交換

重復上述步驟，直到所有的元素都排成由小到大為止

2.2 例子：

待比較數據：7, 6, 9, 8, 5,1

第一輪：此時指針指向第一個元素7，找出所有數據中最小的元素，即1，交換7和1的位置，排序后的數據為：1,6,9,8,5,7

第二輪：第一個元素已經為最小的元素，此時指針指向第二個元素6，找到6,9,8,5,7中最小的元素，即5，交換5和6的位置，排序后的結果為：1,5,9,8,6,7

第三輪：前兩個元素為排好序的元素，此時指針指向第三個元素9，找到9,8,6,7中最小的元素，即6，交換6和9的位置，排序后的結果為：1,5,6,8,9,7

第四輪：前三個元素為排好序的元素，此時指針指向第四個元素8，找到8,9,7中最小的元素，即7，交換8和7的位置，排序后的結果為：1,5,6,7,9,8

第五輪：前四個元素為排好序的元素，此時指針指向第五個元素9，找到9,8中最小的元素，即8，交換9和8的位置，排序后的結果為：1,5,6,7,8,9

到此，全部排序完成。

分析：從上面的原理可以看出，與冒泡排序不同，選擇排序每排完一輪都把最小的元素移到了最左面，然后下一輪排序的比較次數比上一輪減少一次，即第i輪排序需要比較N-i次。因此，和冒泡排序一樣，N個數據比較大小，需要排序N-1輪，第i輪排序需要比較N-i次。

2.3 代碼實現

//2.選擇排序,相對冒泡來說，改進在于交換的次數減少 //(O(n*n)) public void chooseSort(int [] arr) {if(arr == null || arr.length<2) {return;}int len = arr.length, curIndex =0, temp=0 ;for(int i=0;i<len;i++) {curIndex = i;for(int j=0;j<len-i;j++) {if(arr[curIndex] > arr[j]) {curIndex = j;}}temp = arr[curIndex];arr[curIndex] = arr[len-i-1];arr[len-i-1] = temp;} }

3、插入排序

插入排序是簡單排序中最快的排序算法，雖然時間復雜度仍然為O(n*n)，但是卻比冒泡排序和選擇排序快很多。

3.1 原理：

將指針指向某個元素，假設該元素左側的元素全部有序，將該元素抽取出來，然后按照從右往左的順序分別與其左邊的元素比較，遇到比其大的元素便將元素右移，直到找到比該元素小的元素或者找到最左面發現其左側的元素都比它大，停止

此時會出現一個空位，將該元素放入到空位中，此時該元素左側的元素都比它小，右側的元素都比它大

指針向后移動一位，重復上述過程。每操作一輪，左側有序元素都增加一個，右側無序元素都減少一個

3.2 例子：

待比較數據：7, 6, 9, 8, 5,1

第一輪：指針指向第二個元素6，假設6左面的元素為有序的，將6抽離出來，形成7,,9,8,5,1，從7開始，6和7比較，發現7>6。將7右移，形成,7,9,8,5,1，6插入到7前面的空位，結果：6,7,9,8,5,1

第二輪：指針指向第三個元素9，此時其左面的元素6,7為有序的，將9抽離出來，形成6,7,_,8,5,1，從7開始，依次與9比較，發現9左側的元素都比9小，于是無需移動，把9放到空位中，結果仍為：6,7,9,8,5,1

第三輪：指針指向第四個元素8，此時其左面的元素6,7,9為有序的，將8抽離出來，形成6,7,9,,5,1，從9開始，依次與8比較，發現8<9，將9向后移，形成6,7,,9,5,1，8插入到空位中，結果為：6,7,8,9,5,1

第四輪：指針指向第五個元素5，此時其左面的元素6,7,8,9為有序的，將5抽離出來，形成6,7,8,9,,1，從9開始依次與5比較，發現5比其左側所有元素都小，5左側元素全部向右移動，形成,6,7,8,9,1，將5放入空位，結果5,6,7,8,9,1。

第五輪：同上，1被移到最左面，最后結果：1,5,6,7,8,9。

3.3 代碼實現

//插入排序(O(n*n),簡單排序算法里效率相對最好的) public void insertSort(int [] arr) {if(arr == null || arr.length<2) {return;}int len = arr.length, temp=0 ;for(int i=1;i<len;i++) {temp = arr[i];int j=i-1;for(;j>=0 && arr[j]>temp;j--) {arr[j+1] = arr[j];}if(j != i-1) {arr[j] = temp;}}}

4、測試代碼

public static void main(String[] args) {Test test = new Test();int[] arr = {77,29,28,36,33,25,10};test.bobSort(arr);System.out.println(Arrays.toString(arr));test.chooseSort(arr);System.out.println(Arrays.toString(arr));test.insertSort(arr);System.out.println(Arrays.toString(arr)); }

5、拓展

侏儒排序（類似直接插入排序，直接插入排序更優）
https://www.cnblogs.com/9-de/p/6600640.html

圖書館排序：
基于插入排序，做的優化為在每本書之間預留一定的空隙，然后在插入的時候就能少移動一些書。說白了就是在插入排序的基礎上,給書與書之間留一定的空隙,這個空隙越大,需要移動的書就越少,這是它的思路,用空間換時間

https://blog.csdn.net/u014723529/article/details/41958545

總結

以上是生活随笔為你收集整理的简单排序算法（Java实现）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。