冒泡排序（一）：
假設有 5 個數字 35，56，34，22，16 在一個 int 數組中，要求按從小到大排序輸出如何採用冒泡排序算法呢？
1、基本思想
首先從數組的最左邊開始，取出第 0 號位置（左邊）的數據和第1號位置（右邊）的數據，如果左邊的數據大於右邊的數據，則進行交換，否而不進行交換。接下來右移一個位置，取出第 1 個位置的數據和第 2 個位置的數據，進行比較，如果左邊的數據大於右邊的數據，則進行交換，否則不進行交換。沿着這個算法一直排序下去，最大的數就會冒出水面，這就是冒泡排序.
2、排序過程。下面我們來模擬一下冒泡排序假設有數組{35,56,34,22,16}
第一輪排序：
第一次排序：35和56比較，56更大這裡我們什麼都別管 順序為：35,56,34,22,16
第二次排序：56和34比較，56更大我們讓56和34交換 順序：35,34,56,22,16
第三次排序: 56和22比較，56更大，交換位置 順序：35,34,22,56,16
第四次排序: 56比16比較，56更大，交換位置 順序: 35,34,22,16,56
第一輪比較了四次
第二輪排序：
第一次排序：35和34比較，35更大，交換位置 順序：34,35,22,16,56
第二次排序：35和22比較，35更大，交換位置 順序：34,22,35,16,56
第三次排序：35和16比較，35更大，交換位置 順序：34,22,16,35,56
第二輪比較了三次
第三輪排序:
第一次排序：34和22比較，34更大，交換位置 順序：22,34,16,35,56
第二次排序：34和16比較，34更大，交換位置 順序：22,16,34,35,56
第三輪比較了兩次
第四輪排序：
第一次排序：22和16比較，22更大，交換位置 順序：16,22,34,35,56
第四輪比較了一次
最終順序：16,22,34,35,56
從上面我們看到了比較了 N-1 次，那麼第二遍就為 N-2 次比較了，如此類推，比較次數的公式如下：
(N-1) + (N-2)+…+1=((N-1)*N)/2
所以以上總共比較次數為((5-1)*5)/2=10
代碼實現如下：
/**
* ClassName:BubbleSort <br/>
*
* Function: TODO ADD FUNCTION. <br/>
* Reason: TODO ADD REASON. <br/>
* Date: 2021年11月4日 上午11:23:32 <br/>
*
* @author Administrator
* @version
* @since JDK 1.8
* @see
*/
public class BubbleSort {
public static void main(String[] args) {
int[] data = { 35, 56, 34, 22, 16 };
for (int i = 0; i < data.length; i++) {
int min = i;
// 選擇出最小值的下標
for (int j = i + 1; j < data.length; j++) {
if (data[j] < data[min]) {
min = j;
}
}
// 將最小值放到未排序記錄的第一個位置
if (min != i) {// min>i
int temp = data[i];
data[i] = data[min];
data[min] = temp;
}
}
// 循環輸出數組中的元素
for (int i = 0; i < data.length; i++) {
System.out.println(data[i]);
}
}
}
冒泡排序（二）：
1、基本思想
兩兩比較待排序數據元素的大小，發現兩個數據元素的次序相反時即進行交換，直到沒有反序的數據元素為止。
2、排序過程
設想被排序的數組R［1..N］垂直豎立，將每個數據元素看作有重量的氣泡，根據輕氣泡不能在重氣泡之下的原則，從下往上掃描數組R，凡掃描到違反本原則的輕氣泡，就使其向上”漂浮”，如此反覆進行，直至最後任何兩個氣泡都是輕者在上，重者在下為止。
【示例】：
49 13 13 13 13 13 13 13
38 49 27 27 27 27 27 27
65 38 49 38 38 38 38 38
97 65 38 49 49 49 49 49
76 97 65 49 49 49 49 49
13 76 97 65 65 65 65 65
27 27 76 97 76 76 76 76
49 49 49 76 97 97 97 97
代碼實現：
/**
* ClassName:BubbleSort <br/>
*
* Function: 冒泡排序：執行完一次內for循環後，最小的一個數放到了數組的最前面（跟那一個排序算法* 不一樣）。相鄰位置之間交換
* Reason: TODO ADD REASON. <br/>
* Date: 2021年11月4日 上午11:23:32 <br/>
*
* @author Administrator
* @version
* @since JDK 8
* @see
*/
public class BubbleSort {
/**
* 排序算法的實現，對數組中指定的元素進行排序
*
* @param array 待排序的數組
* @param from 從哪裡開始排序 11 * @param end 排到哪裡 11 * @param c 比較器 11
*/
public void bubble(Integer[] array, int from, int end) {
// 需array.length - 1輪比較
for (int k = 1; k < end - from + 1; k++) {
// 每輪循環中從最後一個元素開始向前起泡，直到i=k止，即i等於輪次止
for (int i = end - from; i >= k; i--) {
// 按照一種規則（後面元素不能小於前面元素）排序
if ((array[i].compareTo(array[i - 1])) < 0) {
// 如果後面元素小於了（當然是大於還是小於要看比較器實現了）前面的元素，則前後交換
swap(array, i, i - 1);
}
}
}
}
/**
* 交換數組中的兩個元素的位置
*
* @param array 待交換的數組
* @param i 第一個元素
* @param j 第二個元素
*/
public void swap(Integer[] array, int i, int j) {
if (i != j) {// 只有不是同一位置時才需交換
Integer tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
}
public static void main(String[] args) {
Integer[] intgArr = { 35, 56, 34, 22, 16 };
BubbleSort bubblesort = new BubbleSort();
bubblesort.bubble(intgArr, 0, intgArr.length - 1);
for (Integer intObj : intgArr) {
System.out.print(intObj + " ");
}
}
}
另外一種實現方式：
/**
* ClassName:BubbleSort <br/>
*
* Function: 冒泡排序：執行完一次內for循環後，最大的一個數放到了數組的最後面。相鄰位置之間交換 Reason: TODO ADD REASON.
* <br/>
* Date: 2021年11月4日 上午11:23:32 <br/>
*
* @author Administrator
* @version
* @since JDK 8
* @see
*/
public class BubbleSort {
public static void main(String[] args) {
int[] a = { 35, 56, 34, 22, 16 };
bubble(a);
for (int num : a) {
System.out.print(num + " ");
}
}
public static void bubble(int[] a) {
for (int i = a.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (new Integer(a[j]).compareTo(new Integer(a[j + 1])) > 0) {
swap(a, j, j + 1);
}
}
}
}
public static void swap(int[] a, int x, int y) {
int temp;
temp = a[x];
a[x] = a[y];
a[y] = temp;
}
}原創文章，作者：投稿專員，如若轉載，請註明出處：https://www.506064.com/zh-hant/n/222941.html
微信掃一掃 
支付寶掃一掃 