快速排序

排序效率在同为O(N*logN)的几种排序方法中效率较高 思想： 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 平均时间复杂度： nlog2n ，空间复杂度： log2n，不稳定 public class QuickSort { /** * 快速排序 * @param arr：数组名 * @param leftbound：数组的起始下标 * @param rightbound：数组的结束下标 */ public void sort ( int [ ] arr , int leftbound , int rightbound ) { if ( leftbound >= rightbound ) return ; int mid = partition ( arr , leftbound , rightbound ) ; //轴的位置 sort ( arr , leftbound , mid - 1 ) ; //对轴前面的数进行快排 sort ( arr , mid + 1 , rightbound ) ; //对轴后面的数进行快排 } /** * 将数与轴的位置的数进行大小比较，小的数在轴的前面，大的数在轴的后面 * 左

/* * @Author: hzf * @Date: 2020-02-28 20:52:55 * @Last Modified by: hzf * @Last Modified time: 2020-02-28 21:46:53 */ /* 原理： 问题一： 将一系列数字进行处理，使得大于num的数字在数组左边，小于num的数字位于数组右边 解决方法： 将数组划分为左边，右边两部分， 指针p指向左边的右边界，指针q指向数组的右边的左边界 从数组的L[n]的0位置开始比较 如果L[i]<num 则Swap(L, i++, ++p),即交换当前数字与p指针指向的下一个数字，p指针右移 如果L[i]>num，则i++即可 即将小数字交换到左边 问题二： 将一系列数字进行处理，使得大于num的数字在数组左边，小于num的数字位于数组右边，等于num的数字位于数组中间 将数组划分为左边，右边两部分， 指针p指向左边的右边界，指针q指向数组的右边的左边界 从数组的L[n]的0位置开始比较 如果L[i]<num 则Swap(L, i++, ++p),即交换当前数字与p指针指向的下一个数字，p指针右移 如果L[i]==num，则i++ 如果L[i]>num,则Swap(L, i, --q) */ #include<iostream> #include<math.h> using

快排算法的特点 实用性强。 很多实际的项目中使用了快排算法。但通常对算法都进行了调整（tuning），比如Java.util.Arrays类中的sort函数就使用了快排算法，但使用了双参考值（ Dual-Pivot Quicksort ）等一些改进措施。由于快排算法为递归算法，可以用循环代替递归函数调用，改进性能。 不需要额外的空间。 可以将数组中的数据直接交换位置实现排序，所以理论上不需要额外的空间。 时间复杂度 平均情况：O(nlgn) 最坏情况： O(n*n)，发生在当数据已经是排序状态时 快排算法的基本原理 1、从数据中选取一个值a[i]作为参考 2、以a[i] 为参考，将数据分成2部分：P1、P2，P1中的数据全部≤a[i]，P2中的数据全部＞a[i]，数据变为｛｛P1｝｛a[i]｝｛P2｝｝ 3、将P1、P2重复上述步骤，直到各部分中只剩1个数据 4、数据完成升序排列 示例： 原始数据： ｛3，9，8，5，2，1，6｝ 第1步：选取第1个数据：3 第2步：将数据分成2部分，左边≤3，右边大于>3： ｛2，1｝ ｛3｝ ｛9，8，5，6｝ 第3步：将各部分重复以上步骤，直到每部分只剩1个数据： ｛2，1｝ => ｛1｝ ｛2｝ ｛9，8，5，6｝ => ｛8，5，6｝ ｛9｝=> ｛5，6｝ ｛8｝ ｛9｝=> ｛5｝ ｛6｝ ｛8｝ ｛9｝ 第4步：数据完成升序排列：

快速排序 基本思想： 1. 先取出一个数作为基准数。 2. 分区过程，将比这个数大的全放到它的右边，小于或等于它的全放左边。 3. 再对左右重复第二步，直到到各个区间只有一个数。 #include<iostream> using namespace std; template<class T> void quick_sort(T s[],int start, int end){ int oldStart = start, oldEnd = end; int temp = start; T mid = s[start++]; while(start<=end){ if(temp < start){ if(s[end] > mid){ end --; continue; } s[temp] = s[end]; temp = end--; }else{ if(s[start] <= mid){ start++; continue; } s[temp] = s[start]; temp = start++; } s[temp] = mid; // 如果没有调整，说明已经有序，不用再分了 if(temp == oldStart){ return; } quick_sort(s, oldStart, temp-1); quick_sort(s, temp+1, oldEnd); } }

# include <stdio.h> # include <algorithm> using namespace std ; int main ( ) { int INF = 0x7fffffff ; int n , ans = 0 ; scanf ( "%d" , & n ) ; int a [ n ] , b [ n ] ; for ( int i = 0 ; i < n ; i ++ ) { scanf ( "%d" , & a [ i ] ) ; } int leftmax [ n ] , rightmin [ n ] ; leftmax [ 0 ] = 0 ; rightmin [ n - 1 ] = INF ; for ( int i = 1 ; i < n ; i ++ ) { leftmax [ i ] = max ( leftmax [ i - 1 ] , a [ i - 1 ] ) ; } for ( int i = n - 2 ; i >= 0 ; i -- ) { rightmin [ i ] = min ( rightmin [ i + 1 ] , a [ i + 1 ] ) ; } for ( int i = 0 ; i < n ; i ++ ) { if ( a [ i ] > leftmax [ i ] && a [ i ] < rightmin

内部排序指排序记录存放在计算机随机存储器中进行的排序过程，外部排序指，由于待排序的记录数量太大，以致排序过程中尚需对外存进行访问的排序过程。 一、快速排序的基本思想 1、快速排序（Quick Sorting）又称分区交换排序，是对冒泡排序算法的改进，是一种基于分组进行互换的排序方法。 2、快速排序的基本思想是：从待排记录序列中任取一个记录Ri作为基准（通常取序列中的第一个记录），将所有记录分成两个序列分组，使排在Ri之前的序列分组的记录关键字都小于等于基准记录的关键字值Ri.key，排在Ri之后的序列分组的记录关键字都大于Ri.key，形成以Ri为分界的两个分组，此时基准记录Ri的位置就是它的最终排序位置。此趟排序称为第一趟快速排序。然后分别对两个序列分组重复上述过程，直到所有记录排在相应的位置上。 在快速排序中，选取基准常用的方法有： （1）选取序列中第一个记录的关键字值作为基准关键字。这种选择方法简单。但是当序列中的记录已基本有序时，这种选择往往使两个序列分组的长度不均匀，不能改进排序的时间性能。 （2）选取序列中间位置记录的关键字值作为基准关键字。 （3）比较序列中始端、终端及中间位置上记录的关键字值，并取这三个值中居中的一个作为基准关键字。 通常取序列中的第一个记录作为关键字。 3、具体的算法描述如下： 算法中记录的比较和交换是从待排记录序列的两端向中间进行的

Day2 分治法——快速排序 十大经典算法总结 https://www.cnblogs.com/onepixel/articles/7674659 一、思想:分治，递归 序位，前后位置——下标 元素的值：关键字，数字的大小 分治：以一个关键字（key）为基准（basic）分割数据在前后两边，小于等于basic的在basic前，大于等于basic的在后 这个basic可以随便取，通常可以取左边界元素的值 多次分割，完成排序（可利用递归） 快速排序，效率很高。 图示说明 （和具体操作一起看，那里的一些结论直接画在图上了） 二、具体操作 （一）思路 Basic，分割后的数组左右边界lr（下标），动的标记i,j（下标） 一次分割： 一部分：找到两边“位置”不对的数，进行交换完成分割（先规定元素等于basic时，是“位置正确”。这样会有问题在这里先忽略不详细讨论） 做标记l从最左边向右移动，直到 i 所指的数大于basic的数时，说明他位置不对，需要交换，i停止右移。 再从右向左找小于basic，位置不对需要交换的数，即r开始从最右边向左移动，直到j所指的数小于basic停止。 此时，交换i,j当前所指的元素。 二部分： 多次进行上述移动&交换操作，遍历到所有元素 完成一次分割 。 运用递归法，将分割好的两部分各进行上述分割操作。 （二）思考 一部分 1.左右移动的循环： 循环条件

快速排序可以归结为“挖坑填坑法”。 首先选择一个基准值x（一般选择第一个值），然后用两个指针left指向左端，right指向右端。然后right向前移动，直到遇到nums[right]<x，便将此值赋值给nums[left]，然后将left向后移动，遇到大于x的值便放到right的位置，再移动right……直到left==right，最后将x填到相遇处。 这样便完成了小于x的在x左边，大于x的在x右边的排序。然后再分别对左侧和右侧的数组执行这个算法。 public void quickSort ( int [ ] nums , int left , int right ) { int i = left ; int j = right ; if ( i < j ) { int x = nums [ left ] ; while ( i < j ) { while ( i < j && nums [ j ] > x ) { j -- ; } if ( i < j ) { nums [ i ] = nums [ j ] ; i ++ ; } while ( i < j && nums [ i ] < x ) { i ++ ; } if ( i < j ) { nums [ j ] = nums [ i ] ; j -- ; } } nums [ i ] = x ; quickSort (

文章来源： http://blog.seclibs.com/算法之排序中-c语言实现/ 上一篇文章里说了归并排序和快速排序，它们的代码实现是非常相似的，只要理解了其中的具体实现，还是比较容易写出代码的。 归并排序 代码如下，需要下载代码的请移步至文末 快速排序 代码如下，需要下载代码的请移步至文末 代码： 归并排序： GitHub 快速排序： GitHub 文章首发公众号和个人博客 公众号：无心的梦呓（wuxinmengyi） 博客： http://blog.seclibs.com/ 来源： oschina 链接： https://my.oschina.net/u/3677719/blog/3163548

1.实现思路（参见百度百科） 设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。 一趟快速排序的算法是： 1）设置两个变量i、j，排序开始的时候：i=0，j=N-1； 2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]； 3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换； 4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换； 5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。 2.我的实现 #include <stdio.h> int sort(int i,int j,int *arr){ int k = i; while(i < j){ while(k < j){ //注意处理等值的情况，这里将等值置于大堆 if(*(arr+k) <= *(arr+j)