【算法系列】快速排序详解

已于 2025-02-26 17:36:46 修改
阅读量1.3k 收藏 25
点赞数 30
文章标签： 算法 python 排序算法
于 2025-02-25 19:37:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/binbinxyz/article/details/145859507
版权

文章目录

快速排序的多种实现方式

快速排序（Quick Sort）是一种高效的排序算法，采用分治法策略。它通过选择一个“基准”元素，将数组分割成两个子数组，并递归地对这两个子数组进行排序。本文将详细介绍几种常见的快速排序实现方式，并讨论它们的特点和适用场景。
在这里插入图片描述

1. 基本快速排序（Lomuto 分区方案）

1.1 基本原理

Lomuto 分区方案是最常见的快速排序实现之一。它选择数组的最后一个元素作为基准（pivot），然后重新排列数组，使得所有小于基准的元素位于基准的左侧，所有大于基准的元素位于基准的右侧。

1.2 步骤

  1. 选择基准：通常选择数组的最后一个元素作为基准。
  2. 初始化指针：设置一个指针 i，用于追踪当前小于基准的最后一个元素的位置。
  3. 遍历数组：
    • 遍历数组中的每个元素（除了基准元素），如果当前元素小于等于基准，则将该元素与 i 指针所指向的元素交换，并将 i 向右移动一位。
  4. 放置基准：最后将基准元素与 i + 1 位置的元素交换，使得基准元素处于正确的位置。
  5. 递归排序：对基准两侧的子数组分别递归执行上述过程，直到每个子数组只剩下一个元素或为空。

1.3 Java 实现示例

public static void quickSort(int[] arr) {
    quickSort(arr, 0, arr.length - 1);
}

private static void quickSort(int[] arr, int low, int high) {
    if(low >= high) {
        return;
    }
    int pivotIndex = lomuto(arr, low, high);
    quickSort(arr, low, pivotIndex - 1);
    quickSort(arr, pivotIndex + 1, high);
}

private static int lomuto(int[] arr, int low, int high) {
    int pivot = arr[high]; // 选择最后一个元素作为基准
    int i = low - 1; // 指向当前小于基准的最后一个元素

    for (int j = low; j < high; j ++) {
        if(arr[j] <= pivot) {
            i ++;
            if(i != j) {
                swap(arr, i, j);
                System.out.println(low + "|" + high + " " + i + "|" + j + " " + Arrays.toString(arr));
            }
        }
    }

    // 将基准元素放回数组正确位置
    swap(arr, i + 1, high);
    System.out.println(low + "|" + high + "\t \t" + Arrays.toString(arr));
    return i + 1;
}

/**
 * 交换数组索引为i和j的两个元素
 * @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;
}

2. Hoare 分区方案

2.1 基本原理

Hoare 分区方案由 C.A.R. Hoare 提出，是另一种常见的快速排序实现。它通过选择一个基准元素（通常是第一个或最后一个元素），然后重新排列数组，使得所有小于基准的元素位于基准的左侧，所有大于基准的元素位于基准的右侧。

2.2 步骤

  1. 选择基准：通常选择数组的第一个元素作为基准。
  2. 初始化双指针：设置两个指针，分别指向数组的起始位置和结束位置。
  3. 移动指针：
    • 左指针向右移动，直到找到一个大于基准的元素。
    • 右指针向左移动，直到找到一个小于基准的元素。
  4. 交换元素：当左右指针都停止时，交换这两个元素的位置。
  5. 重复步骤3和4：继续移动指针并交换元素，直到左右指针相遇。
  6. 放置基准：最后将基准元素与右指针的位置交换，使得基准元素处于正确的位置。

2.3 Java 实现示例

public static void quickSort(int[] arr) {
    quickSort(arr, 0, arr.length - 1);
}

private static void quickSort(int[] arr, int low, int high) {
    if(low >= high) {
        return;
    }

    int pivotIndex = hoare(arr, low, high);
    quickSort(arr, low, pivotIndex - 1);
    quickSort(arr, pivotIndex + 1, high);
}

private static int hoare(int[] arr, int low, int high) {
    int pivot = arr[low]; // 选择一个元素作为基准
    int l = low; // 左索引
    int r = high; // 右索引
    while(l < r) {
        while(l < r && arr[r] > pivot) {
            r --;
        }
        while(l < r && arr[l] < pivot) {
            l ++;
        }

        if(l < r) {
            swap(arr, l, r);
            System.out.println(l + "|" + r + "\t\t" + Arrays.toString(arr));
        }
    }
    return l;
}

/**
 * 交换数组索引为i和j的两个元素
 * @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;
}

3. 三数取中法

3.1 基本原理

为了减少快速排序在最坏情况下的时间复杂度（即 O(n^2)），可以使用“三数取中法”来选择基准元素。这种方法通过选择数组的第一个、中间和最后一个元素中的中位数作为基准，从而减少最坏情况的发生概率。

3.2 步骤

  1. 选择基准：选择数组的第一个、中间和最后一个元素中的中位数作为基准。
  2. 分区操作：根据选择的基准进行分区操作，可以使用 Lomuto 或 Hoare 分区方案。
  3. 递归排序：对基准两侧的子数组分别递归执行上述过程，直到每个子数组只剩下一个元素或为空。

3.3 Java 实现示例

public static void quickSort(int[] arr) {
    quickSort(arr, 0, arr.length - 1);
}

private static void quickSort(int[] arr, int low, int high) {
    if (low >= high) {
        return;
    }
    int pivotIndex = lomuto(arr, low, high);
    quickSort(arr, low, pivotIndex - 1);
    quickSort(arr, pivotIndex + 1, high);
}

private static int lomuto(int[] arr, int low, int high) {
    int pivotIndex = medianOfThree(arr, low, high); // 使用三数取中法选择基准
    int pivot = arr[pivotIndex];
    int i = low - 1; // 指向当前小于基准的最后一个元素
    if (pivotIndex != high) {
        swap(arr, pivotIndex, high); // 将基准元素移到最后
        System.out.println("pivot:" + pivotIndex + "|" + high + "\t" + Arrays.toString(arr));
    }

    for (int j = low; j < high; j++) {
        if (arr[j] <= pivot) {
            i++;
            if (i != j) {
                swap(arr, i, j);
                System.out.println(low + "|" + high + " \t" + i + "|" + j + "\t" + Arrays.toString(arr));
            }
        }
    }

    // 将基准元素放回数组正确位置
    if (i + 1 != high) {
        swap(arr, i + 1, high);
        System.out.println("back:" + (i + 1) + "|" + high + "\t" + Arrays.toString(arr));
    }
    return i + 1;
}

/**
 * 选择数组的第一个、中间和最后一个元素中的中位数作为基准，返回其下标
 *
 * @param arr
 * @param low
 * @param high
 * @return
 */
private static int medianOfThree(int[] arr, int low, int high) {
    int mid = (low + high) / 2;

    if ((arr[low] <= arr[mid] && arr[mid] <= arr[high]) || (arr[low] >= arr[mid] && arr[mid] >= arr[high])) {
        return mid;
    }
    if ((arr[mid] <= arr[low] && arr[low] <= arr[high]) || (arr[mid] >= arr[low] && arr[low] >= arr[high])) {
        return low;
    }
    return high;
}

/**
 * 交换数组索引为i和j的两个元素
 *
 * @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;
}

4. 尾递归优化

4.1 基本原理

快速排序的递归实现可能导致栈溢出问题，特别是在处理大规模数据集时。为了避免这种情况，可以使用尾递归优化技术来减少递归调用栈的深度。

4.2 步骤

  1. 选择基准：选择数组的某个元素作为基准。
  2. 分区操作：根据选择的基准进行分区操作，可以使用 Lomuto 或 Hoare 分区方案。
  3. 尾递归优化：每次递归只对较小的子数组进行递归调用，较大的子数组则通过循环继续处理，从而减少递归调用栈的深度。

4.3 Java 实现示例

public static void quickSort(int[] arr) {
    quickSort(arr, 0, arr.length - 1);
}

private static void quickSort(int[] arr, int low, int high) {
    // 使用循环代替递归
    while (low < high) {
        int pivotIndex = hoare(arr, low, high);

        // 对较小的分区进行递归调用
        if (pivotIndex - low < high - pivotIndex) {
            quickSort(arr, low, pivotIndex - 1);
            low = pivotIndex + 1;
        } else {
            quickSort(arr, pivotIndex + 1, high);
            high = pivotIndex - 1;
        }
    }
}

private static int hoare(int[] arr, int low, int high) {
    int pivot = arr[low]; // 选择一个元素作为基准
    int l = low; // 左索引
    int r = high; // 右索引
    while (l < r) {
        while (l < r && arr[r] > pivot) {
            r--;
        }
        while (l < r && arr[l] < pivot) {
            l++;
        }

        if (l < r) {
            swap(arr, l, r);
            System.out.println(l + "|" + r + "\t\t" + Arrays.toString(arr));
        }
    }
    return l;
}

/**
 * 交换数组索引为i和j的两个元素
 *
 * @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;
}

总结

快速排序有多种实现方式，每种实现方式在不同的应用场景下可能有不同的性能表现：

  • Lomuto 分区方案：简单易懂，但相比 Hoare 分区方案，在某些情况下可能会有更多的交换操作，导致效率稍低。
  • Hoare 分区方案：通常比 Lomuto 分区更高效，因为它减少了不必要的交换操作，从而减少了时间复杂度。
  • 三数取中法：通过选择数组的第一个、中间和最后一个元素中的中位数作为基准，减少最坏情况的发生概率。
  • 尾递归优化：通过优化递归调用栈的深度，避免栈溢出问题，特别适合处理大规模数据集。
binbinxyz
关注
Python实现的数据结构与算法之快速排序详解
01-21
本文实例讲述了Python实现的数据结构与算法之快速排序。分享给大家供大家参考。具体分析如下： 一、概述 快速排序（quick sort）是一种分治排序算法。该算法首先 选取 一个划分元素（partition element，有时又称为pivot）；接着重排列表将其 划分 为三个部分：left（小于划分元素pivot的部分）、划分元素pivot、right（大于划分元素pivot的部分），此时，划分元素pivot已经在列表的最终位置上；然后分别对left和right两个部分进行 递归排序。 其中，划分元素的 选取 直接影响到快速排序算法的效率，通常选择列表的第一个元素或者中间元素或者最后一个元
详解Java常用排序算法-快速排序
08-26
快速排序算法详解 快速排序（Quick Sort）是一种分治思想的排序算法，它的基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，然后再分别对这两部分记录继续...
快速排序~~
Whisper_year的博客
12-19 265
快速排序的介绍： 快速排序（Quicksort）是对冒泡排序的一种改进。 它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 快速排序的原理： 1、从数列中挑出一个元素，称为 “基准”（pivot）； ​ 2、重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之
[特殊字符]算法详解——快速排序：分治思想的完美演绎，从原理到实战全解析！
最新发布
WD1213484的博客
04-01 1144
快速排序是一种高效的排序算法，通过分治思想和双指针技巧实现平均 O (n log n) 的时间复杂度。掌握其核心原理和优化策略，能够在实际开发中应对各种排序需求。你在哪些场景用过快速排序？欢迎在评论区交流！👇# 排序算法 #快速排序 #JavaScript #算法可视化。
排序——快速排序
ClearRiver 's Style
08-02 829
之前总以为自己已经掌握了快速排序，可是眼高手低，没有好好研究一下它是否是稳定的排序，以及涉及重复元素等问题，最近用到时总是出现小的bug，于是又潜心翻看《算法导论》，经过测试，写出一个正确的快速排序算法。写正确关键在于paration函数：(1)如果s(2)如果i+1m(3)如果k=e,则有a[k]=x变量s和e分别表示数组a的起始和结尾元素，i用于跟踪j，直到遇到>中枢元素m
快速排序详解
weixin_33906657的博客
10-18 121
package com.sort;/** * 2010-10-18 * 快速排序 * 1。取中值 * 2。按照中值将数组进行分组（不是分的越细越好） * 3。将分组后的数据再进行分组......... */public class QuickSort {public void sort(int[] arr,int leftIndex,int rightIndex){...
快速排序法
gcs的博客
03-13 4410
今天介绍快速排序，这也是在实际中最常用的一种排序算法，速度快，效率高。就像名字一样，快速排序是最优秀的一种排序算法。 思想 快速排序采用的思想是分治思想。 快速排序是找出一个元素（理论上可以随便找一个）作为基准(pivot),然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值，如此作为基准的元素调整到排序后的正确位置。递归快速排序，将其他n
详解快速排序
井井酒的博客
05-10 485
文章目录前言快速排序原理代码实现复杂度分析总结 前言 快速排序是一种不稳定的、**时间复杂度为O(nlogn)**的排序算法，算是较快的算法。 类似于归并排序，主要思想是分治，不同的是快排自顶向下(类似于二叉树的前序遍历)，归并排序自底向上（类似于二叉树的后序遍历）。 时间复杂度： 平均：O(nlogn)O(nlogn)O(nlogn) 最坏：O(n2)O(n^2)O(n2) 最好：O(nlogn)O(nlogn)O(nlogn) 空间复杂度： 平均：O(logn)O(logn)O(logn) 最坏：O(
快速排序的详解
Patrick的博客
03-31 722
下面时快速排序的过程： 把图看懂，下面程序打一遍你就会如何编写快速排序了 #include&lt;iostream&gt; #include&lt;stdio.h&gt; using namespace std; int a[101],n; void quicksort(int left,int right){ int i,j,temp,t; if(left&gt;ri...
快速排序 详解
肖氏专栏
05-17 1213
快速排序算法是一种分治排序算法，它将数组划分为两部分，然后分别对这两部分进行排序。它将重排序数组，使之满足一下三个条件： 1，对于某个i，a[i]在最终的位置上 2，a[l]…a[i-1]中的元素都比a[i]小 3，a[i+1] …a[r]中的元素都比a[i]大 通过划分后完成本轮排序，然后递归地处理子文件。 如果数组中有一个或者0个元素，就什么都不做。否则，调用以下算法实现快速排序：
JavaScript算法系列之快速排序（Quicksort）算法实例详解
11-23
快速排序是一种高效的排序算法，由英国计算机科学家C.A.R. Hoare在1960年提出。其主要思想是分治策略，通过选取一个基准值，将待排序的数据分为两部分，一部分的所有元素都小于基准，另一部分的所有元素都大于基准，...
高效排序算法：快速排序Java与Python实现详解
12-23
内容概要：文章详述了快速排序算法的基本概念、分治策略以及具体实现方式，提供Java和Python两个版本的代码样例。快速排序算法能够将一个序列分解成较小和较大的两部分，并通过递归的方式分别对这两部分进行排序，...
Python实现的快速排序算法详解
09-21
快速排序是一种高效的排序算法，由英国计算机科学家C.A.R. Hoare在1960年提出。它的核心思想是分治策略，通过一趟排序将待排序的数据分成两个部分，一部分的所有元素都比另一部分的所有元素小，然后对这两部分再分别...
用C语言实现lomuto划分算法
10-22
Lomuto分区算法是一种用于快速排序的简单直观的实现方法。它并不直接涉及数组的划分，而是作为快速排序的核心部分，在每一轮递归过程中完成元素的移动。以下是Lomuto划分的基本步骤： 1. **选择基准** (pivot): 通常选择待排序数组的第一个元素作为基准。 2. **设置两个指针** (indices): 分别从数组的起始位置i和结束位置j开始。 3. **分区过程**: - 当i小于等于j时: a. 如果当前指针i指向的元素大于或等于基准，则将i向右移动一位，并将比基准大的元素放在新位置上。 b. 否则，将i向右移动一位，继续比较。 4. **交换元素**: 当i > j时，说明已经找到了所有小于基准的元素的边界，这时将基准值与i+1位置的元素交换，使得基准值处于正确的位置。 5. **递归处理**: 对基准左边的子数组（索引范围[0, i]）和右边的子数组（索引范围[i+1, n]）分别进行同样的操作，直到整个序列有序。 下面是Lomuto划分的一个简化版的C语言实现示例： ```c #include <stdio.h> void swap(int* a, int* b) { int temp = *a; *a = *b; *b = temp; } int partition(int arr[], int low, int high) { int pivot = arr[low]; // 选择第一个元素作为基准 int i = low + 1; for (int j = low + 1; j <= high; j++) { if (arr[j] <= pivot) { i++; swap(&arr[i], &arr[j]); } } swap(&arr[low], &arr[i]); // 将基准放到正确的位置 return i; } void quicksort(int arr[], int low, int high) { if (low < high) { int pi = partition(arr, low, high); quicksort(arr, low, pi - 1); quicksort(arr, pi + 1, high); } } // 示例 int main() { int arr[] = {9, 7, 5, 11, 12, 2, 14, 3}; int n = sizeof(arr) / sizeof(arr[0]); quicksort(arr, 0, n - 1); printf("Sorted array: "); for (int i = 0; i < n; i++) printf("%d ", arr[i]); return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值