乾坤大挪移——冒泡法排序，良心之作，拒絕入坑

冒泡 冒泡，不管學什麼語言，冒泡排序是必經的。
在學C語言時每次都要花好久來想，然後寫程序，而且下次再寫還是花好久纔行，花了一個多小時，寫了這個博客，希望入門的小白不要入坑了，好好看看，真的挺簡單的。
內有C語言 c++ python Java的源碼，希望對大家有所幫助。

冒泡就像是水裏的氣泡，大的氣泡就飄起來，小的就沉下去（在編程裏當然也可以反過來）。好下面來看看他是怎麼操作的。
現在從小到大排序爲例
原理： 比較兩個相鄰的元素，較大的數慢慢往後排，較小的數慢慢往前排。每一趟遍歷，將一個最大的數移到序列末尾。

想一下，有n個數要遍歷幾遍？兩個數遍歷一遍，三個數遍歷兩遍，n個數就是n-1遍。
以這個爲例，有小到大排序：

現在有六個數，所以用 5 次大循環進行兩兩比較
循環一

• 2 5不用交換，往下走
• 5 8不交換，繼續
• 8 1交換，順序爲 2 5 1 8 6 4 繼續
• 8 6交換 順序爲 2 5 1 6 8 4 繼續
• 8 4交換 順序爲 2 5 1 6 4 8 第一輪完成，找到了最大的那個並把他放到了最後

現在最後一個數已經確定了，是最大的，所以下一輪循環就不用比較到他了。

循環二

• 2 5不用交換，往下走
• 5 1交換， 2 1 5 6 4 8 繼續
• 5 6不交換，繼續
• 6 4交換 順序爲 2 1 5 4 6 8 ok現在找到了第二大的，並把他放到了倒數第二個位置，下次循環就不用比較已經找出來的6和8了
  循環三
• 2 1交換 1 2 5 4 6 8繼續
• 2 5不換 繼續
• 5 4 交換1 2 4 5 6 8找到了第三大的5，並把他放到了倒數第三個位置

可以看出現在已經排序完成，但計算機並不知道，他還在繼續他的循環。

循環四

• 1 2不換 繼續
• 2 4不換 順序沒變

循環五

• 1 2不換 順序不變

可以看下下面的動態圖，讓思路更清晰

1. 有n數排序，就要循環n-1次，這稱之爲大循環
2. 每經歷一次大循環都要對數組裏面的數進行比較交換，所以每次大循環後還有一次小循環。
3. 每次小循環都比上一次小循環少遍歷（或者說是比較）一個數，因爲每次大循環都會找到一個最大的，並把他放到後面。

下面來進行編程實現

// C語言版
#include<stdio.h>
void swap(int *a,int *b){
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main(){
	int arr[6]={2,5,8,1,6 ,4};
	int i, j, temp,len=6;
    for (i = 0; i < len - 1; i++)
        for (j = 0; j < len - 1 - i; j++)
            if (arr[j] > arr[j + 1]) {
            	swap(&arr[j], &arr[j + 1]);
            }
    for (i = 0; i < len; i++){
    	printf("%d ",arr[i]);
	}
}

#include<stdio.h>
int main(){
	int arr[6]={2,5,8,1,6 ,4};
	int i, j, temp,len=6,d;
    for (i = 0; i < len - 1; i++)
        for (j = 0; j < len - 1 - i; j++)
            if (arr[j] > arr[j + 1]) {
            	d=arr[j];
            	arr[j]=arr[j+1];
            	arr[j+1]=d;
            }
    for (i = 0; i < len; i++){
    	printf("%d ",arr[i]);
	}
}

• C語言是從0開始計數的，所以第一個數是a[0]，也就是2，最後一個是a[5]，也就是4，循環n-1遍，for (i = 0; i < 5; i++)——>>（0 1 2 3 4）循環五遍
• 每次小循環都是從第一個數開始的，所以要for (j = 0; j < len - 1 - i; j++)，爲什麼是len-1-i呢？因爲循環了前面 i 次後，就找出來了i個大的數，並按順序放到了最後，所以這次小循環就不用與他比較了。

#python
def bubbleSort(arr):
    for i in range(1, len(arr)):
        for j in range(0, len(arr)-i):
            if arr[j] > arr[j+1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

//C++
template<typename T>
void bubble_sort(T arr[], int len) {
    int i, j;
    for (i = 0; i < len - 1; i++)
        for (j = 0; j < len - 1 - i; j++)
            if (arr[j] > arr[j + 1])
                swap(arr[j], arr[j + 1]);
}

//Java
 * 冒泡排序只會操作相鄰的兩個數據。每次冒泡操作都會對相鄰的兩個元素進行比較，看是否滿足大小關係要求。
 * 如果不滿足就讓它倆互換。一次冒泡會讓至少一個元素移動到它應該在的位置，重複n 次，
 * 就完成了 n 個數據的排序工作。
 **/
public class BubbleSort {
    public void bubbleSort(Integer[] arr, int n) {
        if (n <= 1) return;       //如果只有一個元素就不用排序了
 
        for (int i = 0; i < n; ++i) {
            // 提前退出冒泡循環的標誌位,即一次比較中沒有交換任何元素，這個數組就已經是有序的了
            boolean flag = false;
            for (int j = 0; j < n - i - 1; ++j) {        //此處你可能會疑問的j<n-i-1，因爲冒泡是把每輪循環中較大的數飄到後面，
                // 數組下標又是從0開始的，i下標後面已經排序的個數就得多減1，總結就是i增多少，j的循環位置減多少
                if (arr[j] > arr[j + 1]) {        //即這兩個相鄰的數是逆序的，交換
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }
            }
            if (!flag) break;//沒有數據交換，數組已經有序，退出排序
        }
    }
 
    public static void main(String[] args) {
        Integer arr[] = {2, 4, 7, 6, 8, 5, 9};
        SortUtil.show(arr);
        BubbleSort bubbleSort = new BubbleSort();
        bubbleSort.bubbleSort(arr, arr.length);
        SortUtil.show(arr);
    }