8种对快速排序等算法的优化_快速排序优化(2)-CSDN博客

本文链接：https://blog.csdn.net/2201_75604580/article/details/138890354

如果你也是看准了Python，想自学Python，在这里为大家准备了丰厚的免费学习大礼包，带大家一起学习，给大家剖析Python兼职、就业行情前景的这些事儿。

一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、学习软件

工欲善其必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

三、全套PDF电子书

书籍的好处就在于权威和体系健全，刚开始学习的时候你可以只看视频或者听某个人讲课，但等你学完之后，你觉得你掌握了，这时候建议还是得去看一下书籍，看权威技术书籍也是每个程序员必经之路。

四、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

成为一个Python程序员专家或许需要花费数年时间，但是打下坚实的基础只要几周就可以，如果你按照我提供的学习路线以及资料有意识地去实践，你就有很大可能成功！
最后祝你好运！！！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

    /**
     * @param arr 双向选择排序
     */
    public static void selectionSortOP(int[] arr) {
        int low = 0;
        int high = arr.length - 1;//[low,high]表示整个无序区间
        // low = high，无序区间只剩下一个元素，整个数组已经有序
        while (low <= high) {
            int min = low;
            int max = low;
            for (int i = low + 1; i <= high; i++) {
                if (arr[i] < arr[min]) {
                    min = i;
                }
                if (arr[i] > arr[max]) {
                    max = i;
                }
            }
            // min索引一定是当前无序区间的最小值索引，与low交换位置
            swap(arr,low,min);
            if (max == low) {//这个代码非常重要！！！！！！！！！！
                // 最大值已经被换到min这个位置
                max = min;
            }
            swap(arr,max,high);
            low += 1;
            high -= 1;
        }
    }

插入排序及其优化

* 每次从无序区间中拿第一个值插入到已经排序区间的合适位置，直到整个数组有序
* 在近乎有序的数据测试中，插入排序的性能好
* 极端情况下，当集合是一个(完全/近乎)有序的集合，插入排序内层循环一次都不走~~~
* 插入排序变为O(N)；因此，插入排序经常作为高阶排序算法的优化手段之一
* 插入排序是稳定的；arr[j] >= arr[j - 1]就停止了；相等的元素不会交换顺序，arr[j] < arr[j - 1]才交换

    /**
     * @param arr 直接插入排序
     */
    public static void insertionSort(int[] arr) {
        // 已排序区间[0,i)
        // 待排序区间[i...n]
        for (int i = 1; i < arr.length; i++) {
            // 待排序区间的第一个元素arr[i]
            // 从待排序区间的第一个元素向前看，找到合适的插入位置
//            for (int j = i; j > 0; j--) {
//                // arr[j - 1]已排序区间的最后一个元素
//                if (arr[j] >= arr[j - 1]) {
//                    // 相等我们也不交换，保证稳定性
//                    // 此时说明arr[j] > 已排序区间的最大值，arr[j]已经有序了~~直接下次循环
//                    break;
//                }else {
//                    swap(arr,j,j - 1);
//                }
//            }
            for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
                swap(arr,j,j - 1);
            }
        }
    }

优化点：因为插入排序中，每次都是在有序区间中选择插入位置 =>> 使用二分查找来定位元素的插入位置

    /**
     * @param arr 折半插入排序
     */
    public static void insertionSortBS(int[] arr) {
        // 有序区间[0..i)
        // 无序区间[i...n]
        // i表示当前正在处理的元素,有序区间和无序区间的分界线就是i
        for (int i = 1; i < arr.length; i++) {
            int val = arr[i];
            int left = 0;
            int right = i;
            while (left < right){
                int mid = left + ((right - left) >> 1);
                if (val < arr[mid]) {
                    right = mid;
                }else {
                    // val >= arr[mid]
                    left = mid + 1;
                }
            }
            // 搬移left..i的元素
            for (int j = i; j > left; j--) {
                arr[j] = arr[j - 1];
            }
            // left就是val插入的位置
            arr[left] = val;
        }
    }

归并排序及其优化

归并排序是一个稳定的nlogn排序算法

此处的稳定指的是时间复杂度稳定且归并排序也是一个稳定性排序算法

时间复杂度稳定：无论集合中的元素如何变化，归并排序的时间复杂度一直都是nlogn,不会退化为O(n^2)

    /**
     * @param arr 未优化的归并排序
     */
    public static void mergeSort(int[] arr) {
        mergeSortInternal(arr,0,arr.length - 1);
    }
    /**
     * 递归语义：在arr[l,r]进行归并排序,整个arr经过此函数后就是一个已经有序的数组
     */
    private static void mergeSortInternal(int[] arr, int l, int r) {
        if(l >= r){//左边的索引==右边的索引
            return;
        }
        int mid = l + ((r - l) >> 1);
        // 将原数组拆分为左右两个小区间，分别递归进行归并排序
        // 走完这个函数之后 arr[l..mid]已经有序
        mergeSortInternal(arr,l,mid);
        // 走完这个函数之后 arr[mid + 1..r]已经有序
        mergeSortInternal(arr,mid + 1,r);
        //merge
        merge(arr,l,mid,r);

    }
    /**
     * 合并两个子数组arr[l,mid]和arr[mid + 1,r]
     * 为一个大的有序数组arr[l,r]
     */
    private static void merge(int[] arr, int l, int mid, int r) {
        // 先创建一个新的临时数组aux
        int[] aux = new int[r - l + 1];
        // 将arr元素值拷贝到aux上
        for (int i = 0; i < aux.length; i++) {
            aux[i] = arr[i + l];
        }
        // i就是左侧小数组的开始索引
        int i = l;
        // j就是右侧小数组的开始索引
        int j = mid + 1;
        // k表示当前正在合并的原数组的索引下标
        for (int k = l; k <= r; k++) {
            if (i > mid) {
                // 左侧区间已经被处理完毕，只需要将右侧区间的值拷贝原数组即可
                arr[k] = aux[j - l];
                j ++;
            }else if (j > r) {
                // 右侧区间已经被处理完毕，只需要将左侧区间的值拷贝到原数组即可
                arr[k] = aux[i - l];
                i ++;
            }else if (aux[i - l] <= aux[j - l]) {
                // 此时左侧区间的元素值较小，相等元素放在左区间，保证稳定性
                arr[k] = aux[i - l];
                i ++;
            }else {
                // 右侧区间的元素值较小
                arr[k] = aux[j - l];
                j ++;
            }
        }
    }

归并排序的两点优化：

1.当左右两个子区间走完子函数后，左右两个区间已经有序了；如果此时arr[mid] < arr[mid + 1]

arr[mid]已经是左区间的最大值；arr[mid + 1]已经是右区间的最小值 => 整个区间已经有序了，没必要再执行merge过程

2.在小区间上，可以直接俄使用插入排序来优化，没必要元素一致拆分到1位置；r - l <= 15,使用插入排序性能是很好的。可以减少归并的递归次数

    public static void mergeSort(int[] arr) {
        mergeSortInternal(arr,0,arr.length - 1);
    }
    /**
     * 在arr[l,r]进行归并排序,整个arr经过此函数后就是一个已经有序的数组
     * 时间复杂度分析：
     * 递归的深度就是拆分数组所用的时间，就是树的高度（logN）
     * 合并两个子数组的过程merge；就是一个数组的遍历过程：O(n)
     */
    private static void mergeSortInternal(int[] arr, int l, int r) {
        if (r - l <= 15) {
            // 优化2.小区间直接使用插入排序
            insertionSort(arr,l,r);
            return;
        }
        int mid = l + ((r - l) >> 1);
        // 将原数组拆分为左右两个小区间，分别递归进行归并排序
        // 走完这个函数之后 arr[l..mid]已经有序
        mergeSortInternal(arr,l,mid);
        // 走完这个函数之后 arr[mid + 1..r]已经有序
        mergeSortInternal(arr,mid + 1,r);
        // 优化1.只有左右两个子区间还有先后顺序不同时才merge
        if (arr[mid] > arr[mid + 1]) {
            merge(arr,l,mid,r);
        }
    }
    /**
     * 合并两个子数组arr[l,mid]和arr[mid + 1,r]
     * 为一个大的有序数组arr[l,r]
     *
     为啥合并过程需要创建一个临时temp数组呢？
     防止在合并的过程中，因为小元素覆盖大的元素，丢失某些元素
     */
    private static void merge(int[] arr, int l, int mid, int r) {
        // 先创建一个新的临时数组temp
        int[] temp = new int[r - l + 1];
        // 将arr元素值拷贝到temp上
        for (int i = 0; i < temp.length; i++) {
            temp[i] = arr[i + l];
        }
        // i就是左侧小数组的开始索引
        int i = l;
        // j就是右侧小数组的开始索引
        int j = mid + 1;
        // k表示当前正在合并的原数组的索引下标
        for (int k = l; k <= r; k++) {
            if (i > mid) {
                // 左侧区间已经被处理完毕，只需要将右侧区间的值拷贝原数组即可
                arr[k] = temp[j - l];
                j ++;
            }else if (j > r) {
                // 右侧区间已经被处理完毕，只需要将左侧区间的值拷贝到原数组即可
                arr[k] = temp[i - l];
                i ++;
            }else if (temp[i - l] <= temp[j - l]) {
                // 此时左侧区间的元素值较小，相等元素放在左区间，保证稳定性！！！
                arr[k] = temp[i - l];
                i ++;
            }else {
                // 右侧区间的元素值较小
                arr[k] = temp[j - l];
                j ++;
            }
        }
    }
    /**
     * 在arr[l..r]使用插入排序
     * 归并优化调用了这个方法
     */
    private static void insertionSort(int[] arr, int l, int r) {
        for (int i = l + 1; i <= r; i++) {
            for (int j = i; j > l && arr[j] < arr[j - 1]; j--) {
                swap(arr,j,j - 1);
            }
        }
    }

快速排序及其优化

快速排序的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

快速排序的三个步骤：

1）选择基准：在待排序列中，按照某种方式挑出一个元素，作为 “基准”（pivot）

2）分割操作：以该基准在序列中的实际位置，把序列分成两个子序列。此时，在基准左边的元素都比该基准小，在基准右边的元素都比基准大

3）递归地对两个序列进行快速排序，直到序列为空或者只有一个元素。

优化一:优化选取基准点

对于分治算法，当每次划分时，算法若都能分成两个等长的子序列时，那么分治算法效率会达到最大。也就是说，基准的选择是很重要的。选择基准的方式决定了两个分割后两个子序列的长度，进而对整个算法的效率产生决定性影响。最理想的方法是，选择的基准恰好能把待排序序列分成两个等长的子序列

两种选择基准的方法

方法(1)：固定位置

思想：取序列的第一个或最后一个元素作为基准
注意：基本的快速排序选取第一个或最后一个元素作为基准。但是，这是一直很不好的处理方法。

思想：取序列的中间元素作为基准。

测试数据分析：如果输入序列是随机的，处理时间可以接受的。如果数组已经有序时，此时的分割就是一个非常不好的分割。因为每次划分只能使待排序序列减1，此时为最坏情况，快速排序沦为起泡排序，时间复杂度为O(n^2)。而且，输入的数据是有序或部分有序的情况是相当常见的。因此，使用某一个元素作为枢纽元是非常糟糕的，为了避免这个情况，就引入了下面两个获取基准的方法。

方法(2)：随机选取基准

引入的原因：在待排序列是部分有序时，固定选取枢轴使快排效率底下，要缓解这种情况，就引入了随机选取枢轴

思想：取待排序列中任意一个元素作为基准

int pivot = (int) (Math.random() * (r - l + 1)) + 1;

测试数据分析：:这是一种相对安全的策略。由于枢轴的位置是随机的，那么产生的分割也不会总是会出现劣质的分割。在整个数组数字全相等时，仍然是最坏情况，时间复杂度是O(n^{2）。实际上，随机化快速排序得到理论最坏情况的可能性仅为1/(2}n）。所以随机化快速排序可以对于绝大多数输入数据达到O(nlogn）的期望时间复杂度。

方法(3)：三数取中（median-of-three）

分析：最佳的划分是将待排序的序列分成等长的子序列，最佳的状态我们可以使用序列的中间的值，也就是第N/2个数。可是，这很难算出来，并且会明显减慢快速排序的速度。这样的中值的估计可以通过随机选取三个元素并用它们的中值作为枢纽元而得到。事实上，随机性并没有多大的帮助，因此一般的做法是使用左端、右端和中心位置上的三个元素的中值作为枢纽元。显然使用三数中值分割法消除了预排序输入的不好情形**，并且减少快排大约14%的比较次数**

举例：待排序序列为：8 1 4 9 6 3 5 2 7 0

左边为：8，右边为0，中间为6.

我们这里取三个数排序后，中间那个数作为枢轴，则枢轴为6

注意：在选取中轴值时，可以从由左中右三个中选取扩大到五个元素中或者更多元素中选取，一般的，会有（2t＋1）平均分区法（median-of-(2t+1)，三平均分区法英文为median-of-three）。

具体思想：对待排序序列中low、mid、high三个位置上数据进行排序，取他们中间的那个数据作为枢轴，并用0下标元素存储枢轴。

即：采用三数取中，并用0下标元素存储枢轴。

/**
	 * @return 取待排序序列中left、mid、right三个位置上数据，选取他们中间的那个数据作为枢轴
	 */
	public static int SelectPivotMedianOfThree(int arr[], int left, int right) {
		int temp = 0;
		int mid = left + ((right - left) >> 1);// 计算数组中间元素的元素的下标
		// 使用三数取中法选择枢轴
		if (arr[mid] > arr[right]) {// 目标：arr[mid] <= arr[right]
			temp = arr[mid];
			arr[mid] = arr[right];
			arr[right] = temp;
		}
		if (arr[left] > arr[right]) {// 目标：arr[left] <= arr[right]
			temp = arr[left];
			arr[left] = arr[right];
			arr[right] = temp;
		}
		if (arr[mid] > arr[left]) {// 目标：arr[left] <= arr[mid]
			temp = arr[mid];
			arr[mid] = arr[left];
			arr[left] = temp;
		}
		// 此时，arr[mid] <= arr[left] <= arr[right]
		// left的位置上保留这三个位置上大小为中间的值
		return arr[left];
	}

测试数据分析：使用三数取中选择枢轴优势还是很明显的，但是还是处理不了重复数组

优化二：当待排序序列的长度分割到一定大小后，使用插入排序

原因：对于很小和部分有序的数组，快排不如插排好。当待排序序列的长度分割到一定大小后，继

续分割的效率比插入排序要差，此时可以使用插排而不是快排

截止范围：待排序序列长度N = 10，虽然在5~20之间任一截止范围都有可能产生类似的结果，这

种做法也避免了一些有害的退化情形。摘自《数据结构与算法分析》Mark Allen Weiness 著

if (right - left + 1 < 10) {
			insertSort(arr);
			return;
}
//else正常的快速排序

测试数据分析：针对随机数组，使用三数取中选择枢轴+插排，效率还是可以提高一点，真是针对已排序的数组，是没有任何用处的。因为待排序序列是已经有序的，那么每次划分只能使待排序序列减一。此时，插排是发挥不了作用的。所以这里看不到时间的减少。另外，三数取中选择枢轴+插排还是不能处理重复数组

优化三：三路快速排序

lt:less than gt:geater than

将数组划分为大于v、小于v、等于v三部分；l表示小于v部分的第一个元素，r表示大于v部分的最后一个元素；因此：arr[l + 1，lt]这部分表示的是所有小于v的元素；arr[lt + 1，i - 1]表示等于v的元素；arr[gt，r] 表示的是大于v这部分元素；i表示当前遍历到的元素；这样，就把要遍历的数据划分好了；现在的主要问题是，划分成这样的区间后，面对一个新的元素，我们应该做咋样的操作？

1）如果e == v ；就将e融入到等于v的这部分元素中，融入的方式就是i++;

2）如果是e < v ;只需要将e和等于v部分的第一个元素交换位置即可；交换完位置后，e就位于小于v部分的后面了；这样做的意义就是为了让e融入小于v部分的元素，融入的方式就是lt++;之后i++,来看下一个元素

3）如果 e > v ;只需要将此元素与大于v部分的前一个元素交换位置即可。此时，原来的大于v部分的前一个元素是还没被遍历的元素，交换后，把它放在了i所指的位置，而e就已经紧挨着大于v这部分元素了，这时将e融入到这部分元素即可，操作为gt–;然后将i++;因为之前交换后，给i所指向的位置挪过来一个未遍历的元素，此时，只需要继续判断这个元素就好了

最终，使用以上的方式一直进行下去，原始的数据就被分成了三部分，终止条件是i == gt，表示当前已经遍历完了所有的元素；然后，还要将v这个元素和lt指向的元素交换一下位置，这样；lt左边的元素都是小于v的元素，右边都是大于等于v的元素;v和等于v这部分元素融为一体，就不需要考虑等于v这部分元素了；下一步，只需要递归的对大于v和小于v这部分元素进行快速排序即可；三路排序的优点：不用考虑重复元素，极端情况下，如果要排序的数据元素全部相等，只需要一轮三路快排，就可以将所有元素全部排列有序。此时，时间复杂度进化为O（n）。三路快排能够非常好的处理有大量重复元素的数据，同时对于近乎有序的数据和完全无序的数据效果也很好。是很多语言标准库中排序算法的底层实现。Java就是这样

    /**
     * @param arr 三路快排
     */
    public static void quickSort3(int[] arr) {
        Random rnd = new Random();
        partition3(arr,0,arr.length - 1,rnd);
    }
    private static void partition3(int[] arr, int l, int r,Random rnd) {
        if (r - l <= 15) {
            insertionSort(arr,l,r);
            return;
        }
        //生成[l,r]之间的随机索引
        int p = l + rnd.nextInt(r - l + 1);
        swap(arr,l,p);
        int v = arr[l];
        // 这些变量的取值，一定是满足区间的定义，最开始的时候，所有区间都是空
        // arr[l + 1..lt] < v
        // lt是指向最后一个<v的元素
        int lt = l;
        // arr[lt + 1..i) == v
        // i - 1是最后一个 = v的元素
        int i = lt + 1;
        // arr[gt..r] > v
        // gt是第一个 > v的元素
        int gt = r + 1;
        // i从前向后扫描和gt重合时，所有元素就处理完毕
        while (i < gt) {
            if (arr[i] < v) {
                // arr[l + 1..lt] < v
                // arr[lt + 1..i) == v
                swap(arr,i,lt + 1);
                i ++;
                lt ++;
            }else if (arr[i] > v) {
                // 交换到gt - 1
                swap(arr,i,gt - 1);
                gt --;
                // 此处i不++，交换来的gt - 1还没有处理
            }else {
                // 此时arr[i] = v
                i ++;
            }
        }
        // lt落在最后一个 < v的索引处
        swap(arr,l,lt);
        // arr[l..lt - 1] < v
        partition3(arr,l,lt - 1,rnd);
        // arr[gt..r] > v
        partition3(arr,gt,r,rnd);
    }

优化四:尾递归排序

快排函数在函数尾部有两次递归操作，我们可以对其使用尾递归优化

优点：如果待排序的序列划分极端不平衡，递归的深度将趋近于n，而栈的大小是很有限的，每次递归调用都会耗费一定的栈空间，函数的参数越多，每次递归耗费的空间也越多。优化后，可以缩减堆栈深度，由原来的O(n)缩减为O(logn)，将会提高性能。

总结：尾递归的特点是在回归过程中不用做任何操作，这个特性很重要，因为大多数现在的编译器会利用这种特点自动生成优化的代码；所以我感觉尾递归的这种方式对于程序员本身而言，知道这种方式就好，因为在实际中，你的代码有没有尾递归的操作，编译器都会对你的代码进行优化，所以，就不进行具体的代码了。重点放在上面的三路快排！！

几种快排的总结：

基本快排：极端情况下，数组就是一个完全有序的数组；在接近有序的数组上，快排会退化为O(N^2),左右两个子区间严重不平衡。避免的方式：(随机基准、三数取中选取基准)

1.当待排序的集合重复元素并不多时，随机化快排已经可以解决问题，甚至性能比2路和3路快排还要好(2路快排和3路快排中为了解决重复元素引入了很多变量和分支)

2.当待排序集合中有大量重复元素时，使用2路或3路快排优化重复元素的处理，要能讲清楚思路

3.如果待排序集合是一个接近有序的集合，分区点的选择就不能单纯的选择最左侧或最右侧元素(随机化选择、三数取中)

一般来说，JVM的栈的深度大概在1w左右，所谓的栈溢出就是JVM调用函数的次数超过了默认的深度；所以大规模数据测试快排会导致栈溢出。所以，为了解决栈溢出问题，一般使用堆排序

大量重复数据测试下：

数据随机范围大的情况下：

快速排序的实际应用

Java 7的对于排序算法的底层使用了三路快排，Go的排序算法的底层综合了插入排序、三位取中选取基准、三路快排的综合版。在小数据的时候会使用插入排序以及希尔排序，为了避免大数据的栈溢出所以也使用了堆排序，一般的情况下，Go会优先使用三路快排。

海量数据的排序问题

最后

Python崛起并且风靡，因为优点多、应用领域广、被大牛们认可。学习 Python 门槛很低，但它的晋级路线很多，通过它你能进入机器学习、数据挖掘、大数据，CS等更加高级的领域。Python可以做网络应用，可以做科学计算，数据分析，可以做网络爬虫，可以做机器学习、自然语言处理、可以写游戏、可以做桌面应用…Python可以做的很多，你需要学好基础，再选择明确的方向。这里给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！