快速排序

public void quickSort(int[] arr, int left, int right){ 　　if(left>=right){ 　　　　return ; 　　} 　　int last = left; 　　for(int i=left+1;i<=right;i++){ 　　　　if(arr[i]<arr[left]){ 　　　　　　swap(arr, i, ++last); 　　　　} 　　} 　　swap(arr, left, last); 　　quickSort(arr, left, last-1); 　　quickSort(arr, last+1, right); } 来源： https://www.cnblogs.com/cbhe/p/12456290.html

1 #include <stdio.h> 2 3 int main(void) 4 { 5 int a[6] = {2,1,0,5,4,3}; 6 int i; 7 QuickSort(a,0,5);//第二个参数表示第一个元素的下标 第三个参数表示最后的元素的下标 8 9 for(i= 0 ;i<6;++i) 10 printf("%d",a[i]); 11 printf("\n"); 12 return 0; 13 } 14 15 void QuickSort(int *a , int low ,int high) 16 { 17 int pos; 18 if(low<high) 19 { 20 pos = FindPos(a,low,high); 21 QuickSort(a,low,pos-1); 22 QuickSort(a,pos+1,high); 23 } 24 } 25 26 int FindPos(int *a , int low , int high) 27 { 28 int val = a[low]; 29 while(low<high) 30 { 31 while(low<high && a[high]>=val ) 32 --high; 33 a[low] = a[high]; 34 while(low<high && a[low]<=val ) 35 +

import java.util.Arrays;public class quickSort { public static void main(String[] args) { int[] ary=new int[]{8,2,3,7,1,22,11,5,9,10,33}; go(ary,0,ary.length-1); System.out.println(Arrays.toString(ary)); } public static int getM(int[] ary,int low,int high){ int tm=ary[low]; while(low<high){ while(low<high && ary[high]>=tm){ high--; } ary[low]=ary[high]; while(low<high && ary[low]<tm){ low++; } ary[high]=ary[low]; } ary[low]=tm; //System.out.println(low); return low; } public static void go(int[] ary,int low,int high){ if(low<high){ int m=getM(ary,low,high); go(ary,low,m-1); go(ary,m+1,high); }

桶排序 原理 : 数组下标会自动排序 没有的部分用empty代替 function sort ( arr ) { var newArr = [ ] ; //定义一个新数组 //遍历数组 取出原数组的每一位 for ( var i = 0 ; i < arr . length ; i ++ ) { //把原数组的每一位的值当作新数组的下标 并随意赋值（数组下标会自动排序） newArr [ arr [ i ] ] = 1 ; } arr . length = 0 ; //清空原数组 //取出新数组的下标 for ( var key in newArr ) { arr . push ( + key ) ; //转换为数字再赋给原数组 } return arr ; //返回原数组 } 快速排序 原理 : 利用递归 找中点 分左右 function sort ( arr ) { //递归出口 if ( arr . length === 1 || arr . length === 0 ) { return arr ; } // 找中间下标和中间值 var mid_index = parseInt ( arr . length / 2 ) ; //中间下标 var mid_value = arr [ mid_index ] ; //中间值 var left = [ ] ; var right

最好时间复杂度O(nlogn) 最坏时间复杂度O(N^2) 方法一： 左右指针法： 1 /** 2 * 双指针法，将基准点设置为最左端 3 * 4 * @param arr 5 * @param left 6 * @param right 7 */ 8 public static void quicklySort(int[] arr, int left, int right) { 9 10 if (left >= right) { 11 return; 12 } 13 14 int base = arr[left]; 15 int i = left; 16 int j = right; 17 while (i < j) { 18 while (j > i && arr[j] >= base) { 19 j--; 20 } 21 while (j > i && arr[i] <= base) { 22 i++; 23 } 24 if (i < j) { 25 int temp = arr[i]; 26 arr[i] = arr[j]; 27 arr[j] = temp; 28 } 29 } 30 arr[left] = arr[i]; 31 arr[i] = base; 32 quicklySort(arr, left, i - 1); 33 quicklySort(arr, i +

快速排序的时间复杂度是O(NlogN) 算法描述 先从序列中取出一个数作为基准数 分区过程, 将比这个数大的数全部放到它的右边, 小于或等于它的数全部放到它的左边 再对左右区间重复第二步, 直到各区间只有一个数 假设对 6, 1, 2, 7, 9, 3, 4, 5, 10, 8 进行排序, 首先在这个序列中随便找一个基准数(用来参照), 比如选择 6 为基准数, 接下来把所有比基准数大的数放在6的右边, 比6小的数放在左边 原理分析: 选择最左边的数为基准数key 设立两个游标 low 和 high , 分别指向数组的最低位和最高位 然后high先动, 如果high位上的数比key大, 则向前走, 如果high-1位上的数比key大, 继续向前走, 直到该位上的数<=key 此时比较low位, 如果<=key, low向后走, 变为low+1, 依次类推, 直到该位上的数比key大 交换high和low位上的数 重复以上步骤, 直到low=high , 交换 key 和 high 位上的值 最后进行递归操作 #!/usr/bin/env python # coding:utf-8 # 设置最低位和最高位 def quickSort(nums, low, high): # 设置一个比较基准key key = nums[low] while low<high: # 如果最高位的数

文章摘自： 版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/Holmofy/article/details/71168530 快速排序使用的是分治思想，将原问题分成若干个子问题进行递归解决。通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 单轴快排（SinglePivotQuickSort） 单轴快速排序是快速排序最简单的实现。 步骤如下： 如果待排序的数组项数为0或1，直接返回。(递归出口) 在待排序的数组中任选一个元素，作为中心点(pivot)。 将小于pivot的元素，大于pivot的元素划分为开来。也就是将小于中心点的元素放在中心点前面，大于中心点的元素放在中心点后面。 对前面小于pivot的元素进行快速排序，对大于pivot的元素进行快速排序。 如何将大于pivot和小于pivot的元素进行划分是实现快速排序的关键 元素划分的方式 两端扫描交换方式 注意 ：i 与 j 必须交错，如果两者相遇之后就停止比较，那相遇点所在的元素就没有和中心点进行比较。 /** * 双端扫描交换 Double-End Scan and

快速排序(QuickSort) 划分的关键是要求出基准记录所在的位置pivotpos,编程时候的关键点 快速排序： 既然能把冒泡KO掉，马上就激起我们的兴趣，tnd快排咋这么快，一定要好好研究一下。 首先上图： 从图中我们可以看到： left指针，right指针，base参照数。 其实思想是蛮简单的，就是通过第一遍的遍历（让left和right指针重合）来找到数组的切割点。 第一步：首先我们从数组的left位置取出该数（20）作为基准（base）参照物。 第二步：从数组的right位置向前找，一直找到比（base）小的数， 如果找到，将此数赋给left位置（也就是将10赋给20）， 此时数组为：10，40，50，10，60， left和right指针分别为前后的10。 第三步：从数组的left位置向后找，一直找到比（base）大的数， 如果找到，将此数赋给right的位置（也就是40赋给10）， 此时数组为：10，40，50，40，60， left和right指针分别为前后的40。 第四步：重复“第二,第三“步骤，直到left和right指针重合， 最后将（base）插入到40的位置， 此时数组值为： 10，20，50，40，60，至此完成一次排序。 第五步：此时20已经潜入到数组的内部，20的左侧一组数都比20小，20的右侧作为一组数都比20大， 以20为切入点对左右两边数按照

1 交换排序基本思想 交换排序的基本思想是：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。 应用交换排序基本思想的主要排序方法有：冒泡排序（Bubble sort）和快速排序（Quick sort）。 2 冒泡排序 2.1 冒泡排序思想 第一趟排序：首先将第一个记录的关键字和第二个记录的关键字比较，若为逆序，则将两个记录交换之，然后比较第二个和第三个的关键字。以此类推，直至第n-1个记录和第n个记录关键字比较为止。该过程为第一趟排序，使得最大的关键字排到了最后面。第二趟排序：对前n-1个记录进行相同操作，完成后使得次大的关键字排在n-1位置上。以此类推，进行第三、四次排序直到排序结束。判断排序结束条件是：在一趟排序过程中没有发生过交换记录的操作。一般第i趟排序是从第1个元素到（n-i+1）个记录依次比较相邻两个记录关键字，并在逆序时交换记录。 总结便是：共比较多少趟，每趟比较多少次。一个两重循环。 2.2 冒泡排序算法实现 public static void bubbleSort(int a[]) { int lenth = a.length; int temp; //共比较lenth-1趟 for (int i = 0; i < lenth - 1; i++) { //每轮比较length-1-j次 for (int j = 0; j

快速排序的基本思想是基于分治策略的。对于输入的子序列ap..ar，如果规模足够小则直接进行排序，否则分三步处理： 分解(Divide)： 将输入的序列ap..ar划分成两个非空子序列ap..aq和aq+1..ar，使ap..aq中任一元素的值不大于aq+1..ar中任一元素的值。 递归求解(Conquer)： 通过递归对p..aq和aq+1..ar进行排序。 合并(Merge)： 由于对分解出的两个子序列的排序是就地进行的，所以在ap..aq和aq+1..ar都排好序后不需要执行任何计算ap..ar就已排好序。 这个解决流程是符合分治法的基本步骤的。因此，快速排序法是分治法的经典应用实例之一。 using System; namespace VcQuickSort { /// <summary> /// ClassQuickSort 快速排序。 /// </summary> public class QuickSort { public QuickSort() { } private void Swap(ref int i,ref int j) //swap two integer { int t; t=i; i=j; j=t; } public void Sort(int [] list,int low,int high) { if(high<=low) { //only one