超详解内部排序算法之（五）快速排序

快速排序

快速排序简单介绍

快速排序:QuickSort 是对冒泡排序的一种改进。
基本思想
通过一趟排序将要排序的数据分割成两个独立的部分，其中一部分的所有数据都比另外一部分的所有数据都要小，【可以在这思考一下怎么做^- ,或许已经知道怎么做了，等下就验证一下是否是自己想的一样】，然后在按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据有序。

图解分析快速排序的思想

我们对于分析的步骤进行拆解

---

中心思想：从左右两边同时进行检索处理，若左右两边存在位于中轴值两侧的数据，进行交换，否则维持原来位置

---

1.第一步，我们通过原始数组获取一个分组的位置下标和对应的值，将原始数组分为两部分，如上图所示，我们对应的下标Index = （left+right）/ 2【left表示为数组的初始左下标，right表示右下标】对应上边例子的index=2，对应的数据为9，我们建立两个指针，一个从左遍历向9逼近，一个从右向9开始逼近，我们将比9小的放在左边部分，比9大的放在右边部分。我们得到一个第二层的这样的数组。

2. 我们对于分成两部分的数组是不能确保其有序性，我们将对应的两部分在进行如1的操作处理【已经分组的左右两部分不可同时处理】，最终将对应的分组依次从左至右联立起来就得到了我们最终的结果。

代码实现

这个因为递归处理，我们就不用一步一步的进行拆解,我们在中间打印一下验证是否如分析结果

/**
     *
     * @param arr 代操作的数组
     * @param left 数组的左下标
     * @param right 数组的右下标
     */
    public static void quickSort(int[] arr,int left,int right){
        int l =left;
        int r = right;
        // 表示对应的中轴数
        int pivot = arr[(left+right)/2];
        // 临时变量用于操作交换的数
        int temp = 0;

        while(l < r){
            //在中轴值的左边一直找
            while(arr[l]<pivot){//在中轴值的左边找，直到找到>=pivot值，就退出
                l+=1;
            }
            while(arr[r]>pivot){//从右开始
                r-=1;
            }
            //如果l>=r 说明pivot的左右两边的值
            if(l>=r){
                break;
            }
            temp =arr[l];
            arr[l]=arr[r];
            arr[r]=temp;

            //如果交换完之后，发现arr[l]==pivot 值相等，r--, --前移，想象一下如果中间有多个相同的值，不然会遗漏重复数据
            if(arr[l]==pivot){
                r--;
            }
            //如果交换完之后，发现arr[r]==pivot 值相等，l++, 后移
            if(arr[r]==pivot){
                l++;
            }
        }

		//可以在这试着打印看下我们第一次的分组是否符合预期，不进行递归的时候验证一下
		System.out.println(“看下每次的分组”+Arrays.toString(arr));
        //如果左右下标指向同一个位置，我们要错位处理
        if(l==r){
            l+=1;
            r-=1;
        }
		
        // 左递归，我们需要最后分组的最前端的，这个可以对理解一下
        if(left<r){
            quickSort(arr,left,r);

        }
        if(right>l){
            quickSort(arr,l,right);
        }

    }

测试代码(可直接copy使用验证)

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {12,4,9,112,-6,5};
        quickSort(arr,0,arr.length-1);

        System.out.println("arr快排的结果为"+ Arrays.toString(arr));
    }

    /**
     *
     * @param arr 代操作的数组
     * @param left 数组的左下标
     * @param right 数组的右下标
     */
    public static void quickSort(int[] arr,int left,int right){
        int l =left;
        int r = right;
        // 表示对应的中轴数
        int pivot = arr[(left+right)/2];
        // 临时变量用于操作交换的数
        int temp = 0;

        while(l < r){
            //在中轴值的左边一直找
            while(arr[l]<pivot){
                l+=1;
            }
            while(arr[r]>pivot){
                r-=1;
            }
            //如果l>=r 说明pivot的左右两边的值
            if(l>=r){
                break;
            }
            temp =arr[l];
            arr[l]=arr[r];
            arr[r]=temp;

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

        //如果左右下标指向同一个位置，我们要错位处理
        if(l==r){
            l+=1;
            r-=1;
        }
        // 左递归，我们需要最后分组的最前端的
        if(left<r){
            quickSort(arr,left,r);

        }
        if(right>l){
            quickSort(arr,l,right);
        }

    }
}

结果

效率测试

同样我们拿8W个随机数据进行排序测试

测试代码如下

public static void main(String[] args) {

        int[] arr = new int[80000];
        for (int i = 0; i < arr.length; i++) {
            arr[i]=(int)(Math.random()*800000);
        }

        System.out.println("快速排序~~");
        Date dateStart = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Front of Execute:"+simpleDateFormat.format(dateStart));

        quickSort(arr,0,arr.length-1);
        Date dateEnd = new Date();
        System.out.println("Front of Execute:"+simpleDateFormat.format(dateEnd));

    }

8W 个数据感知不够，顺便测试一下80W个数据的效率

效率应该是感知不到的。相较于其他算法超过1S的处理，快速排序的优势显而易见咯。