快速排序

快速排序 一

class{

    ArrayList<Integer> list = new ArrayList<>();
    Random random = new Random();
    int temporary;

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



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

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

        }

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


    }
public void kuaiSuPaiXuTest01(ArrayList<Integer> list, int left, int right) {


        if (left < right) {
            //集合或数组 下标left的数值作为比较的基数
            int base = list.get(left);
            // 以下标为基础设置两个变量
            int z = left, y = right;

            while (z != y) {
                // 从右向左查找 连续大于基数最前面一位的下标
                while (list.get(y) >= base && z < y) {
                    y--;
                }
                // 从左向右查找 连续小与基数的最后一位的下标
                while (list.get(z) <= base && z < y) {
                    z++;
                }
                // 如果 小于基数的下标 小于 大于基数的下标 两个数直接交换
                if (z < y) {
                    temporary = list.get(z);
                    list.set(z, list.get(y));
                    list.set(y, temporary);
                }
            }

            // 连续小与基数的最后一位的数值 放到基数位置上
            list.set(left, list.get(z));
            // 把基数 放到连续小与基数的最后一位的数值
            list.set(z, base);

            // 以刚刚上面基数保存的下标 向两边递归
            kuaiSuPaiXuTest01(list, left, z - 1);

            kuaiSuPaiXuTest01(list, z + 1, right);


        } else {
            return;
        }


    }
@Test
    public void test01() {

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

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

            TimeUtil.start();
            kuaiSuPaiXuTest01(list, 0, list.size() - 1);
            TimeUtil.end();

            System.out.println("快速排序后： " + list);
            System.out.println("快速排序使用时间: " + TimeUtil.useTimeNS() + " 纳秒");
            System.out.println();

        }
    }

}

测试结果

=========== 第1次排序 ========== 
排序前 : [54, 31, 3, 64, 61, 58, 66, 29, 45, 40]
快速排序后： [3, 29, 31, 40, 45, 54, 58, 61, 64, 66]
快速排序使用时间: 46779 纳秒

=========== 第2次排序 ========== 
排序前 : [46, 25, 32, 89, 40, 51, 21, 97, 56, 36]
快速排序后： [21, 25, 32, 36, 40, 46, 51, 56, 89, 97]
快速排序使用时间: 14856 纳秒

=========== 第3次排序 ========== 
排序前 : [23, 2, 54, 75, 39, 20, 80, 80, 67, 50]
快速排序后： [2, 20, 23, 39, 50, 54, 67, 75, 80, 80]
快速排序使用时间: 20625 纳秒

=========== 第4次排序 ========== 
排序前 : [81, 19, 18, 55, 83, 15, 4, 17, 26, 54]
快速排序后： [4, 15, 17, 18, 19, 26, 54, 55, 81, 83]
快速排序使用时间: 13062 纳秒

=========== 第5次排序 ========== 
排序前 : [34, 11, 96, 15, 31, 71, 14, 24, 34, 20]
快速排序后： [11, 14, 15, 20, 24, 31, 34, 34, 71, 96]
快速排序使用时间: 12573 纳秒

=========== 第6次排序 ========== 
排序前 : [85, 89, 85, 72, 47, 71, 19, 88, 49, 99]
快速排序后： [19, 47, 49, 71, 72, 85, 85, 88, 89, 99]
快速排序使用时间: 13117 纳秒

=========== 第7次排序 ========== 
排序前 : [93, 13, 68, 14, 26, 49, 31, 87, 49, 15]
快速排序后： [13, 14, 15, 26, 31, 49, 49, 68, 87, 93]
快速排序使用时间: 32221 纳秒

=========== 第8次排序 ========== 
排序前 : [76, 14, 34, 46, 65, 36, 22, 4, 51, 1]
快速排序后： [1, 4, 14, 22, 34, 36, 46, 51, 65, 76]
快速排序使用时间: 18567 纳秒

=========== 第9次排序 ========== 
排序前 : [7, 72, 34, 18, 42, 57, 99, 5, 31, 26]
快速排序后： [5, 7, 18, 26, 31, 34, 42, 57, 72, 99]
快速排序使用时间: 14316 纳秒

=========== 第10次排序 ========== 
排序前 : [1, 26, 4, 16, 51, 84, 49, 23, 20, 80]
快速排序后： [1, 4, 16, 20, 23, 26, 49, 51, 80, 84]
快速排序使用时间: 22303 纳秒