每日一题（算法：快速排序）

思路：

标题

 

package com.athangzhou.springcloud.service.impl;



import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 快速排序
 * 思想 ： 找中间值
 */
public class QuiteSort {

    public static void main(String[] args) {
        //int arr[] = {6, 5, 7, 8, 8, 2, 4234, 2, -9, -8, 13};
        int[] testArr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            testArr[i] = (int) (Math.random() * 80000);
        }
        // System.out.println("JSON.toJSONString(testArr) = " + JSON.toJSONString(testArr));
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(new Date());
        System.out.println("快速算法：移位法计算开始时间" + format);
        long currentTimeMillis = System.currentTimeMillis();
        quiteSort(testArr, 0, testArr.length - 1);
        System.out.println("快速算法用了" + (System.currentTimeMillis() - currentTimeMillis) + "毫秒");
        String formatEnd = simpleDateFormat.format(new Date());
        System.out.println("快速算法：移位法计算结束时间" + formatEnd);
        // System.out.println("JSON.toJSONString(test) = " + JSON.toJSONString(testArr));

    }

    public static void quiteSort(int arr[], int left, int right) {
        //左边索引
        int l = left;
        //右边索引
        int r = right;

        //中间值
        int pivot = arr[(left + right) / 2];

        //临时变量
        int temp = 0;

        //左边小于右边
        while (l < r) {
            //在pivot的左边一直找，找到大于等于pivot值才退出
            while (arr[l] < pivot) {
                l += 1;
            }

            //在pivot的右边一直找，找到小于等于pivot值才退出
            while (arr[r] > pivot) {
                r -= 1;
            }

            //如果l>=r说明pivot的左右两边的值，
            // 已经按照左边全部是小于等于pivot值，右边全部是大于等于pivot值
            if (l >= r) {
                break;
            }

            //交换  l=2 r=5
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            // {6, 5, 7, 8, 8, 2}
            //[6,5,2,8,8,7]
            //[6,5,2,7,8,8]

            //如果交换完后，发现这个arr[l]==pivot值相等 --  前移
            if (arr[l] == pivot) {
                r -= 1;

            }

            //如果交换完后，发现这个arr[r]==pivot值相等 ++  后移

            if (arr[r] == pivot) {
                l += 1;

            }

        }

        //如果l==r,必须是l++, r--，否则会出现栈溢出
        if (l == r) {
            l += 1;
            r -= 1;
        }

        if (left < r) {
            //左边递归
            quiteSort(arr, left, r);
        }


        if (right > l) {
            //右边递归
            quiteSort(arr, l, right);
        }


    }

}

执行结果：

快速算法：移位法计算开始时间2020-04-23 23:13:02
快速算法用了36毫秒
快速算法：移位法计算结束时间2020-04-23 23:13:02