图解排序算法(03) -- 彻底搞懂快速排序

本文深入解析快速排序算法,探讨其分治策略优势,基准元素选择策略,以及双边循环法和单边循环法的具体实现,包括递归与非递归版本。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1、初识快速排序

冒泡排序一样,快速排序也属于交换排序,通过元素之间的比较和交换位置来达到排序的目的
不同的是:

  • 冒泡排序在每一轮中只把1个元素冒泡到数列的一端
  • 快速排序则在每一轮挑选一个基准元素,并让其他比它大的元素移动到数列一边,比它小的元素移动到数列的另一边,从而把数列拆解成两个部分;这种思路就叫作分治法,如下图所示:
    在这里插入图片描述

使用分治法的优势

假如给出一个8个元素的数列,一般情况下,使用冒泡排序需要比较7轮,每一 轮把1个元素移动到数列的一端,时间复杂度是O(n²);快速排序的流程如下:
【原数列在每一轮都被拆分成两部分,每一部分在下一轮又分别被拆分成两部分,直到不可再分为止】
在这里插入图片描述
每一轮的比较和交换,需要把数组全部元素都遍历一遍,时间复杂度是O(n);
假如元素个数是n,那么平均情况下需要遍历logn轮,因此快速排序算法总体的平均时间复杂度是O(nlogn)

2、基准元素的选择

在分治过程中,以基准元素为中心,把其他元素移动到它的左右两边
选择基准元素最简单的方式是选择数列的第1个元素,如下图:
在这里插入图片描述
例外:假如有一个原本逆序的数列,期望排序成顺序数列,如下图:
在这里插入图片描述
【整个数列并没有被分成两半,每一轮都只确定了基准元素的位置,在这种情况下,数列的第1个元素要么是最小值,
要么是最大值,根本无法发挥分治法的优势,快速排序需要进行n轮,时间复杂度退化成了O(n²)

避免上面这种情况,可以随机选择一个元素作为基准元素,并且让基准元素和数列首元素交换位置
在这里插入图片描述
通过上述方法,可以有效地将数列分成两部分,但即使随机选择基准元素,也会有极小的几率选到数列的最大值或最小 值,同样会影响分治的效果;所以,快速排序的平均时间复杂度是O(nlogn),但最坏情况下的时间复杂度O(n²)
【在后文中,直接将首元素作为基准元素】

3、元素的交换

选定了基准元素之后要进行元素的交换,即把其他元素中小于基准元素的都交换到基准元素一边,大于基准元素的都交换到基准元素另一边,实现有两种方法:双边循环法和单边循环法

双边循环法(递归)

给出原始数列如下,要求对其从小到大进行排序
在这里插入图片描述
1、选定基准元素pivot,并且设置两个指针left和right,指向数列的最左和最右两个元素
在这里插入图片描述
2、进行第1次循环,从right指针开始,让指针所指向的元素和基准元素做比较【如果大于或等于pivot,则指针向左移动;如果小于pivot,则right指针停止移动,切换到left指针】;
在当前数列中1<4,所以right直接停止移动,换到left指针;让指针所指向的元素和基准元素做比较【如果小于或等于 pivot,则指针向右移动;如果大于pivot,则left指针停止移动】;
由于left开始指向的是基准元素,判断肯定相等,所以left右移1位,如下图:
在这里插入图片描述
由于7>4,left指针在元素7的位置停下;这时让left和right指针所指向的元素进行交换
在这里插入图片描述
3、进入第2次循环,重新切换到right指针,向左移动;right指针先移动到8,8>4,继续左移;由于2<4,停止在2的位置,后续步骤如下图所示:
在这里插入图片描述

双边循环法代码实现

Code:【使用递归】

import java.util.Arrays;

/**
 * @ClassName QuickSort
 * @Description  快速排序
 * @Date: 2020/3/28
 * @Version 1.0
 */
public class QuickSort {
    public static void quickSort(int[] arr,int startIndex,int endIndex){
    //递归结束条件:startIndex >=  endIndex
        if(startIndex >= endIndex){
            return;
        }
    // 获取基准元素
        int pivotIndex = partiton(arr,startIndex,endIndex);
    // 根据基准元素,分成两部分进行递归排序
    quickSort(arr,startIndex,pivotIndex -1);
    quickSort(arr,pivotIndex + 1,endIndex);
    }

    //双边循环法
    //arr 带交换的数组
    //startIndex 起始下标
    //endIndex  结束下标
    public static int partiton(int[] arr,int startIndex,int endIndex){
       //取第一个位置(也可以随机)的元素为基准元素
       int pivot = arr[startIndex];
       int left = startIndex;
       int right = endIndex;

       while (left != right){
           //控制right指针比较并左移
           while (left<right && arr[right]>pivot){
               right--;
           }
           //控制left指针比较并右移
           while (left < right && arr[left] <= pivot){
               left++;
           }
           //交换left和right指针所指向的元素
           if(left < right){
               int p = arr[left];
               arr[left] = arr[right];
               arr[right] = p;
           }
       }

       //pivot和指针重合点交换
        arr[startIndex] = arr[left];
        arr[left] = pivot;
        return  left;
    }

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

编译输出:【partition方法则实现了元素的交换,让数列中的元素依据自身大小分别交换到基准元素的左右两边
在这里插入图片描述

单边循环法(递归)

双边循环法从数组的两边交替遍历元素,虽然更加直观,但是代码实现相对烦琐;
单边循环法只从数组的一边对元素进行遍历和交换,较为简单,详细过程:
给出原始数列如下,要求对其从小到大进行排序:
在这里插入图片描述
1、选定基准元素pivot,同时设置一个mark指针指向数列起始位置,这个mark指针代表小于基准元素的区域边界
在这里插入图片描述
2、从基准元素的下一个位置开始遍历数组

  • 如果遍历到的元素大于基准元素,续往后遍历;
  • 如果遍历到的元素小于基准元素,则需要做两件事:
  • 1、把mark指针右移1 位,因为小于pivot的区域边界增大了1;
  • 2、让最新遍历到的元素和mark指针所在位置的元素交换位置,【因为最新遍历的元素归属于小于pivot的区域】

遍历到元素7,7>4,所以继续遍历
在这里插入图片描述
来遍历到的元素是3,3<4,所以mark指针右移1位
在这里插入图片描述
元素3和mark指针所在位置的元素交换,因为元素3归属于小于pivot 的区域
在这里插入图片描述
3、继续遍历,后续步骤如图所示:
在这里插入图片描述

单边循环法代码实现

Code:【使用递归】

/**
 * @ClassName QuickSort
 * @Description  快速排序
 * @Date: 2020/3/28
 * @Version 1.0
 */
public class QuickSort2 {
    public static void quickSort(int[] arr,int startIndex,int endIndex){
    //递归结束条件:startIndex >=  endIndex
        if(startIndex >= endIndex){
            return;
        }
    // 获取基准元素
        int pivotIndex = partiton(arr,startIndex,endIndex);
    // 根据基准元素,分成两部分进行递归排序
    quickSort(arr,startIndex,pivotIndex -1);
    quickSort(arr,pivotIndex + 1,endIndex);
    }

    //单边循环法
    //arr 带交换的数组
    //startIndex 起始下标
    //endIndex  结束下标
    public static int partiton(int[] arr,int startIndex,int endIndex){
       //取第一个位置(也可以随机)的元素为基准元素
       int pivot = arr[startIndex];
       int mark = startIndex;
       for(int i = startIndex+1;i<endIndex;i++){
           if(arr[i]<pivot){
               mark++;
               int p = arr[mark];
               arr[mark] = arr[i];
               arr[i] = p;
           }
       }
        arr[startIndex] = arr[mark];
        arr[mark] = pivot;
        return  mark;
    }

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

编译输出:【partition方法则实现了元素的交换,让数列中的元素依据自身大小分别交换到基准元素的左右两边
在这里插入图片描述

非递归实现

绝大多数的递归逻辑,都可以用栈的方式来代替
代码中一层一层的方法调用,本身就使用了一个方法调用栈;
【每次进入一个新方法,就相当于入栈;每次有方法返回,就相当于出栈】
所以,可以把原本的递归实现转化成一个栈的实现,在栈中存储每一次方法调用的参数。
在这里插入图片描述

非递归代码实现

Code:【非递归】

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

/**
 * @ClassName QuickSort
 * @Description  快速排序
 * @Date: 2020/3/28
 * @Version 1.0
 */
public class QuickSort3 {
    public static void quickSort(int[] arr,int startIndex,int endIndex){
    //用一个集合栈来代替递归的函数栈
    Stack<Map<String,Integer>> quickSortStack = new Stack<Map<String,Integer>>();
    // 整个数列的起止下标,以哈希的形式入栈
        Map rootParam = new HashMap();
        rootParam.put("startIndex",startIndex);
        rootParam.put("endIndex",endIndex);
        quickSortStack.push(rootParam);

    // 循环结束条件:栈为空
    while (!quickSortStack.isEmpty()){
        //栈顶元素出栈,得到起止下标
        Map<String,Integer> param = quickSortStack.pop();
        //得到基准元素位置
        int pivotIndex = partiton(arr,param.get("startIndex"),param.get("endIndex"));
        //根据基准元素分成两部分,把每一部分的起止下标入栈
        if(param.get("startIndex")< (pivotIndex -1)){
            Map<String,Integer> leftParam = new HashMap<String, Integer>();
            leftParam.put("startIndex",param.get("startIndex"));
            leftParam.put("endIndex",pivotIndex-1);
            quickSortStack.push(leftParam);
        }
        if(pivotIndex + 1 < param.get("endIndex")){
            Map<String,Integer> rightParam = new HashMap<String, Integer>();
            rightParam.put("startIndex",pivotIndex+1);
            rightParam.put("endIndex",param.get("endIndex"));
            quickSortStack.push(rightParam);
        }
    }
 }

    //单边循环法
    //arr 带交换的数组
    //startIndex 起始下标
    //endIndex  结束下标
    public static int partiton(int[] arr,int startIndex,int endIndex){
        //取第一个位置(也可以随机)的元素为基准元素
        int pivot = arr[startIndex];
        int mark = startIndex;
        for(int i = startIndex+1;i<= endIndex;i++){
            if(arr[i]<pivot){
                mark++;
                int p = arr[mark];
                arr[mark] = arr[i];
                arr[i] = p;
            }
        }
        arr[startIndex] = arr[mark];
        arr[mark] = pivot;
        return  mark;
    }

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

编译输出:【非递归方式代码的变动只发生在quickSort方法中; 该方法引入了一个存储Map类型元素的栈,用于存储每一次交换时的起始下标和结束下标。
**每一次循环,都会让栈顶元素出栈,通过partition方法进行分治,并且按照 基准元素的位置分成左右两部分,左右两部分再分别入栈,**当栈为空时,说明排序 已经完毕,退出循环】
在这里插入图片描述———————————————————————————————————————
内容来源:《漫画算法》
关注公众号,回复 【算法】,获取高清算法书!
在这里插入图片描述

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值