算法__冒泡排序

冒泡排序:从数组的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;
        }
}