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

最新推荐文章于 2024-04-23 23:57:04 发布
最新推荐文章于 2024-04-23 23:57:04 发布
阅读量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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
HanMeng的博客
07-24 57万+
文章目录：1. 插入排序2.希尔排序 1. 插入排序 步骤： 1.从第一个元素开始，该元素可以认为已经被排序 2.取下一个元素tem，从已排序的元素序列从后往前扫描 3.如果该元素大于tem，则将该元素移到下一位 4.重复步骤3，直到找到已排序元素中小于等于tem的元素 5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置 6.重复步骤2~5 动图演示如下： 思路：   在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个
十大排序算法详解（一）冒泡排序、选择排序、插入排序、快速排序、希尔排序
热门推荐
HK的博客
06-27 18万+
冒泡排序、选择排序、插入排序、快速排序、希尔排序
冒泡排序及其改进算法：深入理解与实践
suqieer的博客
03-06 796
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的，直到没有再需要交换的元素为止。
排序算法：冒泡排序及优化
doublecircle1的博客
07-29 1922
冒泡排序算法详解以及对冒泡排序算法进行两个优化
常见排序算法：插入排序，选择排序，冒泡排序，快速排序
qq_59057509的博客
12-12 2114
插入排序，选择排序，冒泡排序，快速排序的理解与实现
排序算法：基于C++实现的插入排序、冒泡排序与选择排序
fantasticHQ的博客
04-23 2万+
本文介绍了三种基础的排序算法：插入排序、冒泡排序和选择排序,三种排序适合于小型数据或基本有序的数据集，在实际应用中，更高效的排序算法（如快速排序、归并排序等）通常更受欢迎。
十大经典排序算法-快速排序算法详解
qq_35344198的博客
06-16 8万+
一、什么是快速排序 1.概念 快速排序（Quick Sort）是从冒泡排序算法演变而来的，实际上是在冒泡排序基础上的递归分治法。快速排序在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成了两个部分 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照快速排序的思想，我们先选择一个基准元素，进行排序 我们选取4为我们的基准元素，并设置基准元素的位置为index，设置两个指针left和right，分别指向最左
排序算法:快速排序——C/C++
Tiany的博客
02-13 7574
快速排序详细介绍——C++一.算法介绍二.算法思路三.代码实现 一.算法介绍 快速排序几乎是目前所有排序法中速度最快的方法，STL的sort()函数就是基于快速排序的优化。 时间复杂度 O 最好 O( nlog⁡2nn\log_2nnlog2​n) 最坏（出现几率极小） O(n2n^2n2) 平均 O(nlog⁡2nn\log_2nnlog2​n) 空间复杂度 O(log⁡2n\log_2nlog2​n) 二.算法思路 1.确定一个分界点，将序列分为左右两部
排序算法：快速排序（Python）
m0_61661179的博客
10-11 5万+
思路：快速排序是在冒泡排序基础上的递归分治法。
简述冒泡排序与快速排序
一恍过去
05-01 2万+
简述冒泡排序与快速排序
二叉树建立遍历冒泡排序快速排序算法：C语言编程实现10个数据结构课程设计实例.zip
07-01
二叉树建立遍历冒泡排序快速排序算法：C语言编程实现10个数据结构课程设计实例.zip 二叉树建立遍历冒泡排序快速排序算法：C语言编程实现10个数据结构课程设计实例.zip 二叉树建立遍历冒泡排序快速排序算法：C语言...
Go语言-排序算法：冒泡排序-综合文档
05-14
**冒泡排序**是计算机科学中一种基础且经典的排序算法，它通过重复遍历待排序的元素列表，比较相邻元素并根据需要交换它们的位置来逐步将列表中的元素按顺序排列。在Go语言中，实现冒泡排序同样简单易懂，这使得它...
快速排序是对冒泡排序的一种改进
03-20
快速排序是对冒泡排序的一种改进，其基本思想是通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程...
数组与排序算法：从基础到进阶
最新发布
07-03
《数组与排序算法：从基础到进阶》是一本全面深入探讨数组基础知识和各种排序算法的实用指南。...高级技巧：探讨希尔排序、归并排序、快速排序等高级排序算法，以及它们在实际应用中的优势和局限。
Java排序算法实现：冒泡与选择排序示例代码
01-04
在实际编程中，Java提供了一个内置的`Arrays.sort()`方法，它使用了更高效的排序算法，如快速排序、归并排序等，对于大数据集，效率远高于冒泡排序和选择排序。`Arrays.sort()`可以轻松地对数组或列表进行升序或降序...
简单排序算法：冒泡排序（交换排序）
DirBee的博客
11-07 1377
冒泡排序：是一种交换排序。 基本思想：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。 在不断循环的过程中，不仅将最小的关键字放到第一的位置，还将较小的关键字的位置提升了，较小的数字如同气泡般浮到上面。 import java.util.Arrays; public class Solution { public static void main(String[]
简单排序算法：简单选择排序（选择排序）
DirBee的博客
11-07 1252
简单选择排序法：通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i（1 import java.util.Arrays; public class Solution { public static void main(String[] args) { Solution s = new Solution(); int[] arr
改进排序算法：堆排序（对简单选择排序的改进）
DirBee的博客
11-07 1126
简单选择排序：在待排序的n个记录中选择一个最小的记录需要比较n-1次。但是并没有把每一次的比较结果保存下来，在后一次的比较中，有许多比较在前一次已经做过了，但由于前一次排序时未保存这些比较结果，所以后一次排序时又重复执行了这些比较操作，因而比较次数较多。 堆排序：每次在选择到最小记录的同时，根据比较结果对其他记录做出相应的调整，使得排序的总体效率变高。 大顶堆：每个节点的值都大于或等于其左右孩
C语言实现排序算法：快速排序、冒泡排序与归并排序
"这篇资源包含了C语言实现的几种排序算法，包括快速排序、冒泡排序和归并排序。同时还提供了一些链接操作的代码。" 快速排序是一种高效的排序算法，由英国计算机科学家C.A.R. Hoare在1960年提出。它的基本思想是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值