【数算-07】冒泡排序

1、冒泡排序算法思路

2、冒泡排序算法图解

3、冒泡排序代码实现（已优化）

优化思路：

import org.junit.Test;

import java.lang.reflect.Array;
import java.util.Arrays;

/**
 * @author zhihua.li
 * @date 2021/2/2 - 9:29
 **/
public class BubbleSorting {
    /*
     *   冒泡排序思想：
     *      第一趟，确定数组中的最大数位于最后一个位置，要循环n-1次
     *      第二趟，保证数组中次大数位于倒数第二个位置，循环n-2次
     *      第三趟，保证倒数第三大数位于倒数第三个位置，循环n-3次
     *       ...
     *      直至除第一个位置的数外，其他n-1个数都确定了其对应的位置，返回排序后的序列
     *
     *
     * */

        /*
             冒泡排序推导：
            for (int j=0;j<arr.length-1-0;j++){
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            System.out.println("第一趟排序后的数组"+ Arrays.toString(arr));


            for (int i=0;i<arr.length-1-1;i++){
                if(arr[i]>arr[i+1]){
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
            System.out.println("第二趟排序后的数组"+ Arrays.toString(arr));

            for (int i=0;i<arr.length-3-1;i++){
                if(arr[i]>arr[i+1]){
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
            System.out.println("第三趟排序后的数组"+ Arrays.toString(arr));
    */


    /**
     * @Method bubbleSort
     * @Author zhihua.Li
     * @Version  1.0
     * @Description
     * 正式的冒泡算法：
     *   外循环：i<arr.length-1，因为第一位不用确定其位置
     *   内循环：每经过一次冒泡，循环次数-1，且因为使用 arr[j]和 arr[j+1] 比，所以j<arr.length-1-j
     * 时间复杂度：为O(n^2)
     * 优化思路：
     *      如果遇到某一趟排序从来没有更换过顺序的话，说明数组序列已经有序了，所以就不需要再做下一趟了
     *      因此设置一个flag标志位，用来表示数组序列更改与否
     * @param arr   接受的未排序的数组序列
     * @Return void
     * @Exception
     * @Date 2021/2/2 10:21
     */

    private void bubbleSort(int[] arr) {
        int temp = 0;
        boolean flag = false;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
                /*
                * 如果flag == false说明并未交换过顺序，那么直接跳出循环返回
                * 如果flag == true 说明交换过顺序，因此继续循环，并把flag重新置为false，判断下一次循环是否交换位置
                */
            }
            if(!flag){
                break;
            }else {
                flag = false;
            }
            System.out.println("第" + (i + 1) + "趟冒泡排序后的数组序列为：" + Arrays.toString(arr));
        }
//        System.out.println("排序完成后的序列："+Arrays.toString(arr));
    }
}

4、冒泡排序代码分析

1、测试冒泡排序

@Test
    public void testSort(){
        int[] arr = {3,9,-1,10,-2,-7};
        bubbleSort(arr);
    }

测试结果：

通过代码可以看出，冒泡排序算法的时间复杂度为O(n^2)

2、当面对大量待排序数据时，测试冒泡排序的耗时

@Test
    public void testSort(){
		int[] arr = new int[80000];
        for(int i=0;i<arr.length;i++) {
            arr[i] = (int) (Math.random()*8000000);
        }
//        System.out.println("排序前的序列："+Arrays.toString(arr));
        long l1 = System.currentTimeMillis();
        bubbleSort(arr);
        long l2 = System.currentTimeMillis();
        System.out.println("排序所用时间为："+(l2-l1)+"毫秒");

    }

测试结果：