氣泡排序及其程式碼改進
什麼是氣泡排序
氣泡排序的英文Bubble Sort，是一種最基礎的交換排序。
大家一定都喝過汽水，汽水中常常有許多小小的氣泡，嘩啦嘩啦飄到上面來。這是因為組成小氣泡的二氧化碳比水要輕，所以小氣泡可以一點一點向上浮動。
而我們的氣泡排序之所以叫做氣泡排序，正是因為這種排序演算法的每一個元素都可以像小氣泡一樣，根據自身大小，一點一點向著陣列的一側移動。
具體如何來移動呢？讓我們來看一個栗子：
有8個數組成一個無序數列：5，8，6，3，9，2，1，7，希望從小到大排序。
按照氣泡排序的思想，我們要把相鄰的元素兩兩比較，根據大小來交換元素的位置，過程如下：
首先讓5和8比較，發現5比8要小，因此元素位置不變。
接下來讓8和6比較，發現8比6要大，所以8和6交換位置。
傳統的氣泡排序實現
/**
*@description 傳統的氣泡排序
*@author SongHongWei
*@params
*@time 2018/9/26-17:40
**/
public List<Integer> bubbleSort(List<Integer> sort)
{
int count = 0;
int size = sort.size();
for (int i = 0; i < sort.size(); i++)
{
for (int j = 0; j < size - 1; j++)
{
int pre = sort.get(j);
int next = sort.get(j + 1);
if (pre > next)
{
sort.set(j, next);
sort.set(j + 1, pre);
}
count++;
}
System.out.println("第" + i + "輪排序結果" + sort.toString());
}
System.out.println(count);
return sort;
}
/**
*@description 稍微改進後的, 迴圈次數降低了一半
*@author SongHongWei
*@params
*@time 2018/9/27-14:51
**/
public List<Integer> bubbleSortHalf(List<Integer> sort)
{
int count = 0;
int size = sort.size();
for (int i = 0; i < sort.size(); i++)
{
for (int j = 0; j < size - i - 1; j++)
{
int pre = sort.get(j);
int next = sort.get(j + 1);
if (pre > next)
{
sort.set(j, next);
sort.set(j + 1, pre);
}
count++;
}
System.out.println("第" + i + "輪排序結果" + sort.toString());
}
System.out.println(count);
return sort;
}
程式碼非常簡單，使用雙迴圈來進行排序。外部迴圈控制所有的回合，內部迴圈代表每一輪的冒泡處理，先進行元素比較，再進行元素交換。
氣泡排序的優化
原始的氣泡排序有哪些優化點呢？
讓我們回顧一下剛才描述的排序細節，仍然以5，8，6，3，9，2，1，7這個數列為例，當排序演算法分別執行到第六、第七、第八輪的時候，數列狀態如下：
很明顯可以看出，自從經過第六輪排序，整個數列已然是有序的了。可是我們的排序演算法仍然“兢兢業業”地繼續執行第七輪、第八輪。
這種情況下，如果我們能判斷出數列已經有序，並且做出標記，剩下的幾輪排序就可以不必執行，提早結束工作。
優化後的程式碼
/**
*@description 這一版程式碼做了小小的改動，利用布林變數isSorted作為標記。如果在本輪排序中，元素有交換，則說明數列無序；如果沒有元素交換，說明數列已然有序，直接跳出大迴圈。
*@author SongHongWei
*@params
*@time 2018/9/27-14:51
**/
public List<Integer> bubbleSortOptimize(List<Integer> sort)
{
int count = 0;
int size = sort.size();
for (int i = 0; i < sort.size(); i++)
{
//有序標記，每一輪的初始是true
boolean isSorted = true;
for (int j = 0; j < size - 1; j++)
{
int pre = sort.get(j);
int next = sort.get(j + 1);
if (pre > next)
{
sort.set(j, next);
sort.set(j + 1, pre);
isSorted = false;
}
count++;
}
if (isSorted)
{
break;
}
size--;
System.out.println("第" + i + "輪排序結果" + sort.toString());
}
System.out.println(count);
return sort;
}
這一版程式碼做了小小的改動，利用布林變數isSorted作為標記。如果在本輪排序中，元素有交換，則說明數列無序；如果沒有元素交換，說明數列已然有序，直接跳出大迴圈。
氣泡排序的效能提升
為了說明問題，咱們這次找一個新的數列：
這個數列的特點是前半部分（3，4，2，1）無序，後半部分（5，6，7，8）升序，並且後半部分的元素已經是數列最大值。
讓我們按照氣泡排序的思路來進行排序，看一看具體效果：
第一輪
元素3和4比較，發現3小於4，所以位置不變。
元素4和2比較，發現4大於2，所以4和2交換。
元素4和1比較，發現4大於1，所以4和1交換
元素4和5比較，發現4小於5，所以位置不變。
元素5和6比較，發現5小於6，所以位置不變。
元素6和7比較，發現6小於7，所以位置不變。
元素7和8比較，發現7小於8，所以位置不變。
第一輪結束，數列有序區包含一個元素：
第二輪
元素3和2比較，發現3大於2，所以3和2交換
元素3和1比較，發現3大於1，所以3和1交換。
元素3和4比較，發現3小於4，所以位置不變。
元素4和5比較，發現4小於5，所以位置不變。
元素5和6比較，發現5小於6，所以位置不變。
元素6和7比較，發現6小於7，所以位置不變。
元素7和8比較，發現7小於8，所以位置不變。
第二輪結束，數列有序區包含一個元素：
這個問題的關鍵點在哪裡呢？關鍵在於對數列有序區的界定。
按照現有的邏輯，有序區的長度和排序的輪數是相等的。比如第一輪排序過後的有序區長度是1，第二輪排序過後的有序區長度是2 …
實際上，數列真正的有序區可能會大於這個長度，比如例子中僅僅第二輪，後面5個元素實際都已經屬於有序區。因此後面的許多次元素比較是沒有意義的。
如何避免這種情況呢？我們可以在每一輪排序的最後，記錄下最後一次元素交換的位置，那個位置也就是無序數列的邊界，再往後就是有序區了。 再次優化的程式碼:
/**
*@description 這一版程式碼中，sortBorder就是無序數列的邊界。每一輪排序過程中，
sortBorder之後的元素就完全不需要比較了，肯定是有序的。
*@author SongHongWei
*@params
*@time 2018/9/27-15:07
**/
public List<Integer> bubbleSortOrder(List<Integer> sort)
{
List<Integer> reuslt = new LinkedList<Integer>();
int count = 0;
int size = sort.size() - 1;
int lastExchangeIndex = 0;
for (int i = 0; i < sort.size(); i++)
{
//有序標記，每一輪的初始是true
boolean isSorted = true;
for (int j = 0; j < size; j++)
{
int pre = sort.get(j);
int next = sort.get(j + 1);
if (pre > next)
{
sort.set(j, next);
sort.set(j + 1, pre);
isSorted = false;
lastExchangeIndex = j;
}
count++;
}
if (isSorted)
{
break;
}
//縮短排序長度
size = lastExchangeIndex;
System.out.println("第" + i + "輪排序結果" + sort.toString());
}
System.out.println(count);
return sort;
}
這一版程式碼中，sortBorder就是無序數列的邊界。每一輪排序過程中，sortBorder之後的元素就完全不需要比較了，肯定是有序的。 全部程式碼,及git地址 https://gitee.com/BruceWayen/algorithm.git :
package com.git.algorithm.bubbling;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
/**
* @ _ooOoo_
* o8888888o
* 88" . "88
* (| -_- |)
* O\ = /O
* ____/`---'\____
* .' \\| |// `.
* / \\||| : |||// \
* / _||||| -:- |||||- \
* | | \\\ - /// | |
* | \_| ''\---/'' | |
* \ .-\__ `-` ___/-. /
* ___`. .' /--.--\ `. . __
* ."" '< `.___\_<|>_/___.' >'"".
* | | : `- \`.;`\ _ /`;.`/ - ` : | |
* \ \ `-. \_ __\ /__ _/ .-` / /
* ======`-.____`-.___\_____/___.-`____.-'======
* `=---='
* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
* 佛祖保佑 永無BUG
*@DESCRIPTION 氣泡排序
*@AUTHOR SongHongWei
*@TIME 2018/9/26-17:19
*@PACKAGE_NAME com.git.algorithm.bubbling
**/
public class BubbleSort
{
public static void main(String[] args)
{
BubbleSort bubbleSort = new BubbleSort();
List<Integer> randomArray = bubbleSort.getRandomArray(15);
System.out.println(bubbleSort.bubbleSort(new ArrayList<Integer>(randomArray)));
System.out.println(bubbleSort.bubbleSortHalf(new ArrayList<Integer>(randomArray)));
System.out.println(bubbleSort.bubbleSortOptimize(new ArrayList<Integer>(randomArray)));
System.out.println(bubbleSort.bubbleSortOrder(new ArrayList<Integer>(randomArray)));
}
/**
*@description 獲取指定長度的隨機陣列
*@author SongHongWei
*@params
*@time 2018/9/26-17:35
**/
public List<Integer> getRandomArray(int length)
{
List<Integer> result = new ArrayList<Integer>();
Random random = new Random();
for (int i = 0; i < length; i++)
{
result.add(random.nextInt(length));
}
System.out.println(result.toString());
return result;
}
/**
*@description 傳統的氣泡排序
*@author SongHongWei
*@params
*@time 2018/9/26-17:40
**/
public List<Integer> bubbleSort(List<Integer> sort)
{
List<Integer> reuslt = new LinkedList<Integer>();
int count = 0;
int size = sort.size();
for (int i = 0; i < sort.size(); i++)
{
for (int j = 0; j < size - 1; j++)
{
int pre = sort.get(j);
int next = sort.get(j + 1);
if (pre > next)
{
sort.set(j, next);
sort.set(j + 1, pre);
}
count++;
}
System.out.println("第" + i + "輪排序結果" + sort.toString());
}
System.out.println(count);
return sort;
}
/**
*@description 稍微改進後的, 迴圈次數降低了一半
*@author SongHongWei
*@params
*@time 2018/9/27-14:51
**/
public List<Integer> bubbleSortHalf(List<Integer> sort)
{
List<Integer> reuslt = new LinkedList<Integer>();
int count = 0;
int size = sort.size();
for (int i = 0; i < sort.size(); i++)
{
for (int j = 0; j < size - i - 1; j++)
{
int pre = sort.get(j);
int next = sort.get(j + 1);
if (pre > next)
{
sort.set(j, next);
sort.set(j + 1, pre);
}
count++;
}
System.out.println("第" + i + "輪排序結果" + sort.toString());
}
System.out.println(count);
return sort;
}
/**
*@description 這一版程式碼做了小小的改動，利用布林變數isSorted作為標記。如果在本輪排序中，元素有交換，則說明數列無序；如果沒有元素交換，說明數列已然有序，直接跳出大迴圈。
*@author SongHongWei
*@params
*@time 2018/9/27-14:51
**/
public List<Integer> bubbleSortOptimize(List<Integer> sort)
{
List<Integer> reuslt = new LinkedList
相關推薦
氣泡排序及其程式碼改進
什麼是氣泡排序
氣泡排序的英文Bubble Sort，是一種最基礎的交換排序。
大家一定都喝過汽水，汽水中常常有許多小小的氣泡，嘩啦嘩啦飄到上面來。這是因為組成小氣泡的二氧化碳比水要輕，所以小氣泡可以一點一點向上浮動。
而我們的氣泡排序之所以叫做氣泡排序，正
氣泡排序及其改進
import java.util.Arrays;
/*
* 氣泡排序及其優化：
*/
public class maopaoSort {
//原始的氣泡排序
public static void bubbleSort1(int[] arr) {
氣泡排序和改進的氣泡排序-c#程式碼
氣泡排序原理：
比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
對每一對相鄰元素做同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
針對所有的元素重複以上的步驟，除了最後一個。
持續每次對越來越少的元素重複上面的步驟，直到沒有任
排序（二）——氣泡排序及其改進
氣泡排序（Bubble
Sort）
氣泡排序（Bubble Sort）是一種簡單的排序演算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是
氣泡排序及其改進演算法
將陣列a[10] = {7,2,9,4,1,3,8,6,5,0}從小到大排序並列印結果
列印函式：
void printA(int *a,int len)
{
int i;
for(i = 0; i < len; i++)
{
printf("%4d",
(排序演算法)linux c語言實現選擇排序演算法（氣泡排序的略微改進版）
快速排序演算法和氣泡排序演算法是差不多的，都是要兩層迴圈，外迴圈是要比較的個數，其實就是元素的個數，內迴圈就是外層那個標記和其他的比較大小，
氣泡排序是相鄰的兩個，兩兩比較，最後交換出一個最大或者最小值，
快速排序是在氣泡排序的基礎上，找出那個最小的或者最大的，但是不是直接交換，
排序演算法1——圖解氣泡排序及其實現（三種方法，基於模板及函式指標）
排序演算法1——圖解氣泡排序及其實現（三種方法，基於模板及函式指標） 排序演算法2——圖解簡單選擇排序及其實現 排序演算法3——圖解直接插入排序以及折半（二分）插入排序及其實現 排序演算法4——圖解希爾排序及其實現 排序演算法5——圖解堆排序及其實現 排序演算法6——圖解歸併排序及其遞迴與非
排序演算法之氣泡排序及其優化
定義：每一趟都是相鄰兩個元素進行比較，將小數放在前面，大數放在後面，最終一趟走完，最大的數也就跑到最後面了。
氣泡排序是常見的一種排序方法，比較簡單，容易理解,多用於教學(＞﹏＜)
最壞情況下時間複雜度:O(N^2) 。
比較次數是n(n-1)/2。
注
排序演算法之 氣泡排序 及其時間複雜度和空間複雜度
氣泡排序（Bubble Sort），是一種電腦科學領域的較簡單的排序演算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因
排序演算法（四）氣泡排序及其優化
基本思路：
氣泡排序的基本思路是通過元素的兩兩比較不斷將較大值（升序）或則較小值（降序）移動序列的後面，類似於氣泡向上冒的排序演算法。
1、比較相鄰兩個元素大小，如若不符合要求則交換元素；
2、對整個序列做同樣1的操作，最後的元素一定是當前比較的序
演算法 -- Java實現氣泡排序(圖解 + 程式碼實現)
排序思想:
相鄰元素兩兩比較,大的往後放,第一次完畢,最大值出現在了最大索引處(每比較完一趟,就選出一個最大值放到了後面),同理繼續可以得到一個排好序的陣列
排序圖解:
排序規
氣泡排序--Java程式碼示例
package cn.wwz.test;
import java.util.Arrays;
/**
* 氣泡排序 假設有陣列：[26, 9, 94, 65, 96, 2]
* 利用雙層迴圈
* 步驟一：內層相鄰兩位相比 若左>右 則交換
順序表上實現氣泡排序及其優化
氣泡排序
（1）定義順序表的儲存結構；
（2）在順序表上實現氣泡排序；
（3）將普通的氣泡排序進行多次改進以提高排序速度，並用大量資料測試其速度的提高。
1.普通版：
2.第一步優化：若在一次排序中沒有發生交換，說明此時已經全部有序無需再進行掃描
增加一個標記，記錄是否進
基本氣泡排序與演算法改進
氣泡排序基本思想，相鄰兩數一次比較，按照要求順序交換。
#include <stdio.h>
void BubbleSort(int *Array,int n);
//*Array,待排陣列；n，陣列大小
int main()
{
快速排序、程式碼實現（python3版）及其時間空間複雜度分析
快速排序是對氣泡排序的一種改進。基本思想是：通過一躺排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都比另外一部分的所有資料都要小，然後再按次方法對這兩部分資料分別進行快速排序，整個排序過程可以遞迴進行，以此達到整個資料變成有序序列。最壞情況的時間複雜度為O(n2)，最好情況時間複雜度
氣泡排序，選擇排序、二分法查詢圖示以及程式碼實現
氣泡排序
請看下面的這個栗子：
需要排序的陣列arr = {99,88,77,55,66,44};
具體排序細節各位客官請看圖：
程式碼實現：
public class BubbleSort {
public static void main(String[] ar
(排序演算法)linux c語言實現快速排序（氣泡排序的改進版）
快速排序演算法是對氣泡排序演算法的一種改進，氣泡排序是對單個元素的升降，快速排序是對所有元素的升降，不過這個升降是取了某一個標準的前提下，在本文程式碼中，就以a[i]，其實就是以最左邊的元素為參考，比較交換之後，將這個參考元素放到分界的地方，即i的位置。
程式碼如下，裡面有比較詳細的
c#程式碼實現排序演算法之氣泡排序
氣泡排序的平均時間複雜度為O（n²），最好時間複雜度為O（n），最壞時間複雜度為O（n²），空間複雜度為O（1），是一種穩定的演算法。
1.將整個待排序的記錄序列劃分成有序區和無序區，初始時有序區為空，無序區包括所有待排序的記錄。 2.對無序區從前向後依次比較相鄰記錄，若反序則交
面試中常見的陣列的操作:遍歷,最值,反轉,氣泡排序,二分查詢(附程式碼)
陣列：儲存同一種資料型別的多個元素的容器；陣列中的索引從0開始，最大編號是陣列的長度-1（減1）；
下面給大家列出陣列常見的幾種操作：
A 遍歷
/** * 遍歷 */ public static void printArray(int
排序演算法之氣泡排序改進演算法
前言
排序演算法中最最常見也算是入門的一個排序演算法就是氣泡排序。這篇文章我們就來好好地寫寫這個氣泡排序演算法，以及氣泡排序呢的改進演算法。
傳統冒泡演算法
static int[] array = {100,1,5,4,11,2,20,18,89,34,20,34};
@Test
publ