算法__冒泡排序

冒泡排序:從數組的0位置開始往右開始一個個比較大小，如果座標小的數大於座標大的數，則兩個座標的數交換，然後再和下一個數比較，直至整個循環完則順序排好。直接舉個例子：

5

2

3

1

6

7

9

8

第一輪：

             1. 5和2比較，5大於2，則5和2交換       

2

5

3

1

6

7

9

8

             2. 5和3比較，5大於3，5和3交換

2

3

5

1

6

7

9

8

             3. 5和1比較，5大於1，5和1交換

2

3

1

5

6

7

9

8

             4. 5和6比較，5小於6，不交換

2

3

1

5

6

7

9

8

             5. 6和7比較，6小於7，不交換

2

3

1

5

6

7

9

8

             6. 7和9比較，7小於9，不交換

2

3

1

5

6

7

9

8

             7. 9和8比較，9大於8，9和8交換

2

3

1

5

6

7

8

9

第二輪：

             1. 2和3比較，2小於3，不交換

             2. 3和1比較，3大於1，3和1交換

2

1

3

5

6

7

8

9

             3. 3和5比較，3小於5，不交換

             4. 5和6比較，5小於6，不交換

             5. 6和7比較，6小於7，不交換

             6. 7和8比較，7小於8，不交換 （不和9比較，第一輪9已經是最大的值，所以每輪會少一個數比較）

第三輪  第四輪 ...

循環8輪，數組則通過冒泡排好序了。代碼如下：

public void sort(int array[]) {
        int size = array.length;
        for (int i = size - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (array[j] > array[j + 1]) {
                    array[j] ^= array[j + 1];
                    array[j + 1] ^= array[j];
                    array[j] ^= array[j + 1];
                }
            }
        }
}

最基本的冒泡排序就寫好了。但是，冒泡是可以優化的。

 

優化一：在第三輪的時候，上面數組就已經是：

1

2

3

5

6

7

8

9

               但是，我們會發現我們還會繼續第四輪，第五輪。。。

優化二：在第二輪的時候，上面數組是：

2

1

3

5

6

7

8

9

               這個狀態的時候，5之後就已經排好序了，但是我們還在每輪往後去比較。

 

基於這兩點，優化後的代碼：

public void Sort(int arry[]) {

        int size = arry.length;
        //記錄最後一次交換的位置
        int lastChangPosition = 0;
        //記錄內循環已有序的最小位置
        int noSortCount = arry.length - 1;
        //數組是否已經排好序
        boolean isSorted = false;

        for (int i = 0; i < size; i++) {
            isSorted = true;
            for (int j = 0; j < noSortCount; j++) {
                if (arry[j] > arry[j + 1]) {
                    arry[j] ^= arry[j + 1];
                    arry[j + 1] ^= arry[j];
                    arry[j] ^= arry[j + 1];

                    isSorted = false;
                    lastChangPosition = j;//這一輪的最後交換的位置，位置之後已經排好序
                }
            }

            if (isSorted)
                break;
            noSortCount = lastChangPosition;
        }
}