java排序算法總結之冒泡排序,java中的冒泡排序法

本文目錄一覽：

1、Java冒泡排序中i、j各代表什麼意思？
2、算法- 冒泡排序（Bubble Sort）
3、java中冒泡排序算法的詳細解答以及程序？
4、JAVA 冒泡排序法的詳細解釋是什麼？
5、java冒泡排序法代碼
6、Java冒泡排序的原理？

Java冒泡排序中i、j各代表什麼意思？

沒有什麼特別的含義。

冒泡排序（Bubble Sort，台灣譯為：泡沫排序或氣泡排序）是一種簡單的排序算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。

這個算法的名字由來是因為越大的元素會經由交換慢慢“浮”到數列的頂端，故名。

冒泡排序（BubbleSort）的基本概念是：依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。

算法- 冒泡排序（Bubble Sort）

冒泡排序是一種計算機科學領域的較簡單的排序算法。

從後向前，比較相鄰的元素，如果第一個比第二個大，就交換他們兩個。比較每一對相鄰元素，到隊尾最後一個元素應該會是最大的數。依次類推，比出第二大的數，直至所有元素都成倒敘排列（9，8，7，6，5，4，3，2，1，0）

這個算法的名字由來是因為越大的元素會經由交換慢慢“浮”到數列的頂端，故名。

時間複雜度

若文件本身的排列和想要的排列一致，一趟掃描即可完成排序。所需的關鍵字比較次數C和記錄移動次數M均達到最小值。

原排序（9，8，7，6，5，4，3，2，1，0） ➡ 需要排序（9，8，7，6，5，4，3，2，1，0）

[圖片上傳失敗…(image-b8e712-1571212381789)]

若文件本身的排列和想要的排列相反，需要進行n-1趟排序，每趟排序要進行n-i次關鍵字的比較。

比如原排序（1，2，3，4，5） ➡ 需要排序（5，4，3，2，1）

n = 5, 1 = i 5 ; 排列次數 1+2+3+…+(n-1) = n*(n-1)/2 ;

每次比較都必須移動記錄三次來達到交換記錄位置。在這種情況下，比較和移動次數均達到最大值：

[圖片上傳失敗…(image-36e71a-1571212381789)]

[圖片上傳失敗…(image-fc1c25-1571212381789)]

冒泡排序的最壞時間複雜度為 [圖片上傳失敗…(image-10a015-1571212381789)]

。

冒泡排序總的平均時間複雜度為 [圖片上傳失敗…(image-1272a9-1571212381789)]

。

算法描述

C語言

void bubble_sort(int a[] , int n)

{

}

OC語言

NSMutableArray * arr = [NSMutableArray arrayWithObjects:@”5″,@”4″,@”3″,@”2″,@”1″, nil];

for (int j = 0; j arr.count – 1; j++) {

}

NSLog(@”%@”,arr);

時間複雜度

算法的時間複雜度是一個函數，它定量描述了該算法的運行時間。這是一個關於代表算法輸入值的字符串的長度的函數。時間複雜度常用於大O符號表示，不包括這個函數的低階項和首項係數。O(n)即時間複雜度為n。

java中冒泡排序算法的詳細解答以及程序？

實例說明

用冒泡排序方法對數組進行排序。

實例解析

交換排序的基本思想是兩兩比較待排序記錄的關鍵字，發現兩個記錄的次序相反時即進行交換，直到沒有反序的記錄為止。

應用交換排序基本思想的主要排序方法有冒泡排序和快速排序。

冒泡排序

將被排序的記錄數組 R[1..n] 垂直排列，每個記錄 R[i] 看做是重量為 R[i].key 的氣泡。根據輕氣泡不能在重氣泡之下的原則，從下往上掃描數組 R 。凡掃描到違反本原則的輕氣泡，就使其向上“漂浮”。如此反覆進行，直到最後任何兩個氣泡都是輕者在上，重者在下為止。

(1) 初始， R[1..n] 為無序區。

(2) 第一趟掃描，從無序區底部向上依次比較相鄰的兩個氣泡的重量，若發現輕者在下、重者在上，則交換二者的位置。即依次比較 (R[n],R[n-1]) 、 (R[n-1],R[n-2]) 、 … 、 (R[2],R[1]); 對於每對氣泡 (R[j+1],R[j]), 若 R[j+1].keyR[j].key, 則交換 R[j+1] 和 R[j] 的內容。

第一趟掃描完畢時，“最輕”的氣泡就飄浮到該區間的頂部，即關鍵字最小的記錄被放在最高位置 R[1] 上。

(3) 第二趟掃描，掃描 R[2..n]。掃描完畢時，“次輕”的氣泡飄浮到 R[2] 的位置上 …… 最後，經過 n-1 趟掃描可得到有序區 R[1..n]。

注意：第 i 趟掃描時， R[1..i-1] 和 R[i..n] 分別為當前的有序區和無序區。掃描仍是從無序區底部向上直至該區頂部。掃描完畢時，該區中最輕氣泡漂浮到頂部位置 R[i] 上，結果是 R[1..i] 變為新的有序區。

冒泡排序算法

因為每一趟排序都使有序區增加了一個氣泡，在經過 n-1 趟排序之後，有序區中就有 n-1 個氣泡，而無序區中氣泡的重量總是大於等於有序區中氣泡的重量，所以整個冒泡排序過程至多需要進行 n-1 趟排序。

若在某一趟排序中未發現氣泡位置的交換，則說明待排序的無序區中所有氣泡均滿足輕者在上，重者在下的原則，因此，冒泡排序過程可在此趟排序後終止。為此，在下面給出的算法中，引入一個布爾量 exchange, 在每趟排序開始前，先將其置為 FALSE 。若排序過程中發生了交換，則將其置為 TRUE 。各趟排序結束時檢查 exchange, 若未曾發生過交換則終止算法，不再進行下趟排序。

具體算法如下：

void BubbleSort(SeqList R){

//R(1..n) 是待排序的文件，採用自下向上掃描，對 R 做冒泡排序

int i,j;

Boolean exchange; // 交換標誌

for(i=1;in;i++){ // 最多做 n-1 趟排序

exchange=FALSE; // 本趟排序開始前，交換標誌應為假

for(j=n-1;j=i;j–) // 對當前無序區 R[i..n] 自下向上掃描

if(R[j+1].keyR[j].key){ // 交換記錄

R[0]=R[j+1]; //R[0] 不是哨兵，僅做暫存單元

R[j+1]=R[j];

R[j]=R[0];

exchange=TRUE; // 發生了交換，故將交換標誌置為真

}

if(!exchange) // 本趟排序未發生交換，提前終止算法

return;

} //endfor( 外循環 )

}//BubbleSort

public class BubbleSort {

public static void main(String[] args) {

// TODO Auto-generated method stub

ListInteger lstInteger = new ArrayListInteger();

lstInteger.add(1);

lstInteger.add(3);

lstInteger.add(2);

lstInteger.add(1);

for(int i = 0; ilstInteger.size(); i++){

System.out.println(lstInteger.get(i));

}

System.out.println(“排序之後—————–“);

lstInteger = sortList(lstInteger);

for(int i = 0; ilstInteger.size(); i++){

System.out.println(lstInteger.get(i));

}

public static ListInteger sortList(ListInteger lstInteger){

int i,j,m;

boolean blChange;

int n = lstInteger.size();

for(i=0;in;i++){

blChange = false;

for(j = n-1; ji ; j– ){

if(lstInteger.get(j)lstInteger.get(j-1)){

m = lstInteger.get(j-1);

lstInteger.set(j-1, lstInteger.get(j));

lstInteger.set(j, m);

blChange = true;

}

if(!blChange){

return lstInteger;

}

return lstInteger;

}

歸納注釋

算法的最好時間複雜度: 若文件的初始狀態是正序的, 一趟掃描即可完成排序。所需的關鍵字比較次數 C 和記錄移動次數 M 均達到最小值，即 C(min)=n-1, M(min)= 0 。冒泡排序最好的時間複雜度為 O(n)。

算法的最壞時間複雜度: 若初始文件是反序的，需要進行 n-1 趟排序。每趟排序要進行 n-1 次關鍵字的比較 (1=i=n-1), 且每次比較都必須移動記錄 3 次。在這種情況下，比較和移動次數均達到最大值，即 C(max)=n(n-1)/2=O(n ^2 )，M(max)=3n(n-1)/2=O(n ^2 )。冒泡排序的最壞時間複雜度為 O(n^2 )。

算法的平均時間複雜度為 O(n^2 )。雖然冒泡排序不一定要進行 n-1 趟，但由於它的記錄移動次數較多，故平均時間性能比直接插入排序要差得多。

算法穩定性：冒泡排序是就地排序，且它是穩定的。

算法改進：上述的冒泡排序還可做如下的改進，① 記住最後一次交換髮生位置 lastExchange 的冒泡排序( 該位置之前的相鄰記錄均已有序 )。下一趟排序開始時，R[1..lastExchange-1] 是有序區， R[lastExchange..n] 是無序區。這樣，一趟排序可能使當前有序區擴充多個記錄，從而減少排序的趟數。② 改變掃描方向的冒泡排序。冒泡排序具有不對稱性。能一趟掃描完成排序的情況，只有最輕的氣泡位於 R[n] 的位置，其餘的氣泡均已排好序，那麼也只需一趟掃描就可以完成排序。如對初始關鍵字序列 12、18、42、44、45、67、94、10 就僅需一趟掃描。需要 n-1 趟掃描完成排序情況，當只有最重的氣泡位於 R[1] 的位置，其餘的氣泡均已排好序時，則仍需做 n-1 趟掃描才能完成排序。比如對初始關鍵字序列：94、10、12、18、42、44、45、67 就需 7 趟掃描。造成不對稱性的原因是每趟掃描僅能使最重氣泡“下沉”一個位置，因此使位於頂端的最重氣泡下沉到底部時，需做 n-1 趟掃描。在排序過程中交替改變掃描方向，可改進不對稱性

JAVA 冒泡排序法的詳細解釋是什麼？

冒泡排序的英文Bubble Sort，是一種最基礎的交換排序。

大家一定都喝過汽水，汽水中常常有許多小小的氣泡，嘩啦嘩啦飄到上面來。這是因為組成小氣泡的二氧化碳比水要輕，所以小氣泡可以一點一點向上浮動。而我們的冒泡排序之所以叫做冒泡排序，正是因為這種排序算法的每一個元素都可以像小氣泡一樣，根據自身大小，一點一點向著數組的一側移動。

冒泡排序算法的原理如下：

比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

對每一對相鄰元素做同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。

針對所有的元素重複以上的步驟，除了最後一個。

持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

具體如何來移動呢？讓我們來看一個栗子：

請點擊輸入圖片描述

有8個數組成一個無序數列：5，8，6，3，9，2，1，7，希望從小到大排序。按照冒泡排序的思想，我們要把相鄰的元素兩兩比較，根據大小來交換元素的位置，過程如下：

首先讓5和8比較，發現5比8要小，因此元素位置不變。

接下來讓8和6比較，發現8比6要大，所以8和6交換位置。

請點擊輸入圖片描述

繼續讓8和3比較，發現8比3要大，所以8和3交換位置。

請點擊輸入圖片描述

繼續讓8和9比較，發現8比9要小，所以元素位置不變。

接下來讓9和2比較，發現9比2要大，所以9和2交換位置。

請點擊輸入圖片描述

接下來讓9和1比較，發現9比1要大，所以9和1交換位置。

請點擊輸入圖片描述

最後讓9和7比較，發現9比7要大，所以9和7交換位置。

請點擊輸入圖片描述

這樣一來，元素9作為數列的最大元素，就像是汽水裡的小氣泡一樣漂啊漂，漂到了最右側。

這時候，我們的冒泡排序的第一輪結束了。數列最右側的元素9可以認為是一個有序區域，有序區域目前只有一個元素。

請點擊輸入圖片描述

下面，讓我們來進行第二輪排序：

首先讓5和6比較，發現5比6要小，因此元素位置不變。

接下來讓6和3比較，發現6比3要大，所以6和3交換位置。

請點擊輸入圖片描述

繼續讓6和8比較，發現6比8要小，因此元素位置不變。

接下來讓8和2比較，發現8比2要大，所以8和2交換位置。

請點擊輸入圖片描述

接下來讓8和1比較，發現8比1要大，所以8和1交換位置。

請點擊輸入圖片描述

繼續讓8和7比較，發現8比7要大，所以8和7交換位置。

請點擊輸入圖片描述

第二輪排序結束後，我們數列右側的有序區有了兩個元素，順序如下：

請點擊輸入圖片描述

至於後續的交換細節，我們這裡就不詳細描述了，第三輪過後的狀態如下：

請點擊輸入圖片描述

第四輪過後狀態如下：

請點擊輸入圖片描述

第五輪過後狀態如下：

請點擊輸入圖片描述

第六輪過後狀態如下：

請點擊輸入圖片描述

第七輪過後狀態如下（已經是有序了，所以沒有改變）：

請點擊輸入圖片描述

第八輪過後狀態如下（同樣沒有改變）：

請點擊輸入圖片描述

到此為止，所有元素都是有序的了，這就是冒泡排序的整體思路。

原始的冒泡排序是穩定排序。由於該排序算法的每一輪要遍歷所有元素，輪轉的次數和元素數量相當，所以時間複雜度是O（N^2）。

冒泡排序代碼

請點擊輸入圖片描述

希望對您有所幫助！~

java冒泡排序法代碼

冒泡排序是比較經典的排序算法。代碼如下：

for(int i=1;iarr.length;i++){

for(int j=1;jarr.length-i;j++){

//交換位置

}

拓展資料：

原理：比較兩個相鄰的元素，將值大的元素交換至右端。

思路：依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。重複第一趟步驟，直至全部排序完成。

第一趟比較完成後，最後一個數一定是數組中最大的一個數，所以第二趟比較的時候最後一個數不參與比較；

第二趟比較完成後，倒數第二個數也一定是數組中第二大的數，所以第三趟比較的時候最後兩個數不參與比較；

依次類推，每一趟比較次數-1；

……

舉例說明：要排序數組：int[] arr={6,3,8,2,9,1};

for(int i=1;iarr.length;i++){

for(int j=1;jarr.length-i;j++){

//交換位置

}

參考資料：冒泡排序原理

Java冒泡排序的原理？

冒泡排序是所欲排序算法里最好理解的了。

1、排序算法：

A)比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

B)對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。

C)針對所有的元素重複以上的步驟，除了最後一個。

D)持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

2、給你一個java的實現代碼：

public class BubbleSort{

public static void main(String[] args){

int score[] = {67, 69, 75, 87, 89, 90, 99, 100};

for (int i = 0; i score.length -1; i++){ //最多做n-1趟排序

for(int j = 0 ;j score.length – i – 1; j++){ //對當前無序區間score[0……length-i-1]進行排序(j的範圍很關鍵，這個範圍是在逐步縮小的)

if(score[j] score[j + 1]){ //把小的值交換到後面

int temp = score[j];

score[j] = score[j + 1];

score[j + 1] = temp;

}

System.out.print(“第” + (i + 1) + “次排序結果：”);

for(int a = 0; a score.length; a++){

System.out.print(score[a] + “\t”);

}

System.out.println(“”);

}

System.out.print(“最終排序結果：”);

for(int a = 0; a score.length; a++){

System.out.print(score[a] + “\t”);

}

原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-hant/n/227465.html

java排序算法總結之冒泡排序,java中的冒泡排序法

本文目錄一覽：

Java冒泡排序中i、j各代表什麼意思？

算法- 冒泡排序（Bubble Sort）

java中冒泡排序算法的詳細解答以及程序？

JAVA 冒泡排序法的詳細解釋是什麼？

java冒泡排序法代碼

Java冒泡排序的原理？

相關推薦

發表回復