冒泡排序

class{
    ArrayList<Integer> list = new ArrayList<>();
    
    Random random = new Random();

    int temporary;

    /**
     * 数据准备
     * 随机生成数据
     */
    public void generateRandomNumbers() {

        for (int i1 = 0; i1 < 10; i1++) {

            list.add(random.nextInt(100) + 1);

        }

        System.out.println("排序前list : " + list);

    }

   /**
     * 冒泡排序 ：1 从最后一位与倒数第二位比较 大数放到最后一位的位置上
     * 倒数第二位再与倒数第三位比较 大数放到倒数第二位的位置上
     * 类推  （遍历一遍最小数就在第一位） （内循环）
     * 2 遍历一遍可以确定一个最小值 所以还需要加一个外循环
     * 3 外循环的长度 由于内循环是两两比较 所以 循环次数可以是集合长度 -1
     * 4 内循环 循环一次就确定一位最小值 所以只用比较剩下的几位 i>j
     */

    // 冒泡排序
    public void maoPaoTest() {

        //generateRandomNumbers();

        TimeUtil.start();

        //比较的次数
        for (int j = 0; j < list.size() - 1; j++) {
            //单次比较范围
            for (int i = list.size() - 1; i > j; i--) {
                //如果后一位小于前一位 两位数互换位子
                if (list.get(i) < list.get(i - 1)) {
                    //把后一位数值 临时存储
                    temporary = list.get(i);
                    //把前一位数值存储到后一位置上
                    list.set(i, list.get(i - 1));
                    //把临时存储到数值存储到前一位位置上
                    list.set(i - 1, temporary);
                }

            }
        }

        TimeUtil.end();

        System.out.println("冒泡排序后: " + list);

        System.out.println("冒泡排序使用时间: " + TimeUtil.useTimeNS() + " 纳秒");
    }

    @Test
    public void test() {

        for (int i = 1; i <= 10; i++) {

            System.out.println("=========== 第" + i + "次排序 ========== ");

            generateRandomNumbers();

            maoPaoTest();

            list.removeAll(list);

            System.out.println();

        }

    }
}

测试结果

=========== 第1次排序 ========== 
排序前list : [9, 47, 64, 15, 2, 27, 94, 89, 87, 48]
冒泡排序后: [2, 9, 15, 27, 47, 48, 64, 87, 89, 94]
冒泡排序使用时间: 73677 纳秒

=========== 第2次排序 ========== 
排序前list : [8, 47, 69, 96, 48, 17, 72, 54, 71, 7]
冒泡排序后: [7, 8, 17, 47, 48, 54, 69, 71, 72, 96]
冒泡排序使用时间: 27018 纳秒

=========== 第3次排序 ========== 
排序前list : [18, 34, 32, 4, 30, 46, 39, 40, 21, 45]
冒泡排序后: [4, 18, 21, 30, 32, 34, 39, 40, 45, 46]
冒泡排序使用时间: 21483 纳秒

=========== 第4次排序 ========== 
排序前list : [37, 65, 91, 14, 13, 69, 84, 74, 92, 75]
冒泡排序后: [13, 14, 37, 65, 69, 74, 75, 84, 91, 92]
冒泡排序使用时间: 47005 纳秒

=========== 第5次排序 ========== 
排序前list : [83, 89, 10, 27, 45, 15, 13, 52, 83, 84]
冒泡排序后: [10, 13, 15, 27, 45, 52, 83, 83, 84, 89]
冒泡排序使用时间: 24760 纳秒

=========== 第6次排序 ========== 
排序前list : [43, 65, 41, 75, 27, 91, 99, 25, 81, 67]
冒泡排序后: [25, 27, 41, 43, 65, 67, 75, 81, 91, 99]
冒泡排序使用时间: 25741 纳秒

=========== 第7次排序 ========== 
排序前list : [30, 24, 59, 79, 40, 31, 25, 60, 18, 65]
冒泡排序后: [18, 24, 25, 30, 31, 40, 59, 60, 65, 79]
冒泡排序使用时间: 26464 纳秒

=========== 第8次排序 ========== 
排序前list : [81, 52, 55, 46, 76, 34, 97, 4, 93, 83]
冒泡排序后: [4, 34, 46, 52, 55, 76, 81, 83, 93, 97]
冒泡排序使用时间: 26980 纳秒

=========== 第9次排序 ========== 
排序前list : [31, 77, 40, 34, 67, 31, 75, 39, 6, 53]
冒泡排序后: [6, 31, 31, 34, 39, 40, 53, 67, 75, 77]
冒泡排序使用时间: 28845 纳秒

=========== 第10次排序 ========== 
排序前list : [96, 29, 74, 28, 27, 20, 73, 38, 79, 12]
冒泡排序后: [12, 20, 27, 28, 29, 38, 73, 74, 79, 96]
冒泡排序使用时间: 32627 纳秒