快速排序

快速排序

穿精又带淫゛_ 提交于 2020-01-17 05:14:53
快速排序 时间复杂度分析: 快速排序的一次划分算法从两头交替搜索,直到low和high重合,因此其时间复杂度是O(n),而 整个 快速排序算法的实际复杂度与 划分的趟数 有关。 理想情况 :每次划分所选择的关键字key,恰好将当前序列几乎等分,经过 log ⁡ 2 n \log_2^n lo g 2 n ​ 趟划分,便可得到长度为1的子表。这样,整个算法的时间复杂度为 O ( n log ⁡ 2 n ) O(n\log_2^n) O ( n lo g 2 n ​ ) 。 最坏情况 :每次所选的中间数是当前序列中的最大或最小元素,这使得每次划分所得的子表中一个为空表,另一子表的长度为原表的长度-1。这样,长度为n的数据表的快速排序需要经过n趟划分,使得整个排序算法的时间复杂度为 O ( n 2 ) O(n^2) O ( n 2 ) 。 代码如下: # include <stdio.h> # include <stdlib.h> # define N 1000000 int a [ N ] ; int Partition ( int b [ ] , int low , int high ) { int key ; //划分点 key = b [ low ] ; while ( low < high ) { while ( low < high && b [ high ] >= key

快速排序

ε祈祈猫儿з 提交于 2020-01-16 15:03:22
快速排序(Quicksort)是对 冒泡排序 的一种改进。 快速排序由C. A. R. Hoare在1960年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以 递归 进行,以此达到整个数据变成有序 序列 。 public static void quickSort(int arr[] , int low , int high){ /** * i为指向最左边的第一个元素,j为最右边的第一个元素 , temp为基准元素 ,t为交换元素 */ int i , j , temp , t; if (low>high){ return; } i = low; j = high; temp = arr[low]; while(i<j){ while (temp<=arr[j]&&i<j){ j--; } while (temp>=arr[i]&&i<j){ i++; } //交换两个元素 if(i<j){ t = arr[j]; arr[j] = arr[i]; arr[i] = t; } } arr[low] = arr[i]; arr[i] = temp; //递归左边 quickSort(arr , low , j-1); //递归右边 quickSort

算法五:快速排序

自作多情 提交于 2020-01-16 14:58:35
快速排序是对冒泡排序的一种改进。思想:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小, 然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序。 选择一个基准数,这个数的左边都比她小,右边的都比它大,然后再递归处理左右两边的操作直到左右的各区只有一个数 数组: 3,2,1,6,9 #include <iostream> using namespace std; void Qsort(int a[], int low, int high) { if (low >= high) return; int frist = low; int last = high; int key = a[frist]; while (frist < last) { while (frist < last &&a[last] > key) --last; a[frist] = a[last]; while (frist < last && a[frist] < key) ++frist; a[last] = a[frist]; } a[frist] = key; Qsort(a, low, frist); Qsort(a, frist + 1,high); } int main() { int a[] = {3,1

排序(冒泡排序、快速排序)

て烟熏妆下的殇ゞ 提交于 2020-01-16 14:56:44
基本排序分类图: 关于排序的稳定性 在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中r[i]=r[j],且r[i]在r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排序算法是稳定的;否则称为不稳定的。 一、 冒泡排序 冒泡排序的基本思想:每次比较两个 相邻 的元素,如果它们的顺序错误就把他们交换过来 冒泡排序的原理:每一趟只能确定将一个数归位,如果有n个数进行排序,只需将n-1个数归位,也就是说要进行n-1趟操作,而每一趟都需要从第1位开始进行相邻两个数的比较 1 #include <stdio.h> 2 #define MAX 7 3 4 int main(void) 5 { 6 int i, j, t; 7 int a[MAX] = {1, 5, 3, 7, 6, 4, 2}; 8 9 //冒泡排序核心部分 10 for (i = 0; i < MAX - 1; i++) //n个数排序只需要n-1趟 11 { 12 for (j = 0;j < MAX - i; j++) //每一趟比较到n-i结束 13 { 14 if (a[j] < a[j + 1])//降序排列 15 { 16 t = a[j]; 17 a[j] = a[j + 1]; 18 a[j + 1] = t; 19 20 } 21

快速排序(详解)

Deadly 提交于 2020-01-16 14:37:49
描述: 通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以 递归 进行,以此达到整个数据变成有序 序列 。 快速排序 的平均时间复杂度为O(NlogN),是冒泡排序的一种改进版。 方法:快速排序主要采用“二分”的思想,步骤如下: 1) 设置两个变量i、j, 排序 开始的时候:i=0,j=n-1; 2)第一个数组值作为比较值,首先保存到temp中,即temp=A[0]; 3)然后j-- ,向前搜索,找到小于temp后,因为s[i]的值保存在temp中,所以直接赋值,s[i]=s[j] 4)然后i++,向后搜索,找到大于temp后,因为s[j]的值保存在第2步的s[i]中,所以直接赋值,s[j]=s[i],然后j--,避免死循环 5)重复第3、4步,直到i=j,最后将temp值返回s[i]中 6) 然后采用“二分”的思想,以i为分界线,拆分成两个数组 s[0,i-1]、s[i+1,n-1]又开始排序 如下图,以数组 6 4 7 1 2为例: 代码如下: #include "stdio.h" void find_frst(int *s,int left,int right) { int i=left,j=right,temp; //(1)初始化i、j if(left>=right

C#之快速排序

不打扰是莪最后的温柔 提交于 2020-01-16 14:08:18
快速排序(Quicksort)是对冒泡排序的一种改进。 快速排序的基本概念是 : 通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小, 然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以 递归 进行,以此达到整个数据变成有序序列。 下面通过一个例子来了解快速排序的具体含义: { 23, 45, 60, 10, 17, 101,12} 第一遍排序: 由此思想,我们可以实现快速排序的代码: 注意基准数据永远不变,永远是和基准数据进行比较,无论在什么位置,最后的目的就是把基准数据放在中间,小的放前面大的放后面。 namespace QuickSort { class QuickSort { private int Func(int[] n, int left, int right) { int baseNum = n[left]; // 基准数据 int i = left; int j = right; while (true) { if (n[i] < baseNum && i < j) { i++; } else if (n[i] > baseNum && i < j) { int number = n[i]; n[i] = n[j]; n[j] = number; j--; } else if (n[j] < baseNum

排序二 快速排序

孤者浪人 提交于 2020-01-16 11:31:44
目录 要点 算法分析   快速排序算法的性能   时间复杂度   空间复杂度   算法稳定性 完整参考代码   JAVA版本 参考资料 相关阅读 要点 快速排序是一种 交换排序 。 快速排序由C. A. R. Hoare在1962年提出。 它的基本思想是:通过一趟排序将要排序的数据 分割 成独立的两部分: 分割点左边都是比它小的数,右边都是比它大的数 。 然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。 详细的图解往往比大堆的文字更有说明力,所以直接上图: 上图中,演示了快速排序的处理过程: 初始状态 为一组无序的数组:2、4、5、1、3。 经过以上操作步骤后,完成了 第一次的排序 ,得到新的数组:1、2、5、4、3。 新的数组中,以2为分割点,左边都是比2小的数,右边都是比2大的数。 因为2已经在数组中找到了合适的位置,所以不用再动。 2左边的数组只有一个元素1,所以显然不用再排序,位置也被确定。(注:这种情况时,left指针和right指针显然是重合的。因此在代码中,我们可以通过设置判定条件 left 必须小于right ,如果不满足,则不用排序了 )。 而对于2右边的数组5、4、3,设置left指向5,right指向3,开始继续 重复图中的一、二、三、四步骤 ,对新的数组进行排序。 核心代码 public int

常用的十大排序算法,经典图解版,『精』!!!

倾然丶 夕夏残阳落幕 提交于 2020-01-16 08:33:26
前言 本文或许是东半球分析十大排序算法最好的一篇文章,配有 70 张图片和动画,和你一起一步步看懂排序算法的运行过程。 预计阅读时间 47 分钟,强烈建议先收藏然后通过电脑端进行阅读。 No.1 冒泡排序 冒泡排序无疑是最为出名的排序算法之一,从序列的一端开始往另一端冒泡(你可以从左往右冒泡,也可以从右往左冒泡,看心情),依次比较相邻的两个数的大小(到底是比大还是比小也看你心情)。 冒泡排序动图演示 图解冒泡排序 以 [ 8,2,5,9,7 ] 这组数字来做示例,上图来战: 从左往右依次冒泡,将小的往右移动 冒泡排序1 首先比较第一个数和第二个数的大小,我们发现 2 比 8 要小,那么保持原位,不做改动。位置还是 8,2,5,9,7 。 指针往右移动一格,接着比较: 冒泡排序2 比较第二个数和第三个数的大小,发现 2 比 5 要小,所以位置交换,交换后数组更新为:[ 8,5,2,9,7 ]。 指针再往右移动一格,继续比较: 冒泡排序3 比较第三个数和第四个数的大小,发现 2 比 9 要小,所以位置交换,交换后数组更新为:[ 8,5,9,2,7 ] 同样,指针再往右移动,继续比较: 冒泡排序4 比较第 4 个数和第 5 个数的大小,发现 2 比 7 要小,所以位置交换,交换后数组更新为:[ 8,5,9,7,2 ] 下一步,指针再往右移动,发现已经到底了,则本轮冒泡结束,处于最右边的

快速排序算法

☆樱花仙子☆ 提交于 2020-01-16 07:50:13
这个算法比较妙的地方在于有左右两个针指向左右两边断点,初始化数组的第一个值为【坑】,左指针和右指针分别和坑这个值对比,比坑小的给放在坑的左边,左指针右移,比坑大的放在右面,右指针左移,当左右指针见面的时候,循环结束,此时循环到这个索引就是这个数在这个数组中应该所处的位置。 1,2,3,4,5,6,7,8,9,10 从一个有序数组中来看,任何一个数都是比它们左边数字大,比它们右边数字小的这个规律 所以我们可以将一个无序的数不断地寻找它们合适的位置去给它进行变动 然后将其一分为二使用分治思想将其继续递归排序,逐渐缩小问题 //快速排序 public static void quickSort ( int [ ] arr , int left , int right ) { if ( left < right ) { int l = left ; int r = right ; int x = arr [ left ] ; while ( l < r ) { while ( l < r && arr [ r ] >= x ) r -- ; if ( l < r ) { arr [ l ++ ] = arr [ r ] ; } while ( l < r && arr [ l ] < x ) l ++ ; if ( l < r ) { arr [ r -- ] = arr [ l ] ;

1045.快速排序 (25分)

核能气质少年 提交于 2020-01-16 03:20:26
著名的快速排序算法里有一个经典的划分过程:我们通常采用某种方法取一个元素作为主元,通过交换,把比主元小的元素放到它的左边,比主元大的元素放到它的右边。 给定划分后的 N 个互不相同的正整数的排列,请问有多少个元素可能是划分前选取的主元? 例如给定 N = 5 N = 5 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 # include <iostream> # include <vector> using namespace std ; int main ( ) { int n , max = 0 ; cin >> n ; vector < int > m ( n