改进排序算法：快速排序（对冒泡排序的改进）

最新推荐文章于 2020-11-28 23:32:46 发布
最新推荐文章于 2020-11-28 23:32:46 发布
阅读量1k 收藏
点赞数
分类专栏： 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DirBee/article/details/78467779
版权

快速排序的基本思想：通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

Partition函数的作用：选取当中的一个关键字，将它放到一个位置，使得它左边的值都比它小，右边的值比它大，这样的关键字被称为枢轴。

一：取low端的值作为枢轴记录，从high端开始交换

import java.util.ArrayList;
import java.util.Arrays;

public class Solution {
    public static void main(String[] args) {
        Solution s = new Solution();
        int[] arr = {4,5,1,6,2,7,3,8,8,4};
        System.out.println(s.GetLeastNumbers_Solution(arr, 4));   //输出：[1, 2, 3, 4]
    }
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list = new ArrayList<>();
        if (input.length <= 0 || k <= 0 || k > input.length) return list;
        sort(input, 0, input.length - 1);
        System.out.println(Arrays.toString(input));    //输出：[1, 2, 3, 4, 4, 5, 6, 7, 8, 8]
        for (int i = 0; i < k; i++)
            list.add(input[i]);
        return list;
    }
    private void sort(int[] arr, int low, int high)
    {
        int index;
        if (low < high)
        {
            index = partition(arr, low, high);
            sort(arr, low, index - 1);
            sort(arr, index + 1, high);
        }
    }
    private int partition(int[] arr, int low, int high)
    {
        int flag = arr[low];
        while(low < high)
        {
            while (low < high && arr[high] >= flag)
                high--;
            swap(arr, low, high);
            while(low < high && arr[low] <= flag)
                low++;
            swap(arr, low, high);


        }
        return low;
    }
    private void swap(int[] arr, int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}


二：取high端的值作为枢轴记录，从low端开始交换 

import java.util.ArrayList;
import java.util.Arrays;

public class Solution {
    public static void main(String[] args) {
        Solution s = new Solution();
        int[] arr = {4,5,1,6,2,7,3,8,8,4};
        System.out.println(s.GetLeastNumbers_Solution(arr, 4));  //输出：[1, 2, 3, 4]
    }
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list = new ArrayList<>();
        if (input.length <= 0 || k <= 0 || k > input.length) return list;
        sort(input, 0, input.length - 1);
        System.out.println(Arrays.toString(input));  //输出：[1, 2, 3, 4, 4, 5, 6, 7, 8, 8]
        for (int i = 0; i < k; i++)
            list.add(input[i]);
        return list;
    }
    private void sort(int[] arr, int low, int high)
    {
        int index;
        if (low < high)
        {
            index = partition(arr, low, high);
            sort(arr, low, index - 1);
            sort(arr, index + 1, high);
        }
    }
    private int partition(int[] arr, int low, int high)
    {
        int flag = arr[high];
        while(low < high)
        {
            while(low < high && arr[low] <= flag)
                low++;
            swap(arr, low, high);
            while (low < high && arr[high] >= flag)
                high--;
            swap(arr, low, high);

        }
        return low;
    }
    private void swap(int[] arr, int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}


快速排序的复杂度分析：


时间复杂度：

快速排序的时间性能取决于快速排序递归的深度，可以用递归树来描述递归算法的执行情况。若取的枢轴正好是待排序的序列的中间值，则递归树是平衡的，性能也比较好。

在最优情况下，Partition每次都划分得很均匀，如果排序n个关键字，其递归树的深度为[log2n]+1，即仅需递归log2n次，需要时间为T(n)的话，第一次Partition需要对整个数组扫描一遍，做n次比较，然后，获得的枢轴将数组一分为二，各自还需要T(n/2)的时间。不断划分下去。在最优的情况下，快排算法的时间复杂度为O(nlogn)。

在最坏的情况下，待排序的序列为正序或者逆序，每次划分只得到一个比上一次划分少一个记录的子序列，另一个为空。递归树画出来，为一棵斜树。此时需要执行n-1次递归调用，且第i次划分需要经过n-i次关键字的比较才能找到第i个记录，也就是枢轴的位置，最终时间复杂度为O(n^2)。

平均情况下，时间复杂度为O(nlogn)。


空间复杂度：

主要是递归造成的栈空间的使用。

最好情况下，递归树的深度为log2n，空间复杂度为O(logn)。

最坏情况下，需要进行n-1次递归调用，空间复杂度为O(n)。

平均情况下，空间复杂度为O(logn)。


由于关键字的比较和交换是跳跃进行的，快速排序是一种不稳定的排序方法。


快速排序的优化：

一：优化选取枢轴

三数取中法：取三个关键字，先进行排序，将中间数作为枢轴。一般是取左端、右端和中间三个数，也可以随机选取。这样，至少这个中间数一定不会是最小或者最大的数。

三数取中对小数组来说有很大概率可以选择到一个比较好的枢轴，但是对于非常大的待排序的序列还不足以保证能够选择出一个好的枢轴。因此可以九数取中，它先从数组中分三次取样，每次取三个数，三个样品各取出中数，然后从这三个中数当中再取出一个中数作为枢轴。

import java.util.ArrayList;
import java.util.Arrays;

public class Solution {
    public static void main(String[] args) {
        Solution s = new Solution();
        int[] arr = {4,5,1,6,2,7,3,8,8,4};
        System.out.println(s.GetLeastNumbers_Solution(arr, 4));   //输出：[1, 2, 3, 4]
    }
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list = new ArrayList<>();
        if (input.length <= 0 || k <= 0 || k > input.length) return list;
        sort(input, 0, input.length - 1);
        System.out.println(Arrays.toString(input));    //输出：[1, 2, 3, 4, 4, 5, 6, 7, 8, 8]
        for (int i = 0; i < k; i++)
            list.add(input[i]);
        return list;
    }
    private void sort(int[] arr, int low, int high)
    {
        int index;
        if (low < high)
        {
            index = partition(arr, low, high);
            sort(arr, low, index - 1);
            sort(arr, index + 1, high);
        }
    }
    private int partition(int[] arr, int low, int high)
    {
        int m = low + (high - low) / 2;
        if (arr[low] > arr[high]) swap(arr, low, high);
        if (arr[m] > arr[high]) swap(arr,m, high);
        if (arr[low] < arr[m]) swap(arr, low, m); //此时，low端的值为中间值
        int flag = arr[low];
        while(low < high)
        {
            /*while (low < high && arr[high] >= flag) //无论从low端开始交换还是从high端开始交换都可以
                high--;
            swap(arr, low, high);
            while(low < high && arr[low] <= flag)
                low++;
            swap(arr, low, high);*/
            while(low < high && arr[low] <= flag)
                low++;
            swap(arr, low, high);
            while (low < high && arr[high] >= flag)
                high--;
            swap(arr, low, high);
        }
        return low;
    }
    private void swap(int[] arr, int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

二：优化不必要的交换

同上：取low端的值作为枢轴记录，从high端开始交换；取high端的值作为枢轴记录，从low端开始交换

import java.util.ArrayList;
import java.util.Arrays;

public class Solution {
    public static void main(String[] args) {
        Solution s = new Solution();
        int[] arr = {4,5,1,6,2,7,3,8,8,4};
        System.out.println(s.GetLeastNumbers_Solution(arr, 4));   //输出：[1, 2, 3, 4]
    }
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list = new ArrayList<>();
        if (input.length <= 0 || k <= 0 || k > input.length) return list;
        sort(input, 0, input.length - 1);
        System.out.println(Arrays.toString(input));    //输出：[1, 2, 3, 4, 4, 5, 6, 7, 8, 8]
        for (int i = 0; i < k; i++)
            list.add(input[i]);
        return list;
    }
    private void sort(int[] arr, int low, int high)
    {
        int index;
        if (low < high)
        {
            index = partition(arr, low, high);
            sort(arr, low, index - 1);
            sort(arr, index + 1, high);
        }
    }
    private int partition(int[] arr, int low, int high)
    {
        int flag = arr[low];
        while(low < high)
        {
            while (low < high && arr[high] >= flag)
                high--;
            arr[low]= arr[high];
            
            while(low < high && arr[low] <= flag)
                low++;
            arr[high] = arr[low];
        }
        arr[low]= flag;
        return low;
    }
}

三：优化小数组时的排序方案

如果数组非常小，直接插入排序比快速排序更好。（直接插入排序是简单排序中性能最好的）

快速排序中，用到了递归操作，在大量数据排序时，这点性能影响对于它的整体算法优势而言可以忽略。

import java.util.ArrayList;
import java.util.Arrays;

public class Solution {
    public static final int CUTOFF = 7;
    public static void main(String[] args) {
        Solution s = new Solution();
        int[] arr = {4,5,1,6,2,7,3,8,8,4};
        System.out.println(s.GetLeastNumbers_Solution(arr, 4));   //输出：[1, 2, 3, 4]
    }
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {

        ArrayList<Integer> list = new ArrayList<>();
        if (input.length <= 0 || k <= 0 || k > input.length) return list;

        sort(input, 0, input.length - 1);

        System.out.println(Arrays.toString(input));    //输出：[1, 2, 3, 4, 4, 5, 6, 7, 8, 8]

        for (int i = 0; i < k; i++)
            list.add(input[i]);

        return list;
    }
    private void sort(int[] arr, int low, int high)
    {
        int index;
        if ((high - low) > CUTOFF)
        {
            index = partition(arr, low, high);
            sort(arr, low, index - 1);
            sort(arr, index + 1, high);
        }
        else
            InsertSort(arr, low, high);
    }
    private int partition(int[] arr, int low, int high)
    {
        int flag = arr[low];
        while(low < high)
        {
            while (low < high && arr[high] >= flag)
                high--;
            arr[low]= arr[high];

            while(low < high && arr[low] <= flag)
                low++;
            arr[high] = arr[low];
        }
        arr[low]= flag;
        return low;
    }
    private void InsertSort(int[] arr, int low, int high) //直接插入排序
    {
        for (int i = low + 1; i <= high; i++)
        {
            if (arr[i] < arr[i - 1])
            {
                int save = arr[i];
                int j = i - 1;
                for (; j >= 0 && arr[j] > save; j--)
                    arr[j + 1] = arr[j];
                arr[j + 1] = save;
            }
        }
    }
}

四：优化递归操作

sort函数在其尾部有两次递归操作。如果待排序的序列划分极端不平衡，递归深度将趋近于n，而不是平衡时的logn，这不仅仅是速度快慢的问题。

栈的大小是有限的，每次递归调用会耗费一定的栈空间，函数的参数越多，每次递归耗费的空间也越多。

所以要减少递归。

import java.util.ArrayList;
import java.util.Arrays;

public class Solution {
    public static final int CUTOFF = 7;
    public static void main(String[] args) {
        Solution s = new Solution();
        int[] arr = {4,5,1,6,2,7,3,8,8,4};
        System.out.println(s.GetLeastNumbers_Solution(arr, 4));   //输出：[1, 2, 3, 4]
    }
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {

        ArrayList<Integer> list = new ArrayList<>();
        if (input.length <= 0 || k <= 0 || k > input.length) return list;

        sort(input, 0, input.length - 1);

        System.out.println(Arrays.toString(input));    //输出：[1, 2, 3, 4, 4, 5, 6, 7, 8, 8]

        for (int i = 0; i < k; i++)
            list.add(input[i]);

        return list;
    }
    private void sort(int[] arr, int low, int high)
    {
        int index;
        if ((high - low) > CUTOFF)
        {
            while (low < high)
            {
                index = partition(arr, low, high);
                sort(arr, low, index - 1);
                low = index + 1; //尾递归，采用迭代而不是递归的方式，缩减了堆栈深度，提高了整体性能
            }

        }
        else
            InsertSort(arr, low, high);
    }
    private int partition(int[] arr, int low, int high)
    {
        int flag = arr[low];
        while(low < high)
        {
            while (low < high && arr[high] >= flag)
                high--;
            arr[low]= arr[high];

            while(low < high && arr[low] <= flag)
                low++;
            arr[high] = arr[low];
        }
        arr[low]= flag;
        return low;
    }
    private void InsertSort(int[] arr, int low, int high) //直接插入排序
    {
        for (int i = low + 1; i <= high; i++)
        {
            if (arr[i] < arr[i - 1])
            {
                int save = arr[i];
                int j = i - 1;
                for (; j >= 0 && arr[j] > save; j--)
                    arr[j + 1] = arr[j];
                arr[j + 1] = save;
            }
        }
    }
}


import java.util.Arrays;

public class Solution {
    public static final int CUTOFF = 10;
    public static void main(String[] args) {
        Solution s = new Solution();
        int[] arr = {4,5,1,6,2,7,3,8,8,4,2};
        s.quicksort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr)); //输出：[1, 2, 2, 3, 4, 4, 5, 6, 7, 8, 8]
    }
    private void quicksort(int[] arr, int low, int high)
    {
        if (low + CUTOFF <= high)
        {
            int m = (high + low) / 2;
            if (arr[m] < arr[low]) swap(arr, low, m);
            if (arr[high] < arr[low]) swap(arr, low, high);
            if (arr[high] < arr[m]) swap(arr, m, high); //此时，m端的值为中间值

            swap(arr, m, high - 1);
            int flag = arr[high - 1];

            int i = low;
            int j = high - 1;
            for ( ; ; )
            {
                while(arr[++i] < flag);
                while (arr[--j] > flag);
                if (i < j)
                    swap(arr, i, j);
                else
                    break;
            }
            swap(arr, i, high - 1);

            quicksort(arr, low, i - 1);
            quicksort(arr, i + 1, high);
        }
        else
            InsertSort(arr, low, high);
    }
    private void InsertSort(int[] arr, int low, int high) //直接插入排序
    {
        for (int i = low + 1; i <= high; i++)
        {
            if (arr[i] < arr[i - 1])
            {
                int save = arr[i];
                int j = i - 1;
                for (; j >= 0 && arr[j] > save; j--)
                    arr[j + 1] = arr[j];
                arr[j + 1] = save;
            }
        }
    }
    private void swap(int[] arr, int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

}



求k个最小的数： 点击打开链接





when_bounce
关注
专栏目录
改进的快速排序算法
11-04
快速排序算法的改进思路 1.选取好的基准，是两边的数据个数尽量的均匀 取数组的第一个，中间，最后一个数据，取三个数中第二大的数作为基准 2. 不递归 3.与插入结合，当段内的数组个数小于等于16的时候，使用插入排序
快速排序-冒泡法改进
算法与程序并行
09-24 1102
快速排序：是对冒泡法的一种改进。 它的基本思想是，通过一趟排序将待排记录分割成独立的两部分， 其中一部分的关键字均比另一部分记录的关键字小， 则可分别对这两部分记录继续进行排序，以达到整个序列有序。总的时间复杂度为O(N2) c程序实现 #include #include void swap(int *x,int *y) { int temp;      tem
快速排序算法（冒泡排序算法的改进）-递归实现-数据结构-python实现及测试实例
妙手书生的博客
11-28 658
目录 快速排序算法介绍 算法原理介绍方案1 算法原理介绍2 python函数实现及测试案例 快速排序算法介绍 快速排序其实是在冒泡排序的基础上做出的一个改进.。冒泡排序看另外一篇博客：https://blog.csdn.net/weixin_36602742/article/details/110244894 快速排序算法利用的是一趟快速排序,基本内容是选择一个数作为准基数,然后利用这个准基数将遗传数据分为两个部分,第一部分比这个准基数小,都放在准基数的左边,第二部分都比这个准基数大,放.
快速排序算法的改进
weixin_34380781的博客
03-22 138
  由于快速排序多次因为很小的子文件而调用自身，所以可以在其长度较小时，停止使用快速排序，而使用插入排序： If (right - left &lt;= M) InsertSort(Item, left, right) M通常取5-25，实验表明，其速度比M=1快10%以上 中间元素法： 取3个元素的中间元素作为Partition的依据，而不是Item[ri...
【排序算法系列 6】 高级排序——归并排序（由冒泡排序改进）
Java技术工坊
10-20 355
简介 快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 需求 排序前：{6, 1, 2, 7, 9, 3, 4, 5, 8} 排序后：{1, 2, 3, 4, 5, 6, 7, 8, 9} 快速排序原理 首先设定一个分界值，通过该分界值将数组分成左右两部分； 将大于或等于分界值的数据放到到数组右边，小
二叉树建立遍历冒泡排序快速排序算法：C语言编程实现10个数据结构课程设计实例.zip
最新发布
07-01
二叉树建立遍历冒泡排序快速排序算法：C语言编程实现10个数据结构课程设计实例.zip 二叉树建立遍历冒泡排序快速排序算法：C语言编程实现10个数据结构课程设计实例.zip 二叉树建立遍历冒泡排序快速排序算法：C语言...
冒泡排序的改进算法和快速排序
微风
04-20 6017
通过实现快速排序让我对排序算法有了更加深入的理解，希望再接再厉。
快速排序算法（冒泡算法改进版）
Tobin_Xu的博客
12-21 401
坐在马桶上看算法：快速排序 算法的精髓在于，跟它一比高数也显得那么生动活泼…。本文由啊哈磊吐槽而成，话说我还是头一次见到这么萌的变量，简直颠覆我对变量这个兵种、对算法这个种族的传统观念。正在被算法欺负吗？快进来看看： 作者：啊哈磊来源：51CTO博客|2014-03-03 16:44  移动端  收藏   分享 【限时免费】年底最强一次云计算大会，看传统
排序算法: 冒泡排序，桶排序，计数排序，堆排序，插入排序，合并排序，快速排序，基数排序，选择排序，希尔排序 实现语言: C++
01-15
本文将详细探讨十种经典的排序算法在C++中的实现，分别是冒泡排序、桶排序、计数排序、堆排序、插入排序、合并排序、快速排序、基数排序、选择排序和希尔排序。 1. **冒泡排序**：冒泡排序是最简单的排序算法之一，...
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨C++实现的八种常见的排序算法，它们分别是插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序。这些排序算法在计算机科学中有着广泛的应用，是理解和掌握...
快速排序是对冒泡法排序的一种改进。
02-15 353
快速排序算法 的基本思想是：将所要进行排序的数分为左右两个部分，其中一部分的所有数据都比另外一 部分的数据小，然后将所分得的两部分数据进行同样的划分，重复执行以上的划分操作，直 到所有要进行排序的数据变为有序为止。 可能仅根据基本思想对快速排序的认识并不深，接下来以对n个无序数列A[0], A[1]…, A[n-1]采用快速排序方法进行升序排列为例进行讲解。 (1)定义两个变量lo
快速排序 改进快排的方法
热门推荐
lingfengtengfei的专栏
10-07 2万+
快速排序法事应用最广泛的排序算法之一，最佳情况下时间复杂度是 O(nlogn)。但是最坏情况下可能达到O(n^2)。说明快速排序达到最坏情况的原因。并提出改善方案并实现之。 答： 改进方案：改进选取枢轴的方法 1、选取随机数作为枢轴。 但是随机数的生成本身是一种代价，根本减少不了算法其余部分的平均运行时间。 2、使用左端，右端和中心的中值做为枢轴元。 经验得知，选取左端，右端，中心元素
快速排序改进算法
ForLearning
09-13 2051
#include using namespace std; const int M = 20; void quickSort(int *data,const int left,const int right); int partition(int *data,const int low,const int high); void insertSort(int *data,const int le
排序算法：冒泡排序，快速排序
u012933335的博客
02-18 267
排序算法 冒泡排序 思想：把相邻的元素两两比较，当一个元素大于右侧相邻元素时，交换它们的位置！每一个循环将较大数置于右侧。时间复杂度就是O(nlogn)。 优化点： 每次循环后可剔除右侧一个元素就行比较 若一个循环下来，没有任何元素交换，说明数组有序，可直接退出 若循环在某个index之后，就没有进行数据交换，说明该index后的数组有序，不进入循环。 鸡尾酒排序 对冒泡排序的升级，冒泡排序始...
原创系列 |「冒泡排序」提升为「快速排序」，都发生了什么？
算法channel
10-21 395
「Python与算法社区」第310篇原创“1 你会学到什么？”彻底弄明白常用的排序算法的基本思想，算法的时间和空间复杂度，以及如何选择这些排序算法，确定要解决的问题...
【数据结构】-排序-快速排序的改进算法
vector的博客
07-05 753
快速排序的最好情况是每一趟排序的基准值都将序列划分成两个长度尽可能一样的序列 在默认情况下，我们通常选择第一个元素作为基准值，但是，则会有问题。 最坏情况是原序列顺序和逆序的情况，此时基准值左右的序列长度一个是0，一个是n-1 即使序列原本就是顺序的，但是快排它无法判断有序，还是不断地做比较；逆序的情况下是不断地比较，不断地移动元素。 因此，将基准值的选取对快排的效率有很大的影响，我们用“随机”法和“三数取中”法来选取基准值，这样的方法基本可以避免上述两种最坏的情况发生。 编程注意事项： 1.c
【排序算法】快速排序的分析改进
Qregi的博客
03-19 9711
基本的快速排序最基本的快速排序是由C.A.R.Hoare在1960年提出的，快速排序的算法是一种分治排序算法它将数组划分为两个部分，然后分别对两个部分进行排序快速每次对数组重新排序，选择一个基准值key，然后让数组满足下面的两个个条件·a[l]， ... ，a[i - 1]之中的元素都比key值要小·a[i + 1], ... ,a[r]之中的元素都比key值要大然后通过划分来完成排序，递归的去处...
快速排序
weixin_34082177的博客
03-19 95
快速排序是对冒泡排序的一种改进。它的基本思想是，通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。        假设待排序的序列为{a[L],a[L+1],a[L+2],……,a[R]}，首先任意选取一个记录（通常可选中间一个记作为枢轴或支点），然后重新排列其余记录，将所有关键字小于它的记录都...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值