Quick Sort

最新推荐文章于 2025-09-07 20:32:33 发布
转载 最新推荐文章于 2025-09-07 20:32:33 发布 · 63 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/Hangtutu/p/8023536.html
文章标签：

#数据结构与算法

简单快速排序

选取数组第一个元素为临界值,然后将数组排序,小于临界值得都放在临界值左边,大于临界值的都放在临界值右边,然后递归知道数组完全有序.但是如果数组基本有序或者数组中重复元素较多的情况下,临界值的依然选择第一个就不是很恰当了,所以后续会有快排的优化

/**
 * 简单快速排序--对于基本有序的数组和重复元素较多的数组时间复杂度较高,存在不足需要改进
 */
public class QuickSort {
    private QuickSort() {
    }

    //通过分区,返回两个区的临界值
    private static <T extends Comparable<? super T>> int partition(T[] arr, int low, int high) {
        T temp = arr[low];
        int j = low;
        for (int i = low + 1; i <= high; i++) {
            if (arr[i].compareTo(temp) < 0) {
                j++;
                swap(arr, i, j);
            }
        }
        swap(arr, low, j);
        return j;
    }

    //递归将数组分区
    private static <T extends Comparable<? super T>> void sort(T[] arr, int low, int high) {
        if (low >= high) {
            return;
        }
        int partition = partition(arr, low, high);
        sort(arr, low, partition - 1);
        sort(arr, partition + 1, high);
    }

    public static <T extends Comparable<? super T>> void sort(T[] arr) {
        sort(arr, 0, arr.length - 1);
    }

    //交换数组中的两个元素
    private static <T extends Comparable<? super T>> void swap(T[] arr, int i, int j) {
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    //打印数组元素
    public static <T extends Comparable<? super T>> void printArray(T[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] arr = {9, 5, 1, 3, 7, 2, 8, 4, 6, 10};
        sort(arr);
        printArray(arr);
    }
}　　

快速排序优化

优化一:如果基本有序数组的第一个元素是临界值,那么临界值很可能是最小的元素,导致分区不均,时间复杂度相当于O(n^2),所以为了尽量消除数组基本有序的情况,在数组中随机选取一个元素,解决了数组基本有序排序效率低的情况,但是若数组中存在大量重复元素,效率低的情况仍未解决.

优化二:对于数组中元素基本有序时,可以更换为直接插入排序,提高排序效率

public class QuickSort {
    private QuickSort() {
    }

    //通过分区,返回两个区的临界值
    private static <T extends Comparable<? super T>> int partition(T[] arr, int low, int high) {
        /*优化一:随机选取数组中的一个元素,将其与数组第一个元素进行交换*/
        swap(arr, low, (int) (Math.random() * (high - low + 1) + low));
        T temp = arr[low];
        int j = low;
        for (int i = low + 1; i <= high; i++) {
            if (arr[i].compareTo(temp) < 0) {
                j++;
                swap(arr, i, j);
            }
        }
        swap(arr, low, j);
        return j;
    }

    //递归将数组分区
    private static <T extends Comparable<? super T>> void sort(T[] arr, int low, int high) {
        /*优化二:对于基本有序的数组可以使用直接插入排序*/
        if (high - low <= 15) {
            insertionSort(arr, low, high);
            return;
        }
        int partition = partition(arr, low, high);
        sort(arr, low, partition - 1);
        sort(arr, partition + 1, high);
    }

    public static <T extends Comparable<? super T>> void sort(T[] arr) {
        sort(arr, 0, arr.length - 1);
    }

    // 对arr[l...r]的区间使用InsertionSort排序
    public static void insertionSort(Comparable[] arr, int l, int r) {

        for (int i = l + 1; i <= r; i++) {
            Comparable temp = arr[i];
            int j = i;
            for (; j > l && arr[j - 1].compareTo(temp) > 0; j--)
                arr[j] = arr[j - 1];
            arr[j] = temp;
        }
    }

    //交换数组中的两个元素
    private static <T extends Comparable<? super T>> void swap(T[] arr, int i, int j) {
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    //打印数组元素
    public static <T extends Comparable<? super T>> void printArray(T[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] arr = {9, 5, 1, 3, 7, 2, 8, 4, 6, 10};
        sort(arr);
        printArray(arr);
    }
}　　

 快速排序--优化2

从左向右找比临界值大的,从右向左找比临界值小的,然后将两者交换,这样对于大量相同的元素不用全部交换,解决了数组中存在大量元素的问题

public class QuickSort {
    private QuickSort() {
    }

    //通过分区,返回两个区的临界值
    private static <T extends Comparable<? super T>> int partition(T[] arr, int low, int high) {
        /*优化:随机选取数组中的一个元素,将其与数组第一个元素进行交换*/
        swap(arr, low, (int) (Math.random() * (high - low + 1) + low));
        T temp = arr[low];
        int i = low + 1;
        int j = high;
        while (true) {
            while (i <= high && arr[i].compareTo(temp) < 0) {
                i++;
            }
            while (j >= low + 1 && arr[j].compareTo(temp) > 0) {
                j--;
            }
            if (i > j) {
                break;
            }
            swap(arr,i,j);
            i++;
            j--;
        }
        swap(arr, low, j);
        return j;
    }

    //递归将数组分区
    private static <T extends Comparable<? super T>> void sort(T[] arr, int low, int high) {
        /*对于基本有序的数组可以使用直接插入排序*/
        if (high - low <= 15) {
            insertionSort(arr, low, high);
            return;
        }
        int partition = partition(arr, low, high);
        sort(arr, low, partition - 1);
        sort(arr, partition + 1, high);
    }

    public static <T extends Comparable<? super T>> void sort(T[] arr) {
        sort(arr, 0, arr.length - 1);
    }

    // 对arr[l...r]的区间使用InsertionSort排序
    public static void insertionSort(Comparable[] arr, int l, int r) {

        for (int i = l + 1; i <= r; i++) {
            Comparable temp = arr[i];
            int j = i;
            for (; j > l && arr[j - 1].compareTo(temp) > 0; j--)
                arr[j] = arr[j - 1];
            arr[j] = temp;
        }
    }

    //交换数组中的两个元素
    private static <T extends Comparable<? super T>> void swap(T[] arr, int i, int j) {
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    //打印数组元素
    public static <T extends Comparable<? super T>> void printArray(T[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] arr = {9, 5, 1, 3,7, 7, 2, 8, 4, 6, 10};
        sort(arr);
        printArray(arr);
    }
}

两路快排--不交换　

public class QuickSort {
    private QuickSort() {
    }

    //通过分区,返回两个区的临界值
    private static <T extends Comparable<? super T>> int partition(T[] arr, int low, int high) {
        /*优化:随机选取数组中的一个元素,将其与数组第一个元素进行交换*/
        swap(arr, low, (int) (Math.random() * (high - low + 1) + low));
        T temp = arr[low];
        int i = low + 1;
        int j = high;
        while (i < j) {
            while (i < j && temp.compareTo(arr[j]) < 0) {
                j--;
            }
            arr[i] = arr[j]; //j停在那里不动
            while (i < j && temp.compareTo(arr[j]) > 0) {
                i++;
            }
            arr[j] = arr[i];//i停在那里不动
        }
        arr[j] = temp;
        return j;
    }

    //递归将数组分区
    private static <T extends Comparable<? super T>> void sort(T[] arr, int low, int high) {
        /*对于基本有序的数组可以使用直接插入排序*/
        if (high - low <= 15) {
            insertionSort(arr, low, high);
            return;
        }
        int partition = partition(arr, low, high);
        sort(arr, low, partition - 1);
        sort(arr, partition + 1, high);
    }

    public static <T extends Comparable<? super T>> void sort(T[] arr) {
        sort(arr, 0, arr.length - 1);
    }

    // 对arr[l...r]的区间使用InsertionSort排序
    public static void insertionSort(Comparable[] arr, int l, int r) {

        for (int i = l + 1; i <= r; i++) {
            Comparable temp = arr[i];
            int j = i;
            for (; j > l && arr[j - 1].compareTo(temp) > 0; j--)
                arr[j] = arr[j - 1];
            arr[j] = temp;
        }
    }

    //交换数组中的两个元素
    private static <T extends Comparable<? super T>> void swap(T[] arr, int i, int j) {
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    //打印数组元素
    public static <T extends Comparable<? super T>> void printArray(T[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] arr = {9, 5, 1, 3, 7, 7, 2, 8, 4, 6, 10};
        sort(arr);
        printArray(arr);
    }
}　　

三路快排

public class QuickSort {
    private QuickSort() {
    }

    private static <T extends Comparable<? super T>> int[] partition(T[] arr, int low, int high) {
        swap(arr, low, (int) (Math.random() * (high - low + 1) + low));
        T temp = arr[low];
        int i = low;
        int j = high;
        int cur = i;
        while (cur <= j) {
            if (temp.compareTo(arr[cur]) == 0) {
                cur++;
            } else if (temp.compareTo(arr[cur]) > 0) {
                swap(arr, cur++, i++);
            } else {
                swap(arr, cur, j--);
            }
        }
        return new int[]{i - 1, j + 1};
    }

    private static <T extends Comparable<? super T>> void sort(T[] arr, int low, int high) {
        if (high - low <= 15) {
            insertionSort(arr, low, high);
            return;
        }

        int[] ret = partition(arr, low, high);
        sort(arr, low, ret[0]);
        sort(arr, ret[1], high);
    }

    public static <T extends Comparable<? super T>> void sort(T[] arr) {
        sort(arr, 0, arr.length - 1);
    }

    // 对arr[l...r]的区间使用InsertionSort排序
    private static void insertionSort(Comparable[] arr, int l, int r) {

        for (int i = l + 1; i <= r; i++) {
            Comparable temp = arr[i];
            int j = i;
            for (; j > l && arr[j - 1].compareTo(temp) > 0; j--)
                arr[j] = arr[j - 1];
            arr[j] = temp;
        }
    }

    //交换数组中的两个元素
    private static <T extends Comparable<? super T>> void swap(T[] arr, int i, int j) {
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    //打印数组元素
    public static <T extends Comparable<? super T>> void printArray(T[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] arr = {9, 5, 1, 3, 7, 7, 2, 8, 4, 6, 10};
        sort(arr);
        printArray(arr);
    }
}

　　

 

转载于:https://www.cnblogs.com/Hangtutu/p/8023536.html

排序——快速排序（Quick sort）
努力中的老周的专栏
02-09 30万+
概况 快速排序（Quick sort）是对冒泡排序的一种改进。快速排序由C. A. R. Hoare在1960年提出。 算法思路 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 快速排序算法通过多次比较和交换来实现排序，其排序流程如下： ......
快速排序（Quick sort）
热门推荐
雪月清的博客
07-20 9万+
一、简介 快速排序是（Quick sort）是对冒泡排序的一种改进，是非常重要且应用比较广泛的一种高效率排序算法。 二、算法思路 快速排序是通过多次比较和交换来实现排序，在一趟排序中把将要排序的数据分成两个独立的部分，对这两部分进行排序使得其中一部分所有数据比另一部分都要小，然后继续递归排序这两部分，最终实现所有数据有序。 大致步骤如下： 首先设置一个分界值也就是基准值又是也称为监视哨，通过该分界值将数据分割成两部分。 将大于或等于分界值的数据集中到右边，小于分界值的数据集中到左边。一趟排序过后，左边部
7-1 Quick Sort
2301_79103337的博客
11-25 701
在这里给出相应的输出。在这里给出一组输入。
快速排序（Quick Sort）
小瑾的博客
05-20 1194
快速排序是一种高效的分治算法，其核心思想是通过选择一个基准值将数组分为两部分，左边部分的元素均小于等于基准值，右边部分的元素均大于等于基准值，然后递归地对左右两部分进行排序，直到子数组长度为1或0。关键步骤包括选择基准值、分区操作和递归排序。性能分析显示，快速排序在最优和平均情况下的时间复杂度为O(nlogn)，最坏情况下为O(n²)，空间复杂度在最优情况下为O(logn)，最坏情况下为O(n)。快速排序是一种不稳定的排序算法。
SWUST OJ 413: Quick Sort
OG_Lzy的博客
05-19 286
【代码】SWUST OJ 413: Quick Sort。
413: Quick Sort
2302_79277225的博客
11-15 339
【代码】413: Quick Sort。
1101 Quick Sort
qq_43655213的博客
01-05 735
1101 Quick Sort 题目 暴力办法：根据快排的思路，扫描数组，依次判断当前元素是否是主元 #include <iostream> #include <bits/stdc++.h> using namespace std; const int MAXN = 1e5; int A[MAXN] = {0}; vector<int> res; int N; int main() { ios::sync_with_stdio(0),cin.tie(0),cout
python 快速排序（Quick Sort）
大白菜代码的博客
12-31 755
快速排序是一种高效的排序算法，适用于大规模数据的排序。通过优化基准选择策略，可以进一步提高其性能和稳定性。
swust oj 413#Quick Sort
m0_67413470的博客
05-01 734
Hoare，平均而言，进行 Θ（n log n） 比较以对 n 个项目进行排序。通常，快速排序在实践中比其他 Θ（n log n） 算法快得多，因为它的内部循环可以在大多数架构上高效实现，并且在大多数实际数据中，可以做出设计选择，从而最大限度地减少需要二次时间的可能性。3.递归排序较小元素的子列表和较大元素的子列表。递归的基本情况是大小为 0 或 1 的列表，这些列表始终按顺序排序。2. 对列表重新排序，以便所有小于枢轴的元素都位于枢轴之前，并且所有大于枢轴的元素都位于枢轴之后（相等的值可以任一种方式）。
quick sort
06-16
Use QuickSort algorithm to sort the array that has n elements that are constructed by the random() function. Requirements: The template should be used for all kinds of data type, such as: integer, ...
sort_exp.rar_quick sort_桶排序
09-22
快速排序（Quick Sort）是由C.A.R. Hoare在1960年提出的，它是一种非常高效的排序算法，其基本思想是分治法。快速排序的基本步骤如下： 1. **选择枢轴元素**：在待排序的数组中选取一个元素作为枢轴，通常选择第一...
AMD KFD 技术分析 3-1: alloc memory in hsakmt
deeplyMind
09-04 175
本文分析了ROCm HSAKMT库中的核心API hsaKmtAllocMemory 的实现原理。该API为上层应用提供统一的内存分配接口，支持多种内存类型（VRAM、系统内存等）。文章详细解析了其参数校验、标志冲突检查、分配类型选择（系统内存、VRAM或Scratch内存）以及与aperture管理器的交互过程。同时介绍了典型使用场景（如VRAM分配、SVM一致性内存等）和内存管理机制（包括对象追踪、释放流程）。该API通过底层aperture管理和红黑树实现高效的内存分配与安全控制，支持多GPU共享和进
二叉树的前中后序遍历(迭代法)
最新发布
mrjieke6的博客
09-07 854
本文系统介绍了二叉树前序、中序和后序遍历的迭代实现方法。前序遍历采用栈结构，按;根→右→左 ;顺序入栈；中序遍历先全部左子树入栈再访问节点；后序遍历则通过修改前序遍历顺序为"根→右→左 ;后反转结果。三种遍历时间复杂度均为O(n)，空间复杂度最坏O(n)。与递归实现相比，迭代方法避免了栈溢出风险，处理大型树更稳定。每种遍历方式都配有详细代码解析、执行示例和复杂度分析，并讨论了实际应用场景，为掌握树结构操作提供了系统指导。
【链表】2.两两交换链表中的节点（medium）
2402_85428625的博客
09-04 298
给你⼀个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进⾏节点交换）。链表中节点的数⽬在范围 [0, 100] 内。输⼊：head = [1,2,3,4]画图画图画图，重要的事情说三遍~输⼊：head = [1]输出：[2,1,4,3]输⼊：head = []
机器学习-逻辑回归
爱分享，爱ai，用热爱驱动ai学习方向
09-03 1246
逻辑回归是一种用于二分类问题的统计学习方法，通过Sigmoid函数将线性结果映射为概率值（0~1）。核心原理包括极大似然估计和对数损失函数，采用梯度下降优化参数。应用场景涵盖金融风控、医疗诊断等领域。Python实现需注意参数配置（solver、penalty等），评估指标包括精确率、召回率、F1值和AUC。案例实践表明，月合约和光纤服务用户具有较高流失风险。该模型适用于处理二分类问题，但样本不均衡时需重点关注召回率指标。
【牛客刷题-剑指Offer】BM18 二维数组中的查找：一题四解，从暴力到最优
字节卷动
09-06 173
方法时间复杂度空间复杂度优点缺点适用场景暴力遍历On×mOn×mO1O(1)O1简单直接，易实现效率低，不适合大数据量小规模数据二分查找Omlog⁡nOmlognO1O(1)O1利用行有序，效率较高未利用列有序特性行数较少时Z字形查找OnmO(n + m)OnmO1O(1)O1最优解，利用行列有序无各种规模数据递归分治平均优于OnmO(nm)OnmOlog⁡nmOlognm。
机器学习：后篇
2301_82065950的博客
09-04 992
本文介绍了多种机器学习算法的原理与应用，主要包括KNN、朴素贝叶斯、决策树、随机森林、线性回归、逻辑回归和K-means聚类。KNN通过计算样本距离进行分类，但计算量大且易受维度灾难影响；朴素贝叶斯基于贝叶斯理论，通过独立性假设简化计算；决策树通过信息增益或基尼指数构建分类模型，但易过拟合；随机森林通过多决策树投票提升分类效果；线性回归采用最小二乘法或梯度下降优化参数；逻辑回归结合线性回归与Sigmoid函数实现分类；K-means通过簇内差异最小化进行无监督聚类。每种算法均配有scikit-learn的A
C++八股 —— 手撕字典
m0_46329175的博客
09-03 1020
如何使用C++实现一个类似Python字典的数据结构，支持任意类型的value
Quick sort
05-25
Quick sort is a popular sorting algorithm that works by partitioning an array into two sub-arrays, and then recursively sorting each sub-array. It is a divide-and-conquer algorithm that has an average...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值