快速排序

我目前最常用的两种排序：冒泡排序和快速排序 比较一下他们的性能： 1 #include<stdio.h> 2 3 void QuickSort(int * a,int left,int right) 4 { 5 if(left>right) 6 { 7 return; 8 } 9 int stand=a[left]; 10 int i=left; 11 int j=right; 12 //得到基准数位置 13 while(i!=j) 14 { 15 while(i<j&&a[j]>=stand) 16 { 17 --j; 18 } 19 while(i<j&&a[i]<=stand) 20 { 21 ++i; 22 } 23 if(i<j) 24 { 25 int temp=a[i]; 26 a[i]=a[j]; 27 a[j]=temp; 28 } 29 } 30 //将基准数放入找出的位置 31 a[left]=a[i]; 32 a[i]=stand; 33 //递归处理 34 QuickSort(a,left,i-1); 35 QuickSort(a,i+1,right); 36 return; 37 } 38 39 void BubbleSort(int * a,int n) 40 { 41 for(int i=0;i<n-1;i++) 42 { 43 for(int j

冒泡和递归一样，不管大家水平怎么样，基本上都能凑合的写写，快速排序其实主要的也是数据的交换，都算是交换排序，不过快排需要了解分治思想，实现的时候需要递归一下，导致很多时候看快排的时候都看的云里雾里。假设有一个无序的整型数组 索引 0 1 2 3 4 5 6 数值 15 32 8 99 12 17 36， ①取出0位的15作为基准值，然后倒序从后往前找小于15的，将12赋值给0位； ②从前往后找大于15的将32放置到位置4； ③位置1空出来，然后继续倒序找小于15的，正序找大于15的，最后索引到大3的时候重复以上过程。 冒泡排序 冒泡基本上没有什么好说的，直接看代码吧，新建了Sort类处理排序: // // Sort.h // Algorithm //http://www.cnblogs.com/xiaofeixiang // Created by keso on 15/3/15. // Copyright (c) 2015年 keso. All rights reserved. // #import <Foundation/Foundation.h> @interface Sort : NSObject @property (nonatomic,strong)NSMutableArray *dataSource; -(void)bubbleSort:(NSMutableArray*

首先我们要理解一下快速排序的原理： 找到当前数组中的任意一个元素（一般选择第一个元素），作为标准，新建两个空数组，遍历整个数组元素， 如果遍历到的元素比当前的元素要小，那么就放到左边的数组，否则放到右面的数组，然后再对新数组进行同样的操作， 不难发现，这里符合递归的原理，所以我们可以用递归来实现。 使用递归，则需要找到递归点和递归出口： 递归点：如果数组的元素大于1，就需要再进行分解，所以我们的递归点就是新构造的数组元素个数大于1 递归出口：我们什么时候不需要再对新数组不进行排序了呢？就是当数组元素个数变成1的时候，所以这就是我们的出口。 理解了原理，来看一下代码实现~ <?php //快速排序 //待排序数组 $arr=array(6,3,8,6,4,2,9,5,1); //函数实现快速排序 function quick_sort($arr) { //判断参数是否是一个数组 if(!is_array($arr)) return false; //递归出口:数组长度为1，直接返回数组 $length=count($arr); if($length<=1) return $arr; //数组元素有多个,则定义两个空数组 $left=$right=array(); //使用for循环进行遍历，把第一个元素当做比较的对象 for($i=1;$i<$length;$i++) { /

冒泡和快速排序都属于交换类排序，所谓交换排序是指借助数据元素之间互相交换进行排序的方法。 冒泡排序法 冒泡排序法是一种最简单的交换类排序方法，它是通过相邻数据的交换逐步将线性表变成有序。 冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。 即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。 在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的）， 第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。 由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。 参考： http://baike.baidu.com/view/254413.htm 图来自： http://www.cppblog.com/guogangj/archive/2009/11/13/100876.html Go 语言实现 fund BubbleSort(values[]int){ flag:=true

P1045 快速排序 转跳点： 🐏 1045 快速排序 (25分) 著名的快速排序算法里有一个经典的划分过程：我们通常采用某种方法取一个元素作为主元，通过交换，把比主元小的元素放到它的左边，比主元大的元素放到它的右边。 给定划分后的 N 个互不相同的正整数的排列，请问有多少个元素可能是划分前选取的主元？ 例如给定 $N = 5$, 排列是1、3、2、4、5。则： 1 的左边没有元素，右边的元素都比它大，所以它可能是主元； 尽管 3 的左边元素都比它小，但其右边的 2 比它小，所以它不能是主元； 尽管 2 的右边元素都比它大，但其左边的 3 比它大，所以它不能是主元； 类似原因，4 和 5 都可能是主元。 因此，有 3 个元素可能是主元。 输入格式： 输入在第 1 行中给出一个正整数 N （≤10​5​​）； 第 2 行是空格分隔的 N 个不同的正整数，每个数不超过 10​9​​。 输出格式： 在第 1 行中输出有可能是主元的元素个数；在第 2 行中按递增顺序输出这些元素，其间以 1 个空格分隔，行首尾不得有多余空格。 输入样例： 5 1 3 2 4 5 输出样例： 3 1 4 5 这道题实现起来并不难，但是吧，时间复杂度的控制是一个很麻烦的事情。 我AC的思路如下： 对原序列sort排序，逐个比较，若当前元素没有变化并且它左边的所有值的最大值都比它小的时候就可以认为它一定是主元

算法归类 简单排序：插入排序、选择排序、冒泡排序（必学） 分治排序：快速排序、归并排序（必学） 分配排序：桶排序、基数排序 树状排序：堆排序（必学） 其他：计数排序（必学）、希尔排序 快速排序 原理：核心思想是通过一个支点进行数据拆分，左边的数据小于这个支点，右边的数据大于支点，然后把左边和右边的做一次递归，直到递归结束。 phpcode实现 $data = array ( 2 , 1 , 3 , 9 , 4 , 6 , 5 , 8 , 7 ) ; $dataNum = count ( $data ) ; $leftIndex = 0 ; $rightIndex = $dataNum - 1 ; quickSort ( $data , $leftIndex , $rightIndex ) ; print_r ( $data ) ; function quickSort ( & $data , $leftIndex , $rightIndex ) { $i = $leftIndex ; $j = $rightIndex ; $pivot = $data [ floor ( ( $leftIndex + $rightIndex ) / 2 ) ] ; while ( $i <= $j ) { while ( $data [ $i ] < $pivot ) { $i ++ ; }

快速排序 以整个数组为对象执行quickSort quickSort流程如下 2.1 通过分割将对象局部数组分割为前后两个局部数组。 2.2 对前半部分数组执行quickSort。 2.3 对后半部分数组执行quickSort。 分割 如下图，数组A的分割范围为p ~ r（包含p和r）。这里分割的基准(即A[r]，数组的最后一个元素)为x。接下来移动A中的元素，将小于等于 x 的元素移到p ~ i的范围内(包含 i),大于 x 的元素移到i+1 ~ j 的范围内(不包含 j)。其中i初始化为p-1，j初始化为p。 当A[j]>X时不必移动元素，j直接向前移动，A[j]自动归入i+1 ~ j的组。 当A[j]≦X时，先让i 向前移动一个位置，然后交换A[j]和A[i]。这样A[j]就归入p ~ i 的组，随着j向后移动，原本位于A[j]的元素又会被归入 i+1 ~ j的组。 当j和r相遇时，分割结束，将A[i+1]和A[r] 交换，然后X左面的数组都小于等于X，右面的数组都大于X。 代码： public static void partition ( int [ ] a , int p , int r ) { int x , i , j , temp ; x = a [ r ] ; i = p - 1 ; for ( j = p ; j < r ; j ++ ) { if ( a [

时间复杂度O（nlogn） 找一个基数，使得这个基数的左边都比它小，右边都比它大。 双指针实现，从左边找找到第一个比基数大下标为i， 从右边找到第一个比基数小的数下标为j，i、j交换。 i == j 时将基数与a[i]交换，分治继续对(l , i-1) 与（i+1 , r）区间进行排序。 //#include <bits/stdc++.h> #include <cstdio> #include <cstring> #include <cmath> #include <algorithm> #include <iostream> #include <cstdio> #include <string> #include <stdio.h> #include <queue> #include <stack> #include <map> #include <set> #include <string.h> #include <vector> #define ME(x , y) memset(x , y , sizeof(x)) #define SC scanf #define rep(i ,j , n) for(int i = j ; i < n ; i ++) #define INF 0x3f3f3f3f #define mod 1000000007 #define PI acos(

void qsort ( void * base , int nelem , unsigned int width , int ( * mycompare ) ( const void * , const void * ) ) ; base:待排序数组的起始地址； nelem:待排序数组的元素个数； width:待排序数组的每个元素的大小（sizeof（T） （T代表变量名，如int,double,等）） 最后就是自定义的比较函数了。 排序就是一个不断比较并交换位置的过程。qsort函数在执行期间通过*mycompare指针调用比较函数，调用时将要比较的两个元素的地址传给比较函数，然后根据比较函数的返回值判断这两个元素哪个更应该排在前面。 int 比较函数名(const void e1,const void e2); 比较函数的编写规则： 1.如果 e1应该在 e2前面，返回值应该为负整数； 2.如果 e1应该在 e2后面，返回值应该为正整数； 3.如果 e1与 e2谁在前谁在后都可，那么函数返回值应该为0。 举个例子：将23，47，134，9，435这几个数，按个位数从小到大排序。 # include <iostream> # include <cstdio> # include <cstring> # include <cmath> # include <ctype.h> #

快速排序 算法步骤 找一个基准值，将这个基准值放在正确的位置上，也就是左边的都比它小，右边都比它大，至于左右两边的顺序先不管。 此时数列已经被分为了两个部分，再在左右两边重复第一步，直到数列的顺序被排好。 动图演示 代码实现 def quick_sort ( ls , left , right ) : if left > right : #递归停止的条件 return cur = ls [ left ] low = left high = right while low < high : if ls [ high ] >= cur : high -= 1 else : ls [ low ] = ls [ high ] while low < high and ls [ low ] <= cur : low += 1 ls [ high ] = ls [ low ] ls [ low ] = cur quick_sort ( ls , left , low - 1 ) quick_sort ( ls , low + 1 , right ) ls = [ 63 , 23 , 23 , 67 , 78 , 45 , 23 , 89 , 10 , 19 , 91 , 68 , 10 , 10 , 23 , 100 , 89 , 98 ] quick_sort ( ls , 0 , len