经典冒泡排序的分析、实现、优化及测试

经典冒泡排序的分析、实现、优化及测试

1.冒泡排序的过程

int arr[] = {3,9,-1,-10,-2};

假设对arr这个数组进行排序，
第一轮：
（1）3和9进行比较，3不大于9，3和9的位置不交换
（2）9和-1进行比较，9大于-1，9和-1交换位置，数组变为

{3,-1,9,-10,-2}

（3）9和-10进行比较，9大于-10，9和-10交换位置，数组变为

{3,-1,-10,9,-2}

（4）9和-2进行比较，9大于-2，9和-2交换位置，数组变为

{3,-1,-10,-2,9}

通过这一段流程可以得出两点：
1.冒泡排序时，是拿数组的每一个元素与这个元素的下一个元素进行比较，如果这个元素比下一个元素大，就交换位置，否则就再进行判断。
2.这一轮排序的使得这个数组中最大的数排在了数组的在最后一个位置，这一点很重要。
第二轮：
和第一轮同样的方法，但是比较的次数少了一次，因为我们已经排出最大的数了，所以第二轮，可以排序出第二大的数，结果如下

{-1,-10,-2,3,9}

…
最多进行5轮排序，就可以将数组排序好。

2.代码实现

package test1;

import java.util.Random;

/**
 * 冒泡排序
 */
public class BubbleSort {
    public static void main(String[] args) {
        //int arr[] = {3,9,-1,-10,-2};
        int arr[] = new int[80000];
        //产生8万条随机数
        for (int i = 0; i < 80000; i++) {
            arr[i]= new Random().nextInt(80000);
        }
        long before = System.currentTimeMillis();
        bubbleSort(arr);
        long after = System.currentTimeMillis();
        System.out.println((after-before)/1000);
    }
    public static int[] bubbleSort(int[] arr){
        boolean flag = false;
        for (int i = 0; i < arr.length; i++) {
            int temp = 0;
            for (int j = 1; j < arr.length-i; j++) {
                if (arr[j-1]>arr[j]){
                    temp = arr[j-1];
                    arr[j-1] = arr[j];
                    arr[j] = temp;
                    flag = true;
                }
            }
            //System.out.println(Arrays.toString(arr));
            //如果已经排好序，就退出，不再进行判断
            if (!flag){
                break;
            }else {
                flag = false;
            }
        }
        return arr;
    }
}

3.冒泡排序的优化

可以设想会有这样一种情况，一共进行5轮排序，但是在第三轮的时候就数组就已经排好序了，例如：

{5,4,1,2,3}

第三轮就已经排好序就无需继续再进行比较，直接退出循环即可。
flag默认为false

 //如果已经排好序，就退出，不再进行判断
            if (!flag){
                break;
            }else {
                flag = false;
            }

4.冒泡排序测试

将上面的代码运行之~

我的电脑测试了大约需要8秒的时间，顺嘴提一句冒泡排序的时间复杂度是O（n^2）