常见排序算法之冒泡排序

常见排序

欢迎来我博客：原文地址

冒泡排序

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。（来源百度百科）

思想：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

图解：

代码实现：

public class BubbleSort {
    public static void main(String[] args) {

        int[] array = {0, 8, 9, 1, 3, 2, 4, 5, 7, 6, 10};
        System.out.println("排序前：");
        System.out.println(Arrays.toString(array));

        //排序
        //表示第i次比较
        for (int i = 0; i < array.length - 1; i++) {
            //每一次依次比较
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                  //tmp 临时变量
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                }
            }

        }
        System.out.println("第" + (i + 1) + "趟排序后的数组");
        System.out.println(Arrays.toString(array));

        System.out.println("排序后：");
        System.out.println(Arrays.toString(array));
    }
}

排序前：
[0, 8, 9, 1, 3, 2, 4, 5, 7, 6, 10]
第1趟排序后的数组
[0, 8, 1, 3, 2, 4, 5, 7, 6, 9, 10]
第2趟排序后的数组
[0, 1, 3, 2, 4, 5, 7, 6, 8, 9, 10]
第3趟排序后的数组
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第4趟排序后的数组
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第5趟排序后的数组
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第6趟排序后的数组
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第7趟排序后的数组
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第8趟排序后的数组
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第9趟排序后的数组
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第10趟排序后的数组
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
排序后：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

代码优化：

在某趟排序中，没有发生一次交换，可以提前结束冒泡排序！

public class BubbleSort {
    public static void main(String[] args) {

        int[] array = {0, 8, 9, 1, 3, 2, 4, 5, 7, 6, 10};
        System.out.println("排序前：");
        System.out.println(Arrays.toString(array));

        //排序
        boolean flag = false; // 标识变量，表示是否进行过交换
        //表示第i次比较
        for (int i = 0; i < array.length - 1; i++) {
            //每一次依次比较
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    flag = true;
                    //tmp 临时变量
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                }
            }
            System.out.println("第" + (i + 1) + "趟排序后的数组");
            System.out.println(Arrays.toString(array));
            if (!flag) { // 在一趟排序中，一次交换都没有发生过
                break;
            } else {
                flag = false; // 重置flag!!!, 进行下次判断
            }

        }

        System.out.println("排序后：");
        System.out.println(Arrays.toString(array));
    }
}

排序前：
[0, 8, 9, 1, 3, 2, 4, 5, 7, 6, 10]
第1趟排序后的数组
[0, 8, 1, 3, 2, 4, 5, 7, 6, 9, 10]
第2趟排序后的数组
[0, 1, 3, 2, 4, 5, 7, 6, 8, 9, 10]
第3趟排序后的数组
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第4趟排序后的数组
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
排序后：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

测试时间：

封装成为方法，用八万个数测试：

public class BubbleSort {
    public static void main(String[] args) {

        //int[] array = {0, 8, 9, 1, 3, 2, 4, 5, 7, 6, 10};
        int[] array = new int[80000];
        for(int i =0; i < 80000;i++) {
            array[i] = (int)(Math.random() * 8000000); //生成一个[0, 8000000) 数
        }
        System.out.println("排序前：");
        System.out.println(Arrays.toString(array));
        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间是=" + date1Str);

        //测试冒泡排序
        bubbleSort(array);

        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("排序后的时间是=" + date2Str);

        System.out.println("排序后：");
        System.out.println(Arrays.toString(array));
    }

    public static void bubbleSort(int array[]) {
        //排序
        boolean flag = false; // 标识变量，表示是否进行过交换
        //表示第i次比较
        for (int i = 0; i < array.length - 1; i++) {
            //每一次依次比较
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    flag = true;
                    //tmp 临时变量
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                }
            }
            if (!flag) { // 在一趟排序中，一次交换都没有发生过
                break;
            } else {
                flag = false; // 重置flag!!!, 进行下次判断
            }

        }
    }
}

测试时间：

排序前的时间是=2019-09-06 07:16:25
排序后的时间是=2019-09-06 07:16:36