桶排序

關於桶排序先做幾點說明：

1）桶排序是穩定的； 
2）桶排序是常見排序演算法中最快的一種，大多數情況下比快排和歸併排序還要快 
3）桶排序非常快但是也非常消耗空間，典型的以空間換時間，基本上是最耗記憶體的一種排序演算法。

桶排序中：無序陣列有個要求,就是成員隸屬於固定(有限的)的區間,如範圍為0-9

例如待排數字[6 2 4 1 5 9]

準備10個空桶,最大數個空桶

    [6 2 4 1 5 9]           待排陣列

    [0 0 0 0 0 0 0 0 0 0]   空桶

    [0 1 2 3 4 5 6 7 8 9]   桶編號(實際不存在)

1）順序從待排陣列中取出數字,首先6被取出,然後把6入6號桶,這個過程類似這樣:空桶[ 待排陣列[ 0 ] ] = 待排陣列[ 0 ]

    [6 2 4 1 5 9] 待排陣列

    [0 0 0 0 0 0 6 0 0 0] 空桶

    [0 1 2 3 4 5 6 7 8 9] 桶編號(實際不存在)

2）順序從待排陣列中取出下一個數字,此時2被取出,將其放入2號桶,是幾就放幾號桶

    [6 2 4 1 5 9] 待排陣列

    [0 0 2 0 0 0 6 0 0 0] 空桶

    [0 1 2 3 4 5 6 7 8 9] 桶編號(實際不存在)

3,4,5,6省略,過程一樣,全部入桶後變成下邊這樣

    [6 2 4 1 5 9] 待排陣列

    [0 1 2 0 4 5 6 0 0 9] 空桶

    [0 1 2 3 4 5 6 7 8 9] 桶編號(實際不存在)

0表示空桶,跳過,順序取出即可:1 2 4 5 6 9

示例原始碼：

public static int[] bucketSort(int[] nums, int maxNum){
    int[] sorted = new int[maxNum+1];

    for(int i=0; i<nums.length; i++){
        sorted[nums[i]] = nums[i];//把資料放到對應索引的位置
    }
    return sorted;
}

測試程式碼：

public static void main(String[] args) {
    int[] x = { 99, 65, 24, 47, 50, 88,33, 66, 67, 31, 18 };
    int[] sorted = bucketSort(x, 99);
    for (int i = 0; i < sorted.length; i++)
    {
        if (sorted[i] > 0)
            System.out.println(sorted[i]);
    }
}

輸出：

18, 24, 31, 33, 47, 50, 65, 66, 67, 88, 99, 

本文完整程式碼的github地址： 
https://github.com/leetcode-hust/leetcode/blob/master/louyuting/src/leetcode/Algorithm/BucketSort.java

轉載自：https://blog.csdn.net/u010853261/article/details/54933236

氣泡排序

排序，其實就是按照數的大小順序進行排列，比如正序就是把小的數放在左邊，大的數放在右邊。而氣泡排序做的事情就是將兩個相鄰的數進行比較

和交換位置，從而達到排序的目的。

基本思想：

氣泡排序的基本思想就是一次迴圈，將一個數擺放在正確的位置上。

思路分析：

讓我們以陣列 {5,4,3,2,1}從小到大排序為例，來具體分析一下氣泡排序的具體思路

首先，冒泡的核心就是兩個相鄰的數進行比較，大的放右邊，小的放左邊

1、我們比較5,4，交換位置，得到4,5,3,2,1，那麼下一步呢？既然是相鄰位置比較，那麼我們比較5.3

2、比較5,3, 並且交換，得到4,3,5,2,1

3、繼續比較5,2，交換，得到4，3,2,5,1

4、比5，1，交換，得到4,3,2,1,5

上面四步，就完成了一次迴圈，我們得到了4,3,2,1,5

5、繼續比較4,3，需要交換，得到3,4,2,1,5

6、比較4,2，需要交換，3,2,4,1,5

7、比較4,1，交換得到，，3,2,1,4,5

8、比較4,5，不需要交換

上面四次比較，我們又完成了一次排列，然後我們需要繼續一次迴圈

這時候我們發現 好像沒完沒了了，那麼什麼時候該結束呢？也就是說我們應該進行多少次這樣的比較迴圈呢，讓我們來思考，其實一次迴圈，至少能確定一個數的位置，就是說，第一次迴圈，就可以把陣列中最大的數，放在最右邊的位置，第二次迴圈，就能將第二大的數放在右邊第二個位置，也就是說，即使是最差的情況（完成逆序，和上面的例子一樣），我們也最多通過5個這樣的迴圈，其實就能完成排列了。

通過上面的分析，我們發現冒泡演算法的核心，需要兩個for迴圈，我們可以寫出如下的程式碼

具體實現：
private void bubbleSort(){

    int[] a = {5,4,3,2,1};

    for (int i = 0; i < a.length - 1; i++) {

        for (int j = 0; j < a.length - 1; j++){
            if (a[j] > a[j+1]){

                int temp = a[j];

                a[j] = a[j+1];

                a[j+1] = temp;

            }

        }

        Log.i("hero","---第--"+i+"---"+ Arrays.toString(a));

    }

    Log.i("hero","-----"+Arrays.toString(a));

}

執行結果：

這樣，我們就完成了氣泡排序了

轉載自：https://blog.csdn.net/qqchenjian318/article/details/69603893