快速排序

template<class Iter> void quick_sort(Iter begin, Iter end) { int sz = (int)distance(begin, end); if (sz < 2) return; //保存现场； Iter b = begin ; Iter e = end; int tmp = *begin; while (b < e) { while (*--e > tmp); while (b < e && *++b < tmp); if (b < e) iter_swap(b, e); } iter_swap(begin, e); quick_sort(begin, e); quick_sort(e + 1, end); } 第一，等于的时候进不进行交换。 需要进行交换，理由就是尽量使得被target被交换到数组的中央； 问题就出现了，如何保证等于的时候，不会发生死循环； 第二，从头遍历还是从后遍历。 从后遍历，因为第一点等于的时候也要进行交换，所以向后遍历最差情况也只是到第一个元素的时候停止，此时遍历的过程中是不需要加上while(i < j)的判断的； 第三，循环外与begin交换的是b，还是e。 这里是e，注意主要经过while (b < e)循环，e最后的位置一定保证是*begin最终的位置。 第四，可以将第三个while的b <

1.原理 1.从待排序区间选择一个数,作为基准值(pivot); 2.partition(分割): 遍历整个待排序区间, 将比基准值小的(可包含相等的)放到基准值的左边, 将比基准值大的(可包含相等的)放到基准值的右边; 3.采用分治的思想, 对左右两个小区间按照同样的方式处理, 直到小区间的长度==1, 代表已经有序, 或者小区间的长度等于0, 代表没有数据. 2.代码实现 import java.util.*; public class quickSort{ public static void quickSort(int[] array){ quickSortInternal(array, 0, array.length-1); } private static void quickSortInternal(int[] array, int left, int right){ //快排核心 if(left == right){ return; } if(left > right){ return; } int pivotIndex = partition(array, left, right); //pivotIndex 代表基准值最终停留的下标 quickSortInternal(array, left, pivotIndex - 1); //[left,

快速排序 快速排序使用 分治法 （Divide and conquer）策略来把一个 序列 （list）分为2个子序列，然后递归地排序两个子序列。 快速排序是一个不稳定的算法，在经过排序之后，可能会对相同值的元素的相对位置造成改变。 快速排序的最坏运行情况是 O(n²)，比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn)，且 O(nlogn) 记号中隐含的常数因子很小，比复杂度稳定等于 O(nlogn) 的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。 快速排序只是使用数组原本的空间进行排序，所以所占用的空间应该是常量级的，但是由于每次划分之后是递归调用，所以递归调用在运行的过程中会消耗一定的空间，在一般情况下的 空间复杂度 为 O(logn) ，在最差的情况下，若每次只完成了一个元素，那么空间复杂度为 O(n) 。所以我们一般认为快速排序的空间复杂度为 O(logn) 。 方法一：遍历交换法。 取一个key元素，我一般取数组的最后一个元素。定义一个指针index从头向后遍历，再定义一个指针位pre于第一个元素之前。如果index元素比key小，pre向前移动一位，交换index和key的元素，把小的放前、大的放后。index遍历到最后，将pre+1和key进行交换，这样比key小的都在它前面，比key大的都在它后面了

partition（）时间复杂度为O（n），quicksort的划分速度为O(logn),快排的排序时间改进主要取决于递归的深度，也即划分的平均程度，主要受：1.元素重复个数；2.元素的有序程度。 元素过多重复时：试想有10000个元素，取值范围为（1，10），在划分时划分后的两段在总体上都会有较大的悬殊，影响着排序时间，两路归并把重复元素分到段，而三路归并把重复元素单独保留到中间一段 元素基本有序时，需要随机地取划分元素，否则快排时间复杂度会退化到O(n^2)，这是因为此时递归地深度接近n 在r-l比较小时，已有较多元素在其排序后应在的位置上，数据元素基本有序了，此时采用插入排序可以进一步加快排序速度:插入排序在基本有序的条件下，有较好的表现，时间复杂度近似O(n) 来源： https://www.cnblogs.com/teipiper/p/12244165.html

快速排序基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 如序列[6，8，1，4，3，9]，选择6作为基准数。从右向左扫描，寻找比基准数小的数字为3，交换6和3的位置，[3，8，1，4，6，9]，接着从左向右扫描，寻找比基准数大的数字为8，交换6和8的位置，[3，6，1，4，8，9]。重复上述过程，直到基准数左边的数字都比其小，右边的数字都比其大。然后分别对基准数左边和右边的序列递归进行上述方法。 实现代码如下： 1 def parttion(v, left, right): 2 key = v[left] 3 low = left 4 high = right 5 while low < high: 6 while (low < high) and (v[high] >= key): 7 high -= 1 8 v[low] = v[high] 9 while (low < high) and (v[low] <= key): 10 low += 1 11 v[high] = v[low] 12 v[low] = key 13 return low 14 def quicksort(v, left, right):

一、快速排序（Quicksort）思想 设要排序的数组是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-完成的时候，此时令循环结束）。 二、算法实现 （1）递归算法 public static void quickSort(int[] data, int low, int high) { //无需排序

#include<stdio.h> #include<algorithm> using namespace std; int a[100]; void quicksort(int left,int right) { int i,j,temp; if(left>right) return; temp=a[left]; i=left,j=right; while(i!=j) { while(a[j]>=temp && i<j) j--; while(a[i]<=temp && i<j) i++; if(i<j) swap(a[i],a[j]); } a[left]=a[i]; a[i]=temp; quicksort(left,i-1); quicksort(i+1,right); } int main() { int n; scanf("%d",&n); for(int i=0; i<n; i++) scanf("%d",&a[i]); quicksort(0,n-1); for(int i=0; i<n; i++) printf("%d ",a[i]); printf("\n"); return 0; } 来源： CSDN 作者： 相似的人适合打闹 链接： https://blog.csdn.net/AYSXY/article/details/103112478

转自：https://www.cnblogs.com/AlwinXu/p/5424905.html 快速排序（quickSort） 快排的思想：首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。 百度百科给的算法： 一趟快速排序的算法是： 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-完成的时候，此时令循环结束）。 时间复杂度：O(nlgn) #QuickSort by Alvin def QuickSort(myList,start,end): #判断low是否小于high,如果为false

快速排序 时间复杂度： O(N * log2 N) 最坏情况下： O (N ^ 2） 空间复杂度： O(log2 N) 代码示例： （1）递归实现快速排序 public static void quickSort ( int [ ] array ) { quick ( array , 0 , array . length - 1 ) ; } public static void quick ( int [ ] array , int low , int high ) { int par = partion ( array , low , high ) ; if ( par > low + 1 ) { quick ( array , low , par - 1 ) ; } if ( par < high - 1 ) { quick ( array , par + 1 , high ) ; } } //找基准 public static int partion ( int [ ] array , int low , int high ) { int tmp = array [ low ] ; while ( low < high ) { while ( low < high && array [ high ] >= tmp ) { high -- ; } if ( low >=

javascript中实现一个链表的快速排序 class Node { constructor (value) { this.val = value this.next = undefined } } class NodeList { constructor (arr) { let head = new Node(arr.shift()) let next = head arr.forEach(item => { next.next = new Node(item) next = next.next }) return head } } let swap = (p, q) => { let val = p.val p.val = q.val q.val = val } let partion = (begin, end) => { let val = begin.val let p = begin let q = begin.next while (q !== end) { if (q.val < val) { p = p.next swap(p, q) } q = q.next } // 让基准元素跑到中间去 swap(p, begin) return p } export default function sort (begin, end) { if (begin !==