快速排序

普通快速排序一次把数据划分成两部分，两部分再分别递归，两枢轴，就是两个结点，把数据划分成三部分，三部分再分别递归，可参考下图 left part center part right part + --------------------------------------------------------------+ | < pivot1 | pivot1 <= && <= pivot2 | > pivot2 | + --------------------------------------------------------------+ ^ ^ | | less great 1 2 3 4 5 6 7 8 划分成三部分： l e f t p a r t ： x < p 1 ， c e n t e r p a r t ： p 1 < = x < = p 2 ， r i g h t p a r t : x > p 2 leftpart：x<p1，centerpart：p1<=x<=p2，rightpart:x>p2 程序中给的下图 /* * Partitioning: * * left part center part right part * + --------------------------------------------------------------+

快速排序： 即一趟快速排序的过程，返回基准。基准：平分数据段 时间复杂度：好情况（无序的数据）：O（nlog2n） 坏（有序）：O（n2） 空间复杂度：O（log2n） 算法稳定性：不稳定 原理：采用分治思想，在待排序的序列中选取一个值作为一个基准值，按照这个基准值得大小将这个序列划分成两个子序列，基准值会在这两个子序列的中间，一边是比基准小的，另一边就是比基准大的。这样快速排序第一次排完，我们选取的这个基准值就会出现在它该出现的位置上。这就是快速排序的单趟算法，也就是完成了一次快速排序。然后再对这两个子序列按照同样的方法进行排序，直到只剩下一个元素或者没有元素的时候就停止，这时候所有的元素都出现在了该出现的位置上。 例：一趟排序（以6为基准） 0 1 2 3 4 5 arr[]: 6 2 7 3 8 9 low=0 high=5 tmp=6 6 2 7 3 8 9 low=0 high=3 tmp=6 arr[high]=3 < tmp=6 3 2 7 6 8 9 low=0 high=3 tmp=6 arr[low]=arr[high]3 3 2 7 6 8 9 low=2 high=3 tmp=6 arr[low]=7 > tmp=6 3 2 6 7 8 9 low=2 high=3 tmp=6 arr[high]=arr[low]7 6的位置已确定 //递归 int

起泡排序和快速排序都属于交换排序，时间复杂度均为O(n^2)，其中心思想是各数据之间的比较，然后交换其位置，以实现有序的操作。 void BubbleSort ( int data []) //起泡排序 { for ( int i = max - 1 ; i > 1 ; i --) for ( int j = 1 ; j < i ; j ++) { if ( data [ j ]> data [ j + 1 ]) //交换 { data [ 0 ]= data [ j ]; data [ j ]= data [ j + 1 ]; data [ j + 1 ]= data [ 0 ]; } } } 二.快速排序 快速排序比起泡排序更加常用，据说sort函数实际上就是用的快排（这点没验证过），应该说快排是几种排序方法里面比较稳定的算法。快排与起泡排序不同的是，它定义了一个枢轴，然后进行比较，关键字值小的放枢轴前面，大的放后面。再对枢轴的前面和后面数据分别进行同样方法的排序（也就是要递归了），最后直至全部有序。上代码： int QuickSort ( int data [], int low , int high ) //快速排序寻找枢轴并使枢轴左端小于枢轴值，右边大于枢轴值 { int key = low ; data [ 0 ]= data [ key ]; while ( low

分享一篇图文并茂的文章 http://blog.51cto.com/ahalei/1365285 快排： 1.数组划分 这一部分算法复杂度为o(n) 。 2.递归排序 在稍微好一点的情况下，每次划分一部分大小为十分之一，一部分大小为十分之九，这种情况下有递归公式： T (n ) ≤ T (9n /10) + T (n /10) + (n )= O (n lg n ) 在平均的情况下，当最好和最坏的情况依次发生时，最坏的情况对渐进时间上的影响不大，因此时间复杂度为o(nlgn)。 【代码】 #include<bits/stdc++.h> using namespace std; int a[101],n; void quicksort(int left,int right) { int i,j,t,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); //继续处理左边

自己是一个菜鸡，不懂技术。 第一次写博客不太懂，写得有点菜。 今天写一个自己对快速排序的理解吧！ 快速排序是非常重要的排序算法，基本是每一个面试都会问到问题；虽然有库函数可以直接调用，而且比我们写的快得多，但是这种基本算法，自己还是要懂得实现的。 快速排序算法关键在于先在数组中选择一个基准数，接下来把数组中的数字分为两部分，比基准数小的移到左边，大的移到右边，然后递归的去调用。 为了避免出现基准值出现极端现象，比如说最大值或者最小值，这样浪费了排序的时间，我们可以选择有效的保障方案，比如说同random函数，或者其他方案，我在这里采用3数取中的方法。 #include<iostream> using namespace std; //swap函数，交换数组两个值。 void swap(int *a,int *b){ int t; t = *a;*a=*b;*b=t; } //采用取头中尾3个数的中间数作为基准数 int median3(int a[],int l,int r){ int cen = (l+r)/2; if(a[l]>a[cen]) swap(&a[l],&a[cen]); if(a[l]>a[r]) swap(&a[l],&a[r]); if(a[cen]>a[r]) swap(&a[cen],&a[r]); swap(&a[cen],&a[r]); return

快速排序中的一种，用C语言实现。 #include <stdio.h> #include <stdlib.h> int main () { int a [ 6 ] = {- 2 , 1 , 0 ,- 500 , 4 ,- 3 }; QuickSort ( a , 0 , 5 ); int i ; for ( i = 0 ; i < 6 ; i ++){ printf ( "%d " , a [ i ]); printf ( "\n" ); } return 0 ; } void QuickSort ( int * a , int low , int high ){ int pos ; if ( low < high ){ pos = FindPos ( a , low , high ); QuickSort ( a , low , pos - 1 ); //递归 QuickSort ( a , pos + 1 , high ); //这个弄一遍只能弄得一个函数的值 } } int FindPos ( int * a , int low , int high ){ int val = a [ low ]; while ( low < high ){ while ( low < high && a [ high ]>= val ){ high --; } a [ low ] = a [

快速排序（英文名：Quicksort，有时候也叫做划分交换排序）是一个高效的排序算法，由Tony Hoare在1959年发明（1961年公布）。当情况良好时，它可以比主要竞争对手的归并排序和堆排序快上大约两三倍。这是一个分治算法 ，而且它就在 原地排序 。 优点： 会比一般的排序方法更节省时间 下面的代码是一种实现： //快速排序 void quick_sort(int s[], int l, int r) { if (l < r) { //Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1 int i = l, j = r, x = s[l]; while (i < j) { while(i < j && s[j] >= x) // 从右向左找第一个小于x的数 j--; if(i < j) s[i++] = s[j]; while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数 i++; if(i < j) s[j--] = s[i]; } s[i] = x; quick_sort(s, l, i - 1); // 递归调用 quick_sort(s, i + 1, r); } } 1 文章来源: 快速排序算法是什么

#快速排序 快速排序是及其常见的算法面试题目，很多算法题都用到了快排的思想，所以需要熟练掌握算法。 快速排序属于交换排序，两两交换数组中元素的位置以实现排序，属于不稳定排序。 时间复杂度 空间复杂度 平均情况O(nlogn) O(nlogn) 最好情况O(nlogn) 最坏情况O(n^2) java代码实现 public static int partition ( int [] nums , int left , int right ) { int tmp = nums [ right ]; //选最后一个元素作为哨兵 while ( left < right ) { while ( left < right && nums [ left ] <= tmp ) { ++ left ; } nums [ right ] = nums [ left ]; while ( left < right && nums [ right ] >= tmp ) { -- right ; } nums [ left ] = nums [ right ]; } nums [ left ] = tmp ; //元素nums[left]放置到最终位置 return left ; //返回元素索引 } public static void quickSort ( int [] nums ) { if (

快速排序是基于分治策略的另一种排序算法，其基本思想是，对于输入的子数组a[p:r]，按照以下3个步骤进行排序。 private static void qSort(int p,int r) { if(p<r) { int q = partition(p,r); qSort(p,q-1);//对左半段排序 qSort(q+1,r);//对右半段排序 } } private static int partition(int p,int r) { int i = p; int j = r + 1; Comparable x = a[p]; //将<x的元素交换到左边区域 //将>x的元素交换到右边区域 while(true) { while(a[++i].compareTo(x)<0&&i<r); while(a[--j].compareTo(x)>0)； if(i>=j) break; MyMath.swap(a,i,j); } a[p]=a[j]; a[j]=x; return j; } 来源：博客园 作者： 王陆 链接：https://www.cnblogs.com/wkfvawl/p/11517280.html

package com.atguigu.array.sort; /** * 快速排序 * 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小， * 则分别对这两部分继续进行排序，直到整个序列有序。 * @author shkstart * 2018-12-17 */ public class QuickSort { private static void swap(int[] data, int i, int j) { int temp = data[i]; data[i] = data[j]; data[j] = temp; } private static void subSort(int[] data, int start, int end) { if (start < end) { int base = data[start]; int low = start; int high = end + 1; while (true) { while (low < end && data[++low] - base <= 0) ; while (high > start && data[--high] - base >= 0) ; if (low < high) { swap(data, low, high); } else { break; }