基本介紹
冒泡排序（Bubble Sorting）（時間復雜度為 O(n²)）的基本思想：通過對待排序序列 從前向后（從下標較小的元素開始），依次比較相鄰元素的值，若發現逆序則交換，使值較大的元素逐漸從前移向后部，就像水底下的旗袍一樣逐漸向上冒。
優化點：因為排序過程中，個元素不斷接近自己的位置，如果一趟比較下來沒有進行過交換，就說明序列有序，因此要在排序過程中設置一個標志判斷元素是否進行過交換。從而減少不必要的比較。（該優化點可以在完成基本的冒泡排序之后再做）
圖解冒泡排序算法的過程
動圖：
冒泡排序小結：
1.共進行 數組大小 - 1 次大的循環
2.每一趟排序的次數在逐漸的減少
3.優化：如果發現在某趟排序中，沒有發生一次交換，則可以提前結束冒泡排序。
代碼實現
演變過程
為了容易理解，先演示冒泡排序的演變過程
/**
* 為了更好的理解，這里把冒泡排序的演變過程演示出來
*/
@Test
public void processDemo() {
int arr[] = {3, 9, -1, 10, -2};
// 第 1 趟排序：將最大的數排在最后
// 總共排序：arr.length - 1
int temp = 0; // 臨時變量，交換的時候使用
for (int i = 0; i < arr.length - 1; i++) {
if (arr[i] > arr[i + 1]) {
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.println("第 1 趟排序后的數組");
System.out.println(Arrays.toString(arr));
// 第 2 趟排序：將第 2 大的數排在倒數第 2 位
// 總共排序：arr.length - 1 - 1 ；
// 從頭開始排序，其他沒有變化，只是將排序次數減少了一次
for (int i = 0; i < arr.length - 1 -1; i++) {
if (arr[i] > arr[i + 1]) {
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.println("第 2 趟排序后的數組");
System.out.println(Arrays.toString(arr));
// 第 3 趟排序：將第 3 大的數排在倒數第 3 位
// 總共排序：arr.length - 1 - 2 ；
// 從頭開始排序，其他沒有變化，只是將排序次數減少了 2 次
for (int i = 0; i < arr.length - 1 -2; i++) {
if (arr[i] > arr[i + 1]) {
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.println("第 3 趟排序后的數組");
System.out.println(Arrays.toString(arr));
// 第 4 趟排序：將第 4 大的數排在倒數第 4 位
// 總共排序：arr.length - 1 - 3 ；
// 從頭開始排序，其他沒有變化，只是將排序次數減少了 3 次
for (int i = 0; i < arr.length - 1 -3; i++) {
if (arr[i] > arr[i + 1]) {
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.println("第 4 趟排序后的數組");
System.out.println(Arrays.toString(arr));
// 第 5 趟沒有必要，因為這里有 5 個數字，確定了 4 個數字，剩下的那一個就已經出來了
}
測試輸出
第 1 趟排序后的數組
[3, -1, 9, -2, 10]
第 2 趟排序后的數組
[-1, 3, -2, 9, 10]
第 3 趟排序后的數組
[-1, -2, 3, 9, 10]
第 4 趟排序后的數組
[-2, -1, 3, 9, 10]
從上述的 4 趟排序過程來看，循環體都是一樣的，只是每次循環的次數在減少，那么就可以如下簡化
@Test
public void processDemo2() {
int arr[] = {3, 9, -1, 10, -2};
// 總共排序：arr.length - 1
int temp = 0; // 臨時變量，交換的時候使用
for (int j = 0; j < arr.length - 1; j++) {
for (int i = 0; i < arr.length - 1 - j; i++) {
if (arr[i] > arr[i + 1]) {
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.println("第 " + (j + 1) + " 趟排序后的數組");
System.out.println(Arrays.toString(arr));
}
}
測試輸出
第 1 趟排序后的數組
[3, -1, 9, -2, 10]
第 2 趟排序后的數組
[-1, 3, -2, 9, 10]
第 3 趟排序后的數組
[-1, -2, 3, 9, 10]
第 4 趟排序后的數組
[-2, -1, 3, 9, 10]
優化
對于優化，減少排序次數
@Test
public void processDemo3() {
int arr[] = {3, 9, -1, 10, 20};
// 總共排序：arr.length - 1
int temp = 0; // 臨時變量，交換的時候使用
boolean change = false;// 標識變量，表示是否進行過交換
for (int j = 0; j < arr.length - 1; j++) {
for (int i = 0; i < arr.length - 1 - j; i++) {
if (arr[i] > arr[i + 1]) {
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
change = true;
}
}
if(!change){
// 如果有 1 輪下來，都沒有進行排序，則可以提前退出
break;
}else{
change = false; // 重置 change!!!, 進行下次判斷
}
System.out.println("第 " + (j + 1) + " 趟排序后的數組");
System.out.println(Arrays.toString(arr));
}
}
測試輸出：
第 1 趟排序后的數組
[3, -1, 9, 10, 20]
第 2 趟排序后的數組
[-1, 3, 9, 10, 20]
這里更改了原始數組，因為優化的點，得看你這個數組原來的排序 和 元素組成，算是一種概率問題，并不是在任何情況下都可以被優化
封裝算法
/**
* 把排序算法封裝成一個方法，方便被復用
*
* @param arr
*/
public static void bubbleSort(int[] arr) {
// 總共排序：arr.length - 1
int temp = 0; // 臨時變量，交換的時候使用
boolean change = false;
for (int j = 0; j < arr.length - 1; j++) {
for (int i = 0; i < arr.length - 1 - j; i++) {
if (arr[i] > arr[i + 1]) {
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
change = true;
}
}
if(!change){
// 如果有 1 輪下來，都沒有進行排序，則可以提前退出
break;
}else{
change = false; // 重置 change!!!, 進行下次判斷
}
}
}
測試調用
/**
* 測試封裝后的算法
*/
@Test
public void bubbleSortTest() {
int[] arr = {3, 9, -1, 10, 20};
System.out.println("排序前：" + Arrays.toString(arr));
bubbleSort(arr);
System.out.println("排序后：" + Arrays.toString(arr));
}
測試輸出
排序前：[3, 9, -1, 10, 20]
排序后：[-1, 3, 9, 10, 20]
大量數據耗時測試
排序隨機生成的 8 萬個數據
/**
* 大量數據排序時間測試
*/
@Test
public void bulkDataSort() {
int max = 80000;
int[] arr = new int[max];
for (int i = 0; i < max; i++) {
arr[i] = (int) (Math.random() * 80000);
}
Instant startTime = Instant.now();
bubbleSort(arr);
// System.out.println(Arrays.toString(arr));
Instant endTime = Instant.now();
System.out.println("共耗時：" + Duration.between(startTime, endTime).toMillis() + " 毫秒");
}
測試輸出
運行幾次，差不多在 13 秒左右
共耗時：14656 毫秒
共耗時：13853 毫秒
到此這篇關于java 排序算法之冒泡排序的文章就介紹到這了,更多相關java 冒泡排序內容請搜索服務器之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持服務器之家！
原文鏈接：https://www.cnblogs.com/ljz111/p/15203778.html
