快速排序-两种分割方法比较(Hoare’s vs. Lomuto)

于 2023-03-12 11:15:46 发布
阅读量906 收藏 6
点赞数
文章标签： 算法 排序算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jasonchen1224/article/details/129473464
版权

快速排序-两种分割方法比较(Hoare’s vs. Lomuto)

  1. 前言

快速排序是一种有效的排序方法，它可以很好平衡时间复杂度，获取不错的排序效果。快速排序从本质上理解，它和冒泡法一样，属于比较排序方法的范畴，冒泡方法中，每次只能相邻两个数据比较，快速排序每次把比较范围扩大到两个维度，从同一侧分为两个队列进行比较(Lomuto)或者从两侧向中间进行合围。快速排序类似双向冒泡，其中一个队列网上冒泡，另外要给队列向下冒泡，这样就显著提升了比较效率，减少循环比较次数。

  1. 快速排序回顾

快速排序采用递归的分治方法，首先找到一个支点数据，对数组中的所有数据进行归类，小于等于支点数据的对象放置到左侧，大于支点的数据对象放置到右侧，一直循环到单个数据对象位置。其主题实现代码，非常简洁。

void quick_sort(int *a, int p, int r)
{
    int q;

    if(p<r) //It should define the exit entry of recursive
    {
        // Partition the subarray around the pivot, which ends up in A[q].
        q = partition(a, p, r);
        quick_sort(a, p, q - 1); // recursively sort the low side
        quick_sort(a, q + 1, r); // recursively sort the high side
    }
}

如果采用《算法导论》的递归分析流程，分为三个阶段，我们分别对其进行相关的分析

  • 分割(Divide), 过程中，需要把数组分割为两个子数组。整体的数组表示为a[p,r]，以支点为分界点，整体需要分割为两个子数组，分别表示为a[p,q-1], a[q+1,r]两个数组。a[p,q-1]为低端侧的数组，数组里面的所有的值，均小于或等于支点a[q]; a[q+1,r]为高端侧的数组，数组里面所有的元素值均大于a[q]。
  • 治理(Conquer)，值得一提的是，两个子数组此时可能处于无序状态，需要继续分割，直至至单个元素出现。这个过程中，我们需要对子数组递归调用子数组，直至最终的结果出现。
  • 组合(Combine)，由于各个子数组已经有序，所以不需要进行特别的组合和动作，递归后返回的结果自然满足要求
  1. 分割函数分析

快速排序算法的关键函数是分割函数 (partition function)，它肩负着分割数组以及返回支点下标的功能，这个函数的性能对整体快速排序算法至关重要。一般情况下，分割函数的实现分为两大类，

  • 一类是Lomuto算法，它以最后一个元素为支点，从左边开始对数组进行分割，整个分割过程中，支点位置保持不变，分割完成后，对支点和i+1的值进行交换
  • 一类是Hoare算法，它从双侧(i侧和j侧_开始进行比较，过程中分割点的位置会不停的变化，直至i=j，结束迭代运算

首先从Lomuto算法开始，Lomuto算法过程演示图，

在这里插入图片描述

(a) 表示原始数组，为了便于理解，把i,j当作指针理解，迭代之前，指针i指向p-1；指针j指向p；这个设计非常巧妙，确保i指针和j指针形成有重叠的两个区域，扩展成“你追我赶”的最终局面

(b) 由于a[j]<=a[r](a[0]<a[7]), 我们对a[0]和a[0]进行首次交换，同时指针i和指针j各自往前移动一步

© 由于a[j]>=a[r](a[2]>a[7])，我们不做任何交换，保留i指针在原为，同时j指针往前移动一步，中间过程遵循相同逻辑

…

(h)此时可以看到整个数组已经由四个区(低侧，高侧，未排序，支点)减少到三个区(底侧，高侧，支点)，这时候未排序区域消失

(i) 交换a[i+1]和a[r]，分割完成，并返回i+1作为支点的下标

过程中的两类操作，(a)类操作，当a[j]>a[r],i指针保持不动，j指针增加1，没有交换发生；(b)类操作a[j]<=a[r],需要交换数据，完成后i和j指针都往前移动1位(增加1)

在这里插入图片描述

接着我们再探索一下Hoare分割方法，与Lomuto方法不同，Hoare 算法的数据比较从两边开始比较，如果起始指针用i表示，末端指针用j表示，过程中两个指针，逐渐向中间靠拢，最后i和j指针重合，从而分割结束，返回i值作为支点的下标。在这个过程中，一般选择起始元素作为支点，支点的位置会随着比较而不停变化。

在这里插入图片描述

逐行分析Hoare分割算法的过程，

(a) 原始数组，i指针指向数组头部，j指针指向数组的尾部，规定第一个元素(橙色)为支点(轴点)

(b) 从尾部开始操作指针，直至a[i]>a[j](2>1)

©交换i和j指向的数值，同时i指针向前移动1位

(d)从头部开始操作指针，比较a[i]和a[j]的值，直至a[i]>a[j](8>2)

(e)交换两个数值，循环(a)~(e)，直至两个指针指向相同的位置

ComparisonHoare 分割算法Lomuto 分割算法
支点选择通常情况下，选择第一个元素作为支点，当然也有选择中间或最后元素最为支点的情况通常最后一个元素作为支点，可以随机选择支点，随机选择支点后，仅需和最后一个元素交换即可
算法复杂度线性算法线性算法
算法速度相对较快相对较慢
理解难易度相对困难相对容易
支点是否固定过程中支点随时变化支点固定
  1. 代码实现

Hoare 分割算法，分为头文件，函数实现和测试

a) 头文件quick_sort.h

/**
 * @file quick_sort.h
 * @author your name (you@domain.com)
 * @brief Use hoare method to partition the array
 * @version 0.1
 * @date 2023-03-12
 * 
 * @copyright Copyright (c) 2023
 * 
 */
#ifndef QUICK_SORT_H
#define QUICK_SORT_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/**
 * @brief Use recursive method to finish the quick sort
 * 
 * @param a Array list
 * @param p Start position of array
 * @param r End position of array
 */
void quick_sort(int *a, int p, int r);

/**
 * @brief Partion a into two sections by using hoare method(from two SIDES)
 * Move from two sides to the center, pivot will be the first element
 * @param a Array list
 * @param p Start position of array
 * @param r End position of array
 * @return int Return partition location
 */
int partition_hoare(int *a,int p,int r);

/**
 * @brief Swap two elements in the array
 * 
 * @param p First element in the array
 * @param q Second element in the array
 * @return void
 */
void swap(int *p, int *q);


/**
 * @brief Show the array list
 * 
 * @param a Array list
 * @param n Number of array element
 */
void show_array(int *a, int n);


#endif

b)函数实现

/**
 * @file quick_sort.c
 * @author your name (you@domain.com)
 * @brief 
 * @version 0.1
 * @date 2023-03-11
 * 
 * @copyright Copyright (c) 2023
 * 
 */
#ifndef QUICK_SORT_C
#define QUICK_SORT_C
#include "quick_sort.h"

void quick_sort(int *a, int p, int r)
{
    int q;

    if(p<r) //It should define the exit entry of recursive
    {
        // Partition the subarray around the pivot, which ends up in A[q].
        q = partition_hoare(a, p, r);
        quick_sort(a, p, q - 1); // recursively sort the low side
        quick_sort(a, q + 1, r); // recursively sort the high side
    }
}

int partition_hoare(int *a, int p, int r)
{
    int i;
    int j; 

    i=p;
    j=r;
    
    while(i<j)
    {
        while(i<j && a[i]<=a[j])
        {
            j--;
        }

        if(i<j)
        {
            swap(a+i,a+j);
            i++;
        }

        while(i<j &&a[i]<=a[j])
        {
            i++;
        }

        if(i<j)
        {
            swap(a+i,a+j);
            j--;
        }
    }

    return i;
    
}

void swap(int *p, int *q)
{
    int temp;

    temp=*p;
    *p=*q;
    *q=temp;
}

void show_array(int *a, int n)
{
    int i;

    for(i=0;i<n;i++)
    {
        printf("%d ",a[i]);
    }

    printf("\n");
}

#endif

c)测试函数

/**
 * @file quick_sort_main.c
 * @author your name (you@domain.com)
 * @brief 
 * @version 0.1
 * @date 2023-03-12
 * 
 * @copyright Copyright (c) 2023
 * 
 */
#ifndef QUICK_SORT_MAIN_C
#define QUICK_SORT_MAIN_C
#include "quick_sort.c"

int main(void)
{
    int a[]={2,8,7,1,3,5,6,4};
    int n=sizeof(a)/sizeof(int);
    int r;
    int p;

    p=0;
    r=n-1;
    
    quick_sort(a,p,r);
    show_array(a,n);

    printf("The program is ending\n");
    getchar();

    return EXIT_SUCCESS;
}

#endif

Lomuto 分割算法，分为头文件，函数实现和测试

a) 头文件

/**
 * @file quick_sort.h
 * @author your name (you@domain.com)
 * @brief Use Lomuto method to partition the array
 * @version 0.1
 * @date 2023-03-11
 * 
 * @copyright Copyright (c) 2023
 * 
 */
#ifndef QUICK_SORT_H
#define QUICK_SORT_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/**
 * @brief Use recursive method to finish the quick sort
 * 
 * @param a Array list
 * @param p Start position of array
 * @param r End position of array
 */
void quick_sort(int *a, int p, int r);

/**
 * @brief Partion a into two sections by using lomuto method(from ONE SIDE)
 * Pivot element had been fixed before the exchange occurence
 * @param a Array list
 * @param p Start position of array
 * @param r End position of array
 * @return int Return partition location
 */
int partition_lomuto(int *a,int p,int r);

/**
 * @brief Swap two elements in the array
 * 
 * @param p First element in the array
 * @param q Second element in the array
 * @return void
 */
void swap(int *p, int *q);


/**
 * @brief Show the array list
 * 
 * @param a Array list
 * @param n Number of array element
 */
void show_array(int *a, int n);


#endif

b)函数实现

/**
 * @file quick_sort.c
 * @author your name (you@domain.com)
 * @brief 
 * @version 0.1
 * @date 2023-03-11
 * 
 * @copyright Copyright (c) 2023
 * 
 */
#ifndef QUICK_SORT_C
#define QUICK_SORT_C
#include "quick_sort.h"

void quick_sort(int *a, int p, int r)
{
    int q;

    if(p<r) //It should define the exit entry of recursive
    {
        // Partition the subarray around the pivot, which ends up in A[q].
        q = partition_lomuto(a, p, r);
        quick_sort(a, p, q - 1); // recursively sort the low side
        quick_sort(a, q + 1, r); // recursively sort the high side
    }
}

int partition_lomuto(int *a, int p, int r)
{
    int i;
    int j; 

    for(i=p-1,j=p;j<r;j++)
    {
        if(a[j]<=a[r])
        {
            i=i+1;
            swap(a+i,a+j);
        }
    }

    swap(a+(i+1),a+r);

    return (i+1);
}

void swap(int *p, int *q)
{
    int temp;

    temp=*p;
    *p=*q;
    *q=temp;
}

void show_array(int *a, int n)
{
    int i;

    for(i=0;i<n;i++)
    {
        printf("%d ",a[i]);
    }

    printf("\n");
}

#endif

c) 测试函数，同Hoare

  1. 总结

通过深入学习，更加深入理解两类分割函数对快速排序的影响，同时也回顾了快速排序的分治思想和实现要点。同时对双指针操作数组也有一个全新的认识。

参考资料

  1. Hoare’s vs Lomuto partition scheme in QuickSort - GeeksforGeeks
  2. 《Introduction to algorithm, 4ed》
Jasonchen1224
关注
快速排序分割点的2种方式
nsjlive的博客
03-06 1452
快速排序是一种交换排序。 基本思想： 通过一趟排序将要排序的数据分割成独立的两部分：分割点左边都是比它小的数，右边都是比它大的数。 然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 参考：https://www.jianshu.com/p/5f38dd54b11f 找分割点的核心代码： 赋值法：（参考百度百科：快速排序 ） ...
快速排序的另一种分割函数
yrk0556的博客
02-16 248
public int partition(int[] nums, int l, int r) {//数组索引l到索引r（包含边界） int p=nums[r];//将最右元素做枢纽元素 int idx=l;//双指针法填充 for(int i=l;i<r;i++){ if(nums[i]<p){ ...
快速排序：分割。
PrisonerLiu专栏
12-31 832
快速排序中的分割函数：选取一个枢轴数，再以这个枢轴数为基准，将比枢轴数小的数移动到左边，比枢轴数大的数移动到右边(若是升序排序)。其中，最初提取枢轴数这一步有人用一个很形象的词语来描述：挖坑。 //快速排序：分割 //选取最后一个数为枢轴数， //然后从左向右扫描 #include using namespace std; int Partition(int arr[],int low,
快速排序 一般分割
jinyi763776890的博客
04-28 172
计算机算法设计与分析第四版[王] #include<iostream> #include <stdlib.h> using namespace std; inline void swap(int &a, int &b) { int c = a; a = b; b = c; } //一般分割
我的小快排（两种分割方法）
邱孝兵的博客
05-03 1149
今天看到微博上有人转一篇文章，题目是《你问什么写不好快排》，看看自己多长时间能把快排写出来。结果，果然20分钟没写出来，本来以为明白原理，结果实现的出现各种问题，小 bug。最终花了半个点，写出来了，就是下面代码中 partition版本的。后来又翻了下算法导论，看到上面的快排，写了第二个分割子函数 partition2，这个原理更加清楚，用的是一个循环不变式的原理，将数组划分为了四个区域，具体说
数据结构课程设计 ---快速排序算法实现 .docx
07-07
快速排序是一种高效的排序算法，由英国计算机科学家C. A. R. Hoare在1960年提出。其核心思想是分治法，通过一趟排序将待排序的数组分为两个子数组，使得左边的元素均小于右边的元素，然后分别对这两个子数组进行递归...
php实现快速排序的三种方法分享
12-18
它的基本思想是通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据...
MATLAB实现快速排序算法及其两种分割方法研究
资源摘要信息:"本资源是一个关于快速排序算法的Matlab实现，特别关注了在寻找次序统计量时应用了两种不同的分割方法。快速排序是一种高效的排序算法，它采用了分治策略来把一个序列分割成较小的两部分，其中一部分的...
快速排序算法的副本.zip
10-23
快速排序有两种常见的实现方式：**Lomuto分区** 和 **Hoare分区**。 - **Lomuto分区** 方法：选取最后一个元素为基准，从第一个元素开始遍历，遇到比基准小的元素则与其交换，最后将基准放到遍历结束的位置。这种...
快速排序(Hoare 分割)
小猪爱拱地
04-16 958
1. 使用 median of three得到分割点 ２．当待排序数组的长度小于阈值（１０）的时候，切换到插入排序 代码： void insertion_sort(int *a, int start, int end) { int i, j; for(i = start + 1; i <= end; ++i) { int k = a[i]; for( j = i - 1...
快速排序中的分割算法的解析与应用
weixin_34288121的博客
06-15 252
一，分割(partition)算法介绍 所谓分割算法，先选定一个枢轴元素，然后 将数组中的元素分成两部分：比枢轴元素小的部分都位于枢轴元素左边；比枢轴元素大的部分都位于枢轴元素右边 此时，枢轴元素在数组中的位置就被“永久地确定”下来了---将整个数组排序，该枢轴元素的位置不会变化。 另外，枢轴元素的选取对分割算法至关重要。一般而言，终极追求的是：将数组平分。因此，尽可能地让枢轴元素的选取随机...
实际快速排序 -分割策略
cathemlin的博客
02-25 387
快速排序，枢纽元（比较值）理论上选哪个都可以。实际快速排序包括划分策略 和递归调用。public static <AnyType extends Comparable<? super AnyType>> void quicksort(AnyType [] a) { quicksort(a, 0, a.length-1); }private static final int CUTOFF= 3;
分治法之-快速排序分割函数变体-第K小数
Nick Feng 的小屋
07-06 648
第K小数问题陆陆续续碰到过几次，从大三算法分析期末考试，
高级排序之快速排序（分割与整合）
深度学习领域优质创作者，CSDN博客专家
11-29 304
在上一篇文章：高级排序之分割法中介绍分割法的基础上，做一个递归就是现在介绍的快速排序！快速排序的原理就是将数组以某个基准值进行分割，左边是小于这个基准值的数列，右边是大于这个基准值的数列，再通过递归，就可以把原数组进行排序了 #include<stdio.h> #define MAX 10000 int A[MAX],n; int mypartition(int left,int right) { int x,i,j,t; x=A[right];//最后一个元素作为分割的
分割
qq_43219250的博客
02-28 203
分割 函数partition(A,p,r)可以将数组A【p,r】分割成A【p,q-1】和A【q+1,r】两部分并返回下标q的值。其中，前面一部分均小于A【q】,后面一部分均大于A【q】. 【注意】这里的r是数组A末尾元素的下标，进行分割时需要以A[r]为基准 。 int partition(int A[],int p,int r) { int x,i,j; x=A[r]; i=p-1; f...
排序算法——快速排序
哈哈的博客
10-27 345
今天我们来说一说快速排序吧！ 其实快速排序跟冒泡排序的原理差不多 快速排序算法流过多次比较和交换来变现挣序，其排序流程如下： （1）首光设定一个分界值，通过该分界值将数组分成左右两部分。 （2）将大于等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时左边部分中各元素都小于等于分界值，而右边部分中各元素都大于等于分界值。 （3）然后，上边和右边的数据可以独立排序。对于左侧的数组...
快排分割区域的两种实现思路
shanliang
05-19 2252
调用 public static void quick_sort(int f[],int from,int to) { if(from>=to) return; int compare=partition(f, from, to); quick_sort(f, from, compare-1); quick_sort(f, compare+1, to); } 第一种 思路：f[to]为比对值。然后先i、j分别从左右查询比compare打的、小的。然后交换数据位置。 public stat
基础篇——快速排序
允诺@晴天的博客
10-12 3171
j 指针负责找到比基准点小的元素，一旦找到则与 i 进行交换。i 指针维护小于基准点元素的边界，也是每次交换的目标索引。最后基准点与 i 交换，i 即为分区位置。基准点在左边，并且要先 j 后 i。选择最右元素作为基准点元素。数据量较大时，优势非常明显。
分治法在排序算法中的应用（JAVA）--快速排序（Lomuto划分、Hoare划分、随机化快排）
一串代码的博客
02-04 3719
分治法在排序算法中的应用--快速排序 时间复杂度：平均O(nlogn)，最坏O(n^2) 如果说归并排序是按照元素在数组中的位置划分的话，那么快速排序就是按照元素的值进行划分。划分方法由两种，本节将主要介绍Huare划分，这也是我们通常采用的划分方法。 为了文章完整，下面只给出基于Lomuto划分的代码，详细分析请参考减治法在查找算法中的应用（JAVA）--快速查找。 1、基于Lomuto...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值