排序算法 - 快速排序（Lomuto and Hoare 分区）

已于 2023-08-31 18:34:56 修改
阅读量1.4k 收藏 6
点赞数 4
分类专栏： 算法集 文章标签： 排序算法 算法
于 2023-08-24 21:00:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ly1347889755/article/details/132482340
版权

文章目录

TIP：更多文章笔者考虑同步到 javgo.cn，目前内容较少，后续会陆续更新。

1.快速排序概念

快速排序是一种高效的通用排序算法，由英国计算机科学家托尼·霍尔（Tony Hoare）于 1960 年发明，并于 1961 年发表。尽管有许多新的排序算法被发明，快速排序仍然 是现代计算中常用的排序算法之一。在实际应用中，对于随机数据，它通常比归并排序和堆排序更快，尤其是数据量较大时。

快速排序采用了 “分而治之” 的策略。它的基本思想是从待排序数组中选择一个 “基准（pivot）” 元素，然后根据其他元素与基准元素的大小关系，将它们划分为两个子数组。在每次分区操作结束后，基准元素都被放置在其最终应该出现的位置上。接着，算法对这两个子数组进行递归排序，直到子数组的长度小于等于1。由于这种分区和交换的特性，快速排序有时也被称为分区交换排序（partition-exchange sort）。

快速排序属于比较排序，因为它的核心操作是将数组元素与选定的基准元素进行比较。如果某个元素小于基准元素，它会被放到左子数组；如果大于或等于基准元素，它会被放到右子数组。需要注意的是，由于这种比较和交换的方式，快速排序可能是不稳定的。这意味着原始数据中相等的元素在排序后可能会改变它们的相对顺序。

从性能角度来看，快速排序算法平均需要 O(n log n) 次比较来对 n 个项目进行排序，在最坏的情况下它会进行 O(n^2）次比较。
Sorting_quicksort_anim.gif
快速排序算法（水平线是基准值）

2.算法实现

上面我们说过，快速排序是基于 “分而治之” 策略的排序方法。它通过一个称为 “分区（partition）” 的步骤来对数组进行排序。由于分区的实现方式可能有所不同，所以快速排序有多种变体，但它们都遵循相同的基本原则。

简单来说，当我们对一个包含至少两个元素的数组进行排序时，快速排序会将其分为两个子数组，确保第一个子数组中的每个元素都不大于第二个子数组中的任何元素。然后，它会递归地对这两个子数组进行同样的操作。

下面是快速排序的基本步骤：

  1. 检查数组长度：如果数组中的元素少于两个，那么不需要排序，直接返回。如果是对于非常短的数组，我们可能会使用其他排序方法。
  2. 选择基准值：从数组中选择一个值作为基准（piovt）。选择的方法可能因实现而异，有时甚至可能是随机的。
  3. 进行分区：根据基准值重新排列数组，确保所有小于基准的元素都在其左侧，而大于基准的元素都在其右侧。等于基准的元素可以放在任意一侧。
  4. 确认基准位置：大部分分区方法都会确保一轮分区结束后基准值最终位于正确的排序位置。
  5. 递归排序：对基准左侧和右侧的子数组递归地应用快速排序。

值得注意的是，如何选择基准值和具体的分区方法可能会不同程度的影响快速排序的效率。因此，当我们谈论快速排序的性能时，需要明确使用的具体方法和策略。

下面是一个对随机顺序的数组进行快速排序的完整示意图，图中的深色元素为选择的基准（pivot），在这里它始终被选定为分区中的最后一个元素。
image.png
注意 ⚠️：
在快速排序算法中，如果我们每次都选择分区的最后一个元素作为基准来进行排序，那么在某些特定情况下（如数组已经排序或数组中所有元素都相同）这种选择策略会导致算法的性能下降，具体到时间复杂度 为O(n^2)。这是因为在这些特定情况下，每次分区都会非常不均匀，导致递归深度增加，从而增加了总的计算时间。

举个例子就很容易理解了，假设我们有一个已排序的数组：

[1,2,3,4,5,6,7,8,9,10]

如果我们始终选择最后一个元素作为基准来进行分区，那么在第一次分区时，我们选择 10 作为基准。这会导致数组被分为两部分：

左子数组：[1,2,3,4,5,6,7,8,9] 
右子树组：[10] （位置确定）

可以看到，这种分区是非常不均匀的。左边的部分包含了 9 个元素，而右边的部分只有 1 个元素。接下来，我们继续对左边的部分进行快速排序。再次选择最后一个元素 9 作为基准，数组又被分为：

左子数组：[1,2,3,4,5,6,7,8] 
右子树组：[9] （位置确定）

这个模式会持续下去，每次都选择最后一个元素作为基准，导致每次分区都非常不均匀。由于每次都只能确定一个元素的最终位置（即基准元素），这意味着我们需要进行 n 次递归调用来排序整个数组，其中 n 是数组的长度。这就是为什么递归深度会增加，从而增加了总的计算时间。
在实际的排序过程中，尤其是在处理大数据集时，经常会遇到已经排序的子数组或由相同元素组成的子数组。如果在这种情况下，我们选择中间元素作为基准来进行排序，那么这种选择策略会比选择最后一个元素作为基准的策略有更好的性能。这是因为选择中间元素作为基准更可能使分区均匀，从而减少递归深度和总的计算时间。

下面我们将介绍两种特定的分区方法，那就是 “Lomuto 分区方案” 和 “霍尔（Hoare）分区方案”。

2.1 Lomuto 分区方案

Lomuto 分区方案是快速排序中的一种实现方法，它选择数组的最后一个元素作为基准。在这个方案中，我们使用两个索引 i 和 j 来遍历数组。索引 i 之前的元素都小于基准，而索引 i 到 j 的元素都大于或等于基准。这种方案相对简洁，容易理解，因此经常用于初学者的教材中。

TIP：请记住上面提到的注意点，那就是当数组已经排序或所有元素都相等时，这种方案的性能会下降，时间复杂度可能达到 O(n^2)。

下面是该方案的 Java 实现：

/**
 * 快速排序（Lomuto 分区方案）
 */
public class QuickSortLomuto {

    /**
     * 分区函数，确定基准点的最终位置（索引）
     * @param arr 待分区数组
     * @param low 当前分区下届
     * @param high 当前分区上届
     * @return 基准点的位置（索引）
     */
    private static int partition(int[] arr,int low,int high){
        // Lomuto 分区方案：选择最右边的元素作为基准点
        int pivot = arr[high];

        // 临时的基准索引 i：用于指向当前小于基准点的元素的位置（循环中，第一步是先自增，然后再使用，所以初值要减 1，从而使得第一次循环时 i 指向的是数组的第一个元素，也就是 j 指向的元素）
        int i = low - 1;
        
        // 小于基准点元素的索引 j：用于遍历数组，找出小于基准点的元素
        for (int j = low; j < high; j++) {
            // 在 j 指针向右移动的过程中，如果遇到小于基准点的元素
            if(arr[j] <= pivot){
                // 由于临时的基准索引 i 初始值为 low - 1，所以需要先自增，使其指向第一个元素（也就是 j 指向的元素）再进行交换
                i++;
                // 交换 i 指针（现在指向的是大于基准点的元素）和 j 指针（现在指向的是小于基准点的元素）指向的元素
                // 交换后，i 指针指向的是小于基准点的元素，j 指针指向的是大于基准点的元素
                swap(arr,i,j);
            }
        }

        // 将临时基准元素索引 i 移动到正确的位置（在较小和较大元素的中间）
        i++;
        // 交换 i 指针（现在指向的是大于基准点的元素）和 high 指针（现在指向的是基准点）指向的元素
        swap(arr,i,high);

        // 返回基准点最终的位置（索引）
        return i;
    }

    /**
     * 交换数组中的两个元素
     * @param arr 数组
     * @param i 临时的基准索引
     * @param j 遍历找到的小于基准点的元素的索引位置
     */
    private static void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    /**
     * 快速排序
     * @param arr 待排序数组
     * @param low 数组下届
     * @param high 数组上届
     */
    public static void quickSort(int[] arr,int low,int high){
        // 递归终止条件(元素个数小于等于 1 个时，无需排序)
        if(low >= high){
            return;
        }

        // 分区，确定基准点的位置
        int pivot = partition(arr,low,high);

        // 递归调用，对左子数组进行快速排序
        quickSort(arr,low,pivot - 1);

        // 递归调用，对右子数组进行快速排序
        quickSort(arr,pivot + 1,high);
    }

    public static void main(String[] args) {
        int[] arr = {3,7,8,5,2,1,9,5,4};
        quickSort(arr,0,arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
}

为了更好的理解上述代码的排序过程，结合下图进行再次理解：
快速排序.png

2.2 Hoare 分区方案

Tony Hoare （霍尔）提出的原始快速排序分区方案是一种巧妙的方法，它使用两个指针来分区数组。

  1. 如何移动：这两个指针分别从数组的两端开始，并逐渐向彼此靠近。
  2. 目的何在：它们的任务是找到一个逆序对，即左侧的元素大于基准值，而右侧的元素小于基准值。
  3. 如何处理：当找到这样的逆序对时，如果左侧指针仍然在右侧指针的左边，这两个元素就会被交换，因为它们相对于彼此是错序的。
  4. 后续过程：然后，这两个指针会继续向中间移动，重复这个过程，直到它们交叉为止。
  5. 如何结束：当指针交叉时，分区完成，交叉点就是分区的界限。

下面是使用霍尔分区方案的快速排序的动画演示图，红色轮廓显示左侧和右侧指针的位置（分别为 i 和 j），黑色轮廓显示排序元素的位置，填充的黑色方块显示正在与之比较的值（基准）。


但是，有一个问题需要注意。有时，这种分区方法可能会导致一个子范围包含整个原始范围，这意味着算法没有实际上进行分区。为了解决这个问题，Hoare 提出了一个修正：在分区完成后，我们可以通过移除基准元素来缩小包含基准元素的子范围的大小。如果需要，我们还可以将基准元素与分隔点附近的元素交换，以确保快速排序能够正常终止。

假设我们有以下数组，我们要对其进行快速排序：

A = [8（i）, 7, 6, 5（pivot）, 4, 3, 2, 1（j）]

假设我们选择中间的元素 5 作为基准。现在，我们使用 Hoare 的方法，从两端开始，寻找逆序对。

  • 从左侧开始，我们找到第一个大于 5 的元素是 8
  • 从右侧开始，我们找到第一个小于 5 的元素是 1

我们交换这两个元素，得到：

A = [1（i）, 7, 6, 5（pivot）, 4, 3, 2, 8（j）]

继续这个过程，左指针会移动到 7，右指针会移动到 2，满足逆序对条件，然后交换它们：

A = [1, 2（i）, 6, 5（pivot）, 4, 3, 7（j）, 8]

再次继续，左指针会移动到 6，右指针会移动到 3，满足逆序对条件，然后交换它们：

A = [1, 2, 3（i）, 5（pivot）, 4, 6（j）, 7, 8]

再次继续，左指针会移动到 5，右指针会移动到 4，满足逆序对条件，然后交换它们：

A = [1, 2, 3, 4（i）, 5（j）, 6, 7, 8]

最后左指针继续向右移动，左指针和右指针最终交叉在 5 的位置（找到分区的界限）：

A = [1, 2, 3, 4, 5（i，j）, 6, 7, 8]

但是，你会注意到，除了 5 和 6, 7, 8 之外，所有的元素都小于 5。这意味着，如果我们继续这个算法（又重新对整个数组从左右两端开始），左侧的子范围 [1, 2, 3, 4] 会包含整个原始范围根本不会被交换（除了 6, 7, 8），这实际上并没有进行有效的分区。

为了解决这个问题，Hoare 提出了一个修正：在分区完成后，我们可以移除基准元素5，这样左侧的子范围就不再包括它。这意味着，在下一次递归调用时，我们只需要对 [1, 2, 3, 4] 这个子范围进行排序，而不是整个数组。

此外，虽然 Hoare 的原始描述是非常直观的，但在实际实现时，开发者通常会进行一些小的调整以提高效率。例如，为了简化实现，我们可以考虑将等于基准的元素也包括在逆序对的检测中。这样，我们就可以使用 “大于或等于” 和 “小于或等于” 的条件，而不是简单的 “大于” 和 “小于”。这种调整虽然看起来是微不足道的，但它实际上可以简化代码，并确保指针不会超出数组的范围。
最后，为了确保分区总是有效的，我们需要确保选择的基准元素不是范围内的最后一个元素。这是因为，如果基准是最后一个元素，并且所有其他元素都小于它，那么分区将不会前进。为了避免这种情况，我们可以通过选择范围中间的元素作为基准来进行调整。

下面是该方案的 Java 实现：

/**
 * 快速排序（Hoare 分区方案）
 */
public class QuickSortHoare {

    /**
     * 分区函数，确定基准点的最终位置（索引）
     * @param arr 待分区数组
     * @param low 当前分区下届
     * @param high 当前分区上届
     * @return 基准点的位置（索引）
     */
    private static int partition(int[] arr,int low,int high){

        // Hoare 分区方案：选择中间的元素作为基准点
        int pivot = arr[low + (high - low) / 2];

        // 初始化左右指针
        int i = low - 1;    // 左指针：寻找大于基准点的元素
        int j = high + 1;   // 右指针：寻找小于基准点的元素

        // 无限循环，直到左右指针相遇（找到分区点）
        while (true){
            // 将左指针向右移动，直到找到大于或等于基准点的元素
            do{
                i++;
            }while (arr[i] < pivot);

            // 将右指针向左移动，直到找到小于或等于基准点的元素
            do {
                j--;
            }while (arr[j] > pivot);

            // 如果左右指针相遇，说明找到了分区点，退出循环
            if(i >= j){
                // 分区点选择 j 的原因
                return j;
            }

            // 找到符合逆序对条件的元素，交换两个元素的位置
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }

    /**
     * 快速排序
     * @param arr 待排序数组
     * @param low 当前分区下届
     * @param high 当前分区上届
     */
    public static void quickSort(int[] arr,int low,int high){
        // 确保索引在有效范围内
        if (low >= 0 && high < arr.length && low < high){
            // 分区操作，将数组分为两个分区，返回分区点的位置（索引）
            int pivot = partition(arr,low,high);

            // 对左分区进行快速排序
            quickSort(arr,low,pivot);

            // 对右分区进行快速排序
            quickSort(arr,pivot + 1,high);
        }
    }

    public static void main(String[] args) {
        int[] arr = {6,5,3,1,8,7,2,4};
        quickSort(arr,0,arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
}

对于上面的代码实现有两个注意点单独解释一下。

  1. 为什么使用 low + (high - low) / 2 而不是 (low + high) / 2 来计算中间值？

这是为了防止整数溢出。当你有两个非常大的整数（接近 Integer.MAX_VALUE）时，它们的和可能会超过整数的最大值，导致溢出。这种溢出可能会导致计算出的中间值是一个负数或者其他不正确的值。

举个例子，假设 low = Integer.MAX_VALUE - 1 和 hi = Integer.MAX_VALUE，那么 (lo + hi) 就会溢出。但是，使用 low + (high - lo) / 2 就不会有这个问题，因为 high - low 的结果是一个较小的正数，除以 2 后再加上 low 仍然是一个合法的整数。

所以，为了确保代码的健壮性，特别是在处理大数据集时，我们通常使用 low + (high - low) / 2 = low + high/2 - low/2 = low/2 + high/2 = (low + hign)/2 来计算中间值。

  1. 为什么在指针相遇时选择 return j 作为分区点而不是 return i？

在霍尔分区方案中，我们的目标是找到一个位置 j，使得在这个位置左边的所有元素都小于或等于基准，而右边的所有元素都大于或等于基准。

在循环中，i 指针从左向右移动，直到找到一个大于或等于基准的元素，而 j 指针从右向左移动，直到找到一个小于或等于基准的元素。当 i 和 j 指针交叉时，我们知道 j 指针的左边都是小于或等于基准的元素，而 i 指针的右边都是大于或等于基准的元素。

因此，当指针交叉时，j 是最后一个小于或等于基准的元素的位置，这正是我们想要的分区点。而 i 是第一个大于或等于基准的元素的位置，所以它不是一个合适的分区点。

选择 j 作为分区点可以确保左子数组的所有元素都小于或等于基准，而右子数组的所有元素都大于或等于基准，这是快速排序算法的核心思想。

为了更好的理解上述代码的排序过程，我将待排序的数组设置得与下述动图一致，可以结合下图进行再次理解：
Quicksort-example.gif

TIP：红色轮廓显示左侧和右侧指针的位置（分别为 i 和 j），黑色轮廓显示排序元素的位置，填充的黑色方块显示正在与之比较的值（基准）。

一开始的待排数组：
image.png
确定基准点元素 3 和左右两端指针的位置：
image.png
左边 i 指向的元素 6 已经大于基准点 3 保持不动，右边 j 向左移动找到小于基准点的元素 2:
image.png
交换 i ，j 指针元素：
image.png
指针继续移动找到下一组逆序对：
image.png
交换 i ，j 指针元素：
image.png
两个指针继续相向移动，找到分区点：
image.png
此时 i 指针指针的右边都是大于或等于基准的元素，j 指针的左边都是小于或等于基准的元素。j 是最后一个小于或等于（=）基准的元素的位置，这正是我们想要的分区点。而 i 是第一个大于或等于（=）基准的元素的位置，所以它不是一个合适的分区点。最终选择 j 处索引，确定改点为基准元素最终的位置：
image.png
左子分区开始递归排序，确定基准点为 1 和左右两端指针的位置，此时位置刚好符合逆序对条件：
image.png
直接交换 i ，j 指针元素：
image.png
两个指针继续相向移动，找到分区点 1，确定为最终基准元素位置：
image.png
现在只有右子分区，元素个数为 1，不满足索引范围检查条件，不需要排序，直接确定基准元素 2 的位置：
image.png
… 省略右子分区排序过程。

2.3 Hoare vs Lomuto

通过上面的了解，我们知道快速排序是一种经典的排序算法，其中一个关键步骤是如何分区数组。有两种流行的分区策略：Hoare 和 Lomuto。这两种策略有各自的优缺点，但从效率上讲，Hoare 的方案通常更胜一筹。

  1. 效率对比：
    • Hoare 分区方案：平均情况下，Hoare 的分区策略只需要 Lomuto 方案的三分之一的交换次数，这使得它在实际应用中更为高效。
    • Lomuto 方案：尽管它的实现可能更为直观和简单，但它在某些情况下，特别是当所有值都相等时，可能不会产生平衡的分区。
  2. 对于已排序的输入：
    • 如果选择第一个或最后一个元素作为基准，无论是使用 Hoare 还是 Lomuto 的分区策略，快速排序的性能都会降低到 O(n^2)。
    • 但是，如果选择中间元素作为基准，Hoare 的方案在已排序的数据上几乎不需要交换操作，并且可以产生大小近似相等的分区。这导致了快速排序的最佳情况性能，即 O(n log(n))。
  3. 稳定性：
    • 无论是 Hoare 还是 Lomuto 的分区策略，快速排序都不是稳定的。这意味着相等的元素可能会改变它们的相对顺序。
  4. 基准的最终位置：
    • 在 Hoare 的分区策略中，基准的最终位置并不一定是返回的索引。这是因为在分区步骤之后，基准和等于基准的元素可能会出现在分区的任何位置，并且可能在递归达到单个元素的基本情况时才会排序。

结论：尽管 Lomuto 的分区策略在某些教学场景中可能更易于理解，但 Hoare 的分区策略在实际应用中通常更为高效。

3.避免可能的不稳定性

上面也说过了，无论是 Hoare 还是 Lomuto 的分区策略，快速排序都不是稳定的。因为原始数据中相等的元素在排序后可能会改变它们的相对顺序。为了避免这个问题，我们可以在进行元素交换时判断被交换的两个元素是否相等，如果相等则放弃本次交换即可。

以 Lomuto 分区方案为例，优化后的代码如下：

/**
 * 快速排序（Lomuto 分区方案）
 */
public class QuickSortLomuto {

    /**
     * 分区函数，确定基准点的最终位置（索引）
     * @param arr 待分区数组
     * @param low 当前分区下届
     * @param high 当前分区上届
     * @return 基准点的位置（索引）
     */
    private static int partition(int[] arr,int low,int high){
        // Lomuto 分区方案：选择最右边的元素作为基准点
        int pivot = arr[high];

        // 临时的基准索引 i：用于指向当前小于基准点的元素的位置（循环中，第一步是先自增，然后再使用，所以初值要减 1，从而使得第一次循环时 i 指向的是数组的第一个元素，也就是 j 指向的元素）
        int i = low - 1;
        
        // 小于基准点元素的索引 j：用于遍历数组，找出小于基准点的元素
        for (int j = low; j < high; j++) {
            // 在 j 指针向右移动的过程中，如果遇到小于基准点的元素
            if(arr[j] <= pivot){
                // 由于临时的基准索引 i 初始值为 low - 1，所以需要先自增，使其指向第一个元素（也就是 j 指向的元素）再进行交换
                i++;
                // 交换 i 指针（现在指向的是大于基准点的元素）和 j 指针（现在指向的是小于基准点的元素）指向的元素
                // 交换后，i 指针指向的是小于基准点的元素，j 指针指向的是大于基准点的元素
                if(arr[i] != arr[j]){
                    swap(arr,i,j);
                }
            }
        }

        // 将基准元素索引 i 移动到正确的位置（在较小和较大元素的中间）
        i++;
        // 交换 i 指针（现在指向的是大于基准点的元素）和 high 指针（现在指向的是基准点）指向的元素
        if(arr[i] != arr[high]){
            swap(arr,i,high);
        }

        // 返回基准点最终的位置（索引）
        return i;
    }

    /**
     * 交换数组中的两个元素
     * @param arr 数组
     * @param i 临时的基准索引
     * @param j 遍历找到的小于基准点的元素的索引位置
     */
    private static void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    /**
     * 快速排序
     * @param arr 待排序数组
     * @param low 数组下届
     * @param high 数组上届
     */
    public static void quickSort(int[] arr,int low,int high){
        // 递归终止条件(元素个数小于等于 1 个时，无需排序)
        if(low >= high){
            return;
        }

        // 分区，确定基准点的位置
        int pivot = partition(arr,low,high);

        // 递归调用，对左子数组进行快速排序
        quickSort(arr,low,pivot - 1);

        // 递归调用，对右子数组进行快速排序
        quickSort(arr,pivot + 1,high);
    }

    public static void main(String[] args) {
        int[] arr = {3,7,8,5,2,1,9,5,4};
        quickSort(arr,0,arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
}

4.小礼物

在某些时候，不管是学习数据结构还是算法的相关知识，难免会觉得有些抽象，这时如果有一个工具能够让抽象的概念变得具体，那可就太棒了。下面推荐一个网站就可以满足你的需求：

地址：Data Structure Visualization

该网站中汇集了大部分常见的数据结构与算法的动图展示和单步调试，利用好可以帮助你更好的理解对应的知识点。

例如常见数据结构：
image.png
再比如我们上面所说的快速排序：
image.png
OK，本次分享到此，如果感觉对你有所帮助记得一键三连哦！！！

参考资料：

clutch.
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
算法实验1-快速排序
12-07
常见的划分策略有“Lomuto分区”和“Hoare分区”。 3. **递归排序**： 对左右两个子数组分别进行快速排序，直到所有元素都是有序的。这是快速排序的核心，也是它能实现高效的关键。 4. **随机快速排序**： 在...
全网最全的快速排序方法--Hoare快排 挖坑法快排 二路快排 三路快排 非递归快排
qq_64580912的博客
04-18 2225
快速排序（Quicksort）由英国计算机科学家Tony Hoare于1959年发明，是一种经典的排序算法，被广泛应用于计算机科学领域。快速排序（Quick Sort）是一种常见的基于比较的排序算法，也是最常用的排序算法之一。快速排序是一种稳定性:如果a原本在b前面，并且a=b,排序之后a仍然在b的前面,那么就成这个算法是稳定的,否则就是不稳定的;以下是快速排序的基本思路选择一个基准元素（pivot）。将序列中所有小于基准元素的元素放在基准元素的左侧，所有大于基准元素的元素放在右侧。递归地对基准元素左侧和右
快速排序（QuickSort）方法的历史、代码、测试，以及Hoare-Partition和Lomuto-Partition的区别（还有很多其他快速排序算法）
ZhongUncle的博客
10-04 1767
在学习快速排序的时候，发现很多人说的快速排序方法不一样（比如教材和网上说到的快速排序过程不一样），很好奇是为什么，而且开发、考试等很多场景都需要用到。就去翻阅了一下《算法导论》想搞明白，发现这种情况的原因和快速排序的发展史有关。于是就查阅了很多资料，来写下本文作为记录。
快速排序详解
qq_36387933的博客
04-24 582
快速排序，又称分区交换排序 （partition-exchange ），简称快排。 算法 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为较小和较大的2个子序列，然后递归地排序两个子序列。 步骤为： 挑选基准值：从数列中挑出一个元素，称为“基准”（pivot）， 分割：重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（与...
快排中的Partition函数
东明山庄
10-01 3672
快排的递归形式 快排算法的程序结构： def quicksort(nums, l, r): if l >= r: return k = partition(nums, l, r) quicksort(nums, l, k - 1) quicksort(nums, k + 1, r) 其中partition函数输入参数是一个数组nums和两个位...
快速排序之partition分区问题版本、netherlandsFlag荷兰国旗问题版本，三次改进以及一个常规快排版本！
Firelearn的博客
04-20 480
今天分享的是关于快速排序的思路以及三种版本的迭代优化 我们先来介绍partition问题 多图预警！！ 所有的算法都经过对数器核对，可以放心使用 已知一个数组arr，要求我们以随机的一个数作为标准把数组分为以下两个区域，小于等于区、大于区，可以不用考虑各区数字的排序 下例我们假设这个数为4 我们设置一个小于等于区（下称≤区），它的起始位置是-1；再设置一个变量index，它指向的是第一个数 然后我们从左往右遍历，当index 大于 arr.length-1 时跳出循环，有以下两种情况
快速排序的三种分区方法（整理）
月巴虫丰博客
01-13 2946
① 单向扫描 ② 双向扫描 ③ 三分法
常用排序算法整理分享(快速排序算法、希尔排序)
09-04
快速排序的实现采用了经典的“Lomuto分区方案”，其中选择数组的第一个元素作为基准，通过两个指针从两端逐步逼近，找到基准值的正确位置，然后进行交换。快速排序的效率高是因为在大多数实际应用中，它可以达到接近...
快速排序算法演示(PPT).rar
11-27
在快速排序的过程中，我们通常采用“Lomuto分区”或“Hoare分区”策略。Lomuto分区法更适合初学者理解，它将数组分为小于和大于基准的两部分，而Hoare分区法则更为高效，但实现起来相对复杂。在这个PPT中，可能讲解...
快速排序算法的副本.zip
10-23
快速排序有两种常见的实现方式：**Lomuto分区** 和 **Hoare分区**。 - **Lomuto分区** 方法：选取最后一个元素为基准，从第一个元素开始遍历，遇到比基准小的元素则与其交换，最后将基准放到遍历结束的位置。这种...
快速排序算法在Swift编程中的几种代码实现示例
09-02
快速排序是一种高效的排序算法，由C.A.R. Hoare在1960年提出。它的主要思想是通过分治策略实现，将一个大问题分解成若干个小问题来解决。在快速排序中，选择一个基准值，然后将数组分为两部分：一部分包含所有小于...
快速排序partition过程常见的两种写法+快速排序非递归实现
weixin_34290000的博客
04-14 237
这里不详细说明快速排序的原理，具体可参考here 快速排序主要是partition的过程，partition最常用有以下两种写法 第一种： int mypartition(vector<int>&arr, int low, int high) { int pivot = arr[low];//选第一个元素作为枢纽元 while(low &lt...
快速排序Partition的写法
tao_bear的博客
10-18 2252
快速排序的重点在于Partition的写法，Partition主要有两种写法：从头前进法，首尾夹逼法。 Partition写法一 首先需要做出求解问题的区间，为此，指定 pivot = nums[left]，并定义两个变量 i, j [left+1, j] 区间所在元素都小于pivot (j, i]区间所在元素都大于pivot 初始化 i 和 j 都是left，可以写出如下代码： int partition(int *nums, int left, int right) { .
快速排序 两种partition实现
diaoyang7352的博客
04-02 228
标签： 算法基础 1. 算法简介 　　快速排序，正如其名字一样，是排序算法中速度较快的一种排序，算法复杂度为\(O(n*logn)\)。 　　排序过程中会打乱元素的相对位置，是不稳定排序。 　　算法思想：选定一个pivot，把元素分为两组，一组比pivot小，一组比pivot大，然后按照相同的方法处理这两组元素，是一个递归的过程。 　　算法核心是partition方法，即把元素分开两组...
快速排序里面的Partition函数
luoshasha1216的博客
12-28 1478
Partition函数有两种实现方法，单边扫描和双边扫描 Partition函数的作用就是在数组中选择一个数字，接下来把数组的数字分成两个部分，比选择的数字小的移动到数组的左边，比选择的数字大的移动到数组的右边。 单边扫描：首先随机选择一个数字，与数组最后一个元素进行交换，变量i从左到右进行扫描，每一个数都与最后一个元素进行比较，如果比最后一个元素小，扫描变量i的元素与标记变量small的元素
快速排序算法
u014248032的博客
12-04 202
快速排序 快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 步骤为： 从数列中挑出一个元素，称为"基准"（pivot）， 重新排序数列...
快速排序partition写法（一道力扣题目引出的Lomuto和Hoare的partition方法区别）
LifeGoesOn
08-03 1390
做力扣的一道题目： 169 多数元素 的时候，用到了快速排序，所以复习了一下快排。 一、快排 快排思想就是： 选定一个哨兵元素pivot； 把小于pivot的元素放在pivot左边，大于pivot的放在右边，这样，划分完后pivot就在自己最终应该在的位置了； 对于pivot位置的左边和右边，递归进行 1、2 的过程。 其中，quickSort就是主方法，是分支递归的过程，2的步骤就是核心的partition方法，他进行划分，使得每一轮用 O(n) 的时间确定了一个元素的位置。 因此快速排序的渐近时间复
面试笔试中最最最常考到的算法——快速排序（Partition函数）
时间有泪
10-04 1218
忙里偷闲，突然对排序算法产生了兴趣，只会冒泡排序和选择排序这两种本科学到的排序方法的我，来探索一波新世界！希望从此告别O(n²)。 文章目录1、原理2、实现划分分治递归终止条件3、复杂度分析时间复杂度空间复杂度4、代码 1、原理 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小。然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，...
快速排序的hoare法
最新发布
07-27
回答: 快速排序的Hoare法是一种常用的快速排序算法实现方法。它是由Tony Hoare在1960年提出的。Hoare法的基本思想是选择一个基准值，将待排序序列分成两部分，一部分是小于基准值的元素，另一部分是大于基准值的元素。然后对这两部分分别进行递归排序，最终将整个序列排序完成。具体实现过程如下： 1. 选择一个基准值，可以是序列中的任意一个元素。 2. 定义两个指针，一个指向序列的起始位置，一个指向序列的末尾位置。 3. 移动左指针，直到找到一个大于等于基准值的元素。 4. 移动右指针，直到找到一个小于等于基准值的元素。 5. 如果左指针小于等于右指针，则交换左右指针所指向的元素。 6. 继续移动左右指针，直到左指针大于右指针。 7. 将基准值与右指针所指向的元素交换。 8. 分别对基准值左边和右边的子序列进行递归排序。 通过以上步骤，每一次递归都会将基准值放置在正确的位置上，最终完成整个序列的排序。\[1\]\[2\]\[3\] #### 引用[.reference_title] - *1* *2* [【八大排序③】快速排序（动图演绎Hoare法、挖坑法、前后指针法）](https://blog.csdn.net/Living_Amethyst/article/details/125513838)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [快速排序常见3种方法(hoare、挖坑法、前后指针法)以及改进。](https://blog.csdn.net/tjh1998/article/details/122159488)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

clutch.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值