• 关于

    堆排序

    的搜索结果

回答

1、 堆排序定义 n个关键字序列Kl,K2,…,Kn称为堆,当且仅当该序列满足如下性质(简称为堆性质): (1) ki≤K2i且ki≤K2i+1 或(2)Ki≥K2i且ki≥K2i+1(1≤i≤ ) 若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构,则堆实质上是满足如下性质的完全二叉树:树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。 【例】关键字序列(10,15,56,25,30,70)和(70,56,30,25,15,10)分别满足堆性质(1)和(2),故它们均是堆,其对应的完全二叉树分别如小根堆示例和大根堆示例所示。 2、大根堆和小根堆 根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最小者的堆称为小根堆。 根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最大者,称为大根堆。 注意: ①堆中任一子树亦是堆。 ②以上讨论的堆实际上是二叉堆(Binary Heap),类似地可定义k叉堆。 3、堆排序特点 堆排序(HeapSort)是一树形选择排序。 堆排序的特点是:在排序过程中,将R[l..n]看成是一棵完全二叉树的顺序存储结构,利用完全二叉树中双亲结点和孩子结点之间的内在关系【参见二叉树的顺序存储结构】,在当前无序区中选择关键字最大(或最小)的记录。 4、堆排序与直接插入排序的区别 直接选择排序中,为了从R[1..n]中选出关键字最小的记录,必须进行n-1次比较,然后在R[2..n]中选出关键字最小的记录,又需要做n-2次比较。事实上,后面的n-2次比较中,有许多比较可能在前面的n-1次比较中已经做过,但由于前一趟排序时未保留这些比较结果,所以后一趟排序时又重复执行了这些比较操作。 堆排序可通过树形结构保存部分比较结果,可减少比较次数。 5、堆排序 堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征,使得在当前无序区中选取最大(或最小)关键字的记录变得简单。 (1)用大根堆排序的基本思想 ① 先将初始文件R[1..n]建成一个大根堆,此堆为初始的无序区 ② 再将关键字最大的记录R[1](即堆顶)和无序区的最后一个记录R[n]交换,由此得到新的无序区R[1..n-1]和有序区R[n],且满足R[1..n-1].keys≤R[n].key ③ 由于交换后新的根R[1]可能违反堆性质,故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换,由此得到新的无序区R[1..n-2]和有序区R[n-1..n],且仍满足关系R[1..n-2].keys≤R[n-1..n].keys,同样要将R[1..n-2]调整为堆。 …… 直到无序区只有一个元素为止。 (2)大根堆排序算法的基本操作: ① 初始化操作:将R[1..n]构造为初始堆; ② 每一趟排序的基本操作:将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换,然后将新的无序区调整为堆(亦称重建堆)。 注意: ①只需做n-1趟排序,选出较大的n-1个关键字即可以使得文件递增有序。 ②用小根堆排序与利用大根堆类似,只不过其排序结果是递减有序的。堆排序和直接选择排序相反:在任何时刻,堆排序中无序区总是在有序区之前,且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止。 (3)堆排序的算法: void HeapSort(SeqIAst R) { //对R[1..n]进行堆排序,不妨用R[0]做暂存单元 int i; BuildHeap(R); //将R[1-n]建成初始堆 for(i=n;i>1;i--){ //对当前无序区R[1..i]进行堆排序,共做n-1趟。 R[0]=R[1];R[1]=R[i];R[i]=R[0]; //将堆顶和堆中最后一个记录交换 Heapify(R,1,i-1); //将R[1..i-1]重新调整为堆,仅有R[1]可能违反堆性质 } //endfor } //HeapSort (4) BuildHeap和Heapify函数的实现 因为构造初始堆必须使用到调整堆的操作,先讨论Heapify的实现。 ① Heapify函数思想方法 每趟排序开始前R[l..i]是以R[1]为根的堆,在R[1]与R[i]交换后,新的无序区R[1..i-1]中只有R[1]的值发生了变化,故除R[1]可能违反堆性质外,其余任何结点为根的子树均是堆。因此,当被调整区间是R[low..high]时,只须调整以R[low]为根的树即可。 "筛选法"调整堆 R[low]的左、右子树(若存在)均已是堆,这两棵子树的根R[2low]和R[2low+1]分别是各自子树中关键字最大的结点。若R[low].key不小于这两个孩子结点的关键字,则R[low]未违反堆性质,以R[low]为根的树已是堆,无须调整;否则必须将R[low]和它的两个孩子结点中关键字较大者进行交换,即R[low]与R[large](R[large].key=max(R[2low].key,R[2low+1].key))交换。交换后又可能使结点R[large]违反堆性质,同样由于该结点的两棵子树(若存在)仍然是堆,故可重复上述的调整过程,对以R[large]为根的树进行调整。此过程直至当前被调整的结点已满足堆性质,或者该结点已是叶子为止。上述过程就象过筛子一样,把较小的关键字逐层筛下去,而将较大的关键字逐层选上来。因此,有人将此方法称为"筛选法"。 具体的算法【参见教材】 ②BuildHeap的实现 要将初始文件R[l..n]调整为一个大根堆,就必须将它所对应的完全二叉树中以每一结点为根的子树都调整为堆。 显然只有一个结点的树是堆,而在完全二叉树中,所有序号 的结点都是叶子,因此以这些结点为根的子树均已是堆。这样,我们只需依次将以序号为 , -1,…,1的结点作为根的子树都调整为堆即可。 具体算法【参见教材】。 5、大根堆排序实例 对于关键字序列(42,13,24,91,23,16,05,88),在建堆过程中完全二叉树及其存储结构的变化情况参见【动画演示】。 6、 算法分析 堆排序的时间,主要由建立初始堆和反复重建堆这两部分的时间开销构成,它们均是通过调用Heapify实现的。 堆排序的最坏时间复杂度为O(nlgn)。堆排序的平均性能较接近于最坏性能。 由于建初始堆所需的比较次数较多,所以堆排序不适宜于记录数较少的文件。 堆排序是就地排序,辅助空间为O(1), 它是不稳定的排序方法。

寒凝雪 2019-12-02 01:18:19 0 浏览量 回答数 0

回答

常用的排序算法有插入排序,希尔排序,冒泡排序,快速排序,归并排序,堆排序还有基数排序。 排序算法一般考虑的就是两个方面,即时间复杂度和空间复杂度。 其中插入排序,冒泡排序是简单排序,排序的平均时间复杂度是O(n^2), 最坏的情况是O(n^2),辅助存储空间是O(1)。 快速排序的平均时间复杂度是O(nlogn), 最坏的情况是O(n^2), 辅助存储空间是O(logn) 归并排序的平均时间复杂度是O(nlogn), 最坏的情况是O(nlogn), 辅助存储空间是O(n) 堆排序平均时间复杂度是O(nlogn), 最坏的情况是O(nlogn), 辅助存储空间是O(1) 基数排序平均时间复杂度是O(d(n+rd)), 最坏的情况是O(d(n+rd)), 辅助存储空间是O(rd),其中d关键字的个数,rd是关键字的取值的个数。 从平均性能上来而言,快速排序最佳,其所需的时间最省,但快排在最坏的情况下的时间性能不如堆排序和归并排序。而后者相比的结果是,在n较大的时候,归并排序需要的时间比堆排序省,但它需要的辅助存储空间比较多。 从方法的稳定性来比较,基数排序是稳定的内排序,所有时间复杂度为O(n^2)的简单排序都是稳定的。然而,快速排序,归并排序,堆排序等时间性能较好的排序方法都是不稳定的。 具体每个排序的思想,楼主可以百度一下,百度百科都有相应的词条。

沉默术士 2019-12-02 01:18:29 0 浏览量 回答数 0

回答

1 快速排序(QuickSort) 快速排序是一个就地排序,分而治之,大规模递归的算法。从本质上来说,它是归并排序的就地版本。快速排序可以由下面四步组成。 (1) 如果不多于1个数据,直接返回。 (2) 一般选择序列最左边的值作为支点数据。 (3) 将序列分成2部分,一部分都大于支点数据,另外一部分都小于支点数据。 (4) 对两边利用递归排序数列。 快速排序比大部分排序算法都要快。尽管我们可以在某些特殊的情况下写出比快速排序快的算法,但是就通常情况而言,没有比它更快的了。快速排序是递归的,对于内存非常有限的机器来说,它不是一个好的选择。 2 归并排序(MergeSort) 归并排序先分解要排序的序列,从1分成2,2分成4,依次分解,当分解到只有1个一组的时候,就可以排序这些分组,然后依次合并回原来的序列中,这样就可以排序所有数据。合并排序比堆排序稍微快一点,但是需要比堆排序多一倍的内存空间,因为它需要一个额外的数组。 3 堆排序(HeapSort) 堆排序适合于数据量非常大的场合(百万数据)。 堆排序不需要大量的递归或者多维的暂存数组。这对于数据量非常巨大的序列是合适的。比如超过数百万条记录,因为快速排序,归并排序都使用递归来设计算法,在数据量非常大的时候,可能会发生堆栈溢出错误。 堆排序会将所有的数据建成一个堆,最大的数据在堆顶,然后将堆顶数据和序列的最后一个数据交换。接下来再次重建堆,交换数据,依次下去,就可以排序所有的数据。 4 Shell排序(ShellSort) Shell排序通过将数据分成不同的组,先对每一组进行排序,然后再对所有的元素进行一次插入排序,以减少数据交换和移动的次数。平均效率是O(nlogn)。其中分组的合理性会对算法产生重要的影响。现在多用D.E.Knuth的分组方法。 Shell排序比冒泡排序快5倍,比插入排序大致快2倍。Shell排序比起QuickSort,MergeSort,HeapSort慢很多。但是它相对比较简单,它适合于数据量在5000以下并且速度并不是特别重要的场合。它对于数据量较小的数列重复排序是非常好的。 5 插入排序(InsertSort) 插入排序通过把序列中的值插入一个已经排序好的序列中,直到该序列的结束。插入排序是对冒泡排序的改进。它比冒泡排序快2倍。一般不用在数据大于1000的场合下使用插入排序,或者重复排序超过200数据项的序列。 6 冒泡排序(BubbleSort) 冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素,使较大的数据下沉,较小的数据上升。它是O(n^2)的算法。 7 交换排序(ExchangeSort)和选择排序(SelectSort) 这两种排序方法都是交换方法的排序算法,效率都是 O(n2)。在实际应用中处于和冒泡排序基本相同的地位。它们只是排序算法发展的初级阶段,在实际中使用较少。 8 基数排序(RadixSort) 基数排序和通常的排序算法并不走同样的路线。它是一种比较新颖的算法,但是它只能用于整数的排序,如果我们要把同样的办法运用到浮点数上,我们必须了解浮点数的存储格式,并通过特殊的方式将浮点数映射到整数上,然后再映射回去,这是非常麻烦的事情,因此,它的使用同样也不多。而且,最重要的是,这样算法也需要较多的存储空间。 9 总结 下面是一个总的表格,大致总结了我们常见的所有的排序算法的特点。 排序法 平均时间 最差情形 稳定度 额外空间 备注 冒泡 O(n2) O(n2) 稳定 O(1) n小时较好 交换 O(n2) O(n2) 不稳定 O(1) n小时较好 选择 O(n2) O(n2) 不稳定 O(1) n小时较好 插入 O(n2) O(n2) 稳定 O(1) 大部分已排序时较好 基数 O(logRB) O(logRB) 稳定 O(n) B是真数(0-9), R是基数(个十百) Shell O(nlogn) O(ns) 1<s<2 不稳定 O(1) s是所选分组 快速 O(nlogn) O(n2) 不稳定 O(nlogn) n大时较好 归并 O(nlogn) O(nlogn) 稳定 O(1) n大时较好 堆 O(nlogn) O(nlogn) 不稳定 O(1) n大时较好

马铭芳 2019-12-02 01:18:25 0 浏览量 回答数 0

阿里云试用中心,为您提供0门槛上云实践机会!

0元试用32+款产品,最高免费12个月!拨打95187-1,咨询专业上云建议!

回答

(1)交换类排序法交换类排序法是指借助数据元素之间的互相交换进行排序的一种方法。冒泡排序法与快速排序法都属于交换类排序方法。冒泡排序法是一种最简单的交换类排序方法,它是通过相邻数据元素的交换逐步将线性表变成有序。假设线性表的长度为n,则在最坏情况下,冒泡排序需要经过n/2遍的从前往后的扫描和n/2遍的从后往前的扫描,需要的比较次数为n(n–1)/2。但这个工作量不是必需的,一般情况下要小于这个工作量。快速排序法也是一种交换类的排序方法,但由于它比冒泡排序法的速度快,因此称之为快速排序法。其关键是对线性表进行分割,以及对各分割出的子表再进行分割。(2)插入类排序法插入类排序法主要有简单插入排序法和希尔排序法。简单插入排序法,是指将无序序列中的各元素依次插入到已经有序的线性表中。在这种排序方法中,每一次比较后最多移掉一个逆序,因此,这种排序方法的效率与冒泡排序法相同。在最坏情况下,简单插入排序需要n(n–1)/2次比较。希尔排序法对简单插入排序做了较大的改进。它是将整个无序序列分割成若干小的子序列分别进行插入排序。希尔排序的效率与所选取的增量序列有关。在最坏情况下,希尔排序所需要的比较次数为O(n1.5)。(3)选择类排序选择类排序主要有简单选择类排序法和堆排序法。简单选择排序法的基本思想是:扫描整个线性表,从中选出最小的元素,将它交换到表的最前面(这是它应有的位置);然后对剩下的子表采用同样的方法,直到子表空为止。对于长度为n的线性表,在最坏情况下需要比较n(n–1)/2次。堆排序法也属于选择类排序法。具有n个元素的序列(h1, h2, …, hn),当且仅当满足条件: 或 (i=1, 2, …, n/2)时称之为堆。可见,堆顶元素(即第一个元素)必为最大项。堆排序的方法对于规模较小的线性表并不适合,但对于较大规模的线性表来说是很有效的。在最坏情况下,堆排序需要比较的次数为O(nlog2n)。 如果帮助到您,请记得采纳为满意答案哈,谢谢。祝您生活愉快。 vae.la

晚来风急 2019-12-02 01:19:10 0 浏览量 回答数 0

回答

选择排序(Selection Sort)的基本思想是:不断从待排记录序列中选出关键字最小的记录插入已排序记录序列的后面,直到n个记录全部插入已排序记录序列中。1、简单选择排序第i趟排序开始时,有序区和无序区分别为R[1..i-1]和R[i..n](i=1,2,..n-1),该趟排序则是从n-i+1个记录选取关键字最小的记录R[k],并与第i(i=1,2,...,n)个记录交换,形成新的有序区和无序区。从i=1开始,每次从剩余元素中选出最小(最大)元素。这就是直接选择排序。2、树型选择排序 又称为锦标赛排序,是一种按锦标赛思想进行选择排序的方法。先对n个记录的关键字进行两两比较,然后在其中的ceil(n/2)个较小者间再进行两两比较,如此往复,直至选出最小关键字的记录为止。这个过程可用一棵n个结点的完全二叉树来表示。如图所示: 但是这种方法存在辅助空间较多,“最大值”进行多余比较等缺点,J.willioms在1964提出了堆排序。3、堆排序(1)基本概念a)堆:设有n个元素的序列: {k1, k2, ..., kn} 对所有的i=1,2,...,(int)(n/2),当满足下面关系:ki≤k2i,ki≤k2i+1 或 ki≥k2i,ki≥k2i+1 这样的序列称为堆。堆的两种类型: 根结点最小的堆----小根堆。 根结点最大的堆----大根堆。根结点称为堆顶,即:在一棵完全二叉树中,所有非叶结点的值均小于(或均大于)左、右孩子的值。b)堆排序:是一种树型选择排序,特点是,在排序过程中,把R[1..n]看成是一个完全二叉树的存储结构,利用完全二叉树双亲结点和孩子结点的内在关系,在当前无序区中选择关键字最大(最小)的记录。(2)堆排序步骤:1、从k-1层的最右非叶结点开始,使关键字值大(或小)的记录逐步向二叉树的上层移动,最大(或小)关键字记录成为树的根结点,使其成为堆。2、逐步输出根结点,令r[1]=r[i](i=n,,n-1,...,2),在将剩余结点调整成堆。直到输出所有结点。我们称这个自堆顶到叶子的调整过程为“筛选”。(3)要解决的两个问题:1、如何由一个无序序列建成一个堆;2、输出一个根结点后,如何将剩余元素调整成一个堆。将一个无序序列建成一个堆是一个反复“筛选”的过程。若将此序列看成是一个完全二叉树,则最后一个非终端结点是第floor(n/2)个元素,由此“筛选”只需从第floor(n/2)个元素开始。堆排序中需一个记录大小的辅助空间,每个待排的记录仅占有一个存储空间。堆排序方法当记录较少时,不值得提倡。当n很大时,效率高。堆排序是非稳定的。堆排序的算法和筛选的算法如第二节所示。为使排序结果是非递减有序排列,我们在排序算法中先建一个“大顶堆”,即先选得一个关键字为最大的记录并与序列中最后一个记录交换,然后对序列中前n-1个记录进行筛选,重新将它调整为一个“大顶堆”,然后将选得的一个关键字为最大的记录(也就是第一个元素)与当前最后一个记录交换(全局看是第n-1个),如此往复,直到排序结束。由到,筛选应按关键字较大的孩子结点向下进行。二、算法的C语言描述1、简单选择排序void SelectSort(SeqList &L); { int i,j,k; for(i=1;i<=L.lenght;i++) { k=i; for(j=i+1;j<=L.lenght;j++) if(R[j].key<R[k].key) k=j; if(k!=i) { R[0]=R[i];R[i]=R[k];R[k]=R[0];} } }2、树型选择排序略(实践中几乎不用)3、堆排序 三、算法的C语言实现#include "stdio.h"#include "stdlib.h"#define OK 1#define MAXSIZE 20typedef int KeyType;typedef int Status;typedef struct{KeyType key;//InfoType otherinfo;}RedType; typedef struct{RedType r[MAXSIZE+1];int length;}Sqlist; typedef Sqlist HeapType;void HeapAdjust(HeapType &H,int s,int m){RedType rc;rc=H.r[s];for(int j=2*s;j<=m;j*=2) { if(j<m&&(H.r[j].key<H.r[j+1].key)) ++j; if(rc.key>=H.r[j].key) break; H.r[s]=H.r[j]; s=j; }//forH.r[s]=rc;}//HeapAdjust void HeapSort(HeapType &H){for(int i=H.length/2;i>0;--i) HeapAdjust(H,i,H.length);for(int i=H.length;i>1;--i) { H.r[0]=H.r[1]; H.r[1]=H.r[i]; H.r[i]=H.r[0]; HeapAdjust(H,1,i-1); }//for}//HeapSort void InputL(Sqlist &L){printf("input the length:\n");scanf("%d",&L.length);printf("input the data needed to sort:\n");for(int i=1;i<=L.length;i++) scanf("%d",&L.r[i].key);}//InputL void OutputL(Sqlist &L){printf("the data after sorting is:\n");for(int i=1;i<=L.length;i++) printf("%d ",L.r[i].key);} int main(){Sqlist H;InputL(H);HeapSort(H);OutputL(H);return OK;}四、堆排序示例及其复杂度 对深度为k的堆,筛选算法中进行关键字的比较次数至多为2(k-1)。建堆时,n个元素所需的比较次数不超过4n。堆排序时,<2nlogn。堆排序在最坏的情况下,时间复杂度为O(n㏒n)。

琴瑟 2019-12-02 01:18:41 0 浏览量 回答数 0

问题

在快速排序, 堆排序,归并排序中 哪个是最稳定的排序方法?

知与谁同 2019-12-01 20:11:20 1567 浏览量 回答数 4

回答

直接插入排序。 当待排序列基本有序时,对冒泡排序来说,若最大关键字位于序列首部,则每趟排序仅能使其“下沉”一个位置,要使其下沉到底部仍需n-1趟排序,也即时间复杂度仍为O(n^2)。而对简单选择排序来说,其比较次数与待排序列的初始状态无关;归并排序要求待排序列已经部分有序,而部分有序的含义是待排序列由若干有序的子序列组成,即每个子序列必须有序,并且其时间复杂度为O(n log2n);直接插入排序在待排序列基本有序时,每趟的比较次数大为降低,也即n-1趟比较的时间复杂度由O(n^2)降至O(n)。 各种排序方法的选择: ①就平均时间性能而言,快速排序最佳,其所需时间最省,但快速排序在最坏情况下的时间性能不如堆排序和归并排序。当n较大时,归并排序较堆排序省,但归并排序所需的辅助空间最大。 ②简单排序方法中,直接插入排序最简单,当待排序的结点已按键值“基本有序”且n较小时,则应采用直接插入排序或冒泡排序,直接插入排序比冒泡排序更快些,因此经常将直接插入排序和其他的排序方法结合在一起使用。 ③当n很大且键值位数较小时,采用基数排序较好;而当键值的最高位分布较均匀时,可先按其最高位将待排序结点分成若干子表,而后对各子表进行直接插入排序。 ④从方法的稳定性来比较,直接插入排序、冒泡排序、归并排序和基数排序是稳定的排序方法;而直接选择排序、希尔排序、堆排序和快速排序都是不稳定的排序方法。 内部排序方法的选择: 各种排序方法各有优缺点,故在不同情况下可作不同的选择。通常需考虑的因素有:待排序的记录个数;记录本身的大小;记录的键值分布情况等。 *若待排序的记录个数n较小时,可采用简单排序方法 *若n 较大时,应采用快速排序或堆排序。 若待排序的记录已基本有序,可采用起泡排序。

知与谁同 2019-12-02 01:19:30 0 浏览量 回答数 0

回答

冒泡排序只是最简单的排序算法之一,其他的排序还有快速排序,插入排序,归并排序和堆牌讯等,其中堆排序是最差情况下效率最高的排序算法,具体算法可以参照算法设计与分析的书籍或者《算法导论》等。还有不懂可以再问

沉默术士 2019-12-02 01:19:54 0 浏览量 回答数 0

回答

排序的算法有很多,对空间的要求及其时间效率也不尽相同。下面列出了一些常见的排序算法。这里面插入排序和冒泡排序又被称作简单排序,他们对空间的要求不高,但是时间效率却不稳定;而后面三种排序相对于简单排序对空间的要求稍高一点,但时间效率却能稳定在很高的水平。基数排序是针对关键字在一个较小范围内的排序算法。 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序 插入排序 插入排序是这样实现的: 首先新建一个空列表,用于保存已排序的有序数列(我们称之为"有序列表")。 从原数列中取出一个数,将其插入"有序列表"中,使其仍旧保持有序状态。 重复2号步骤,直至原数列为空。 插入排序的平均时间复杂度为平方级的,效率不高,但是容易实现。它借助了"逐步扩大成果"的思想,使有序列表的长度逐渐增加,直至其长度等于原列表的长度。 冒泡排序 冒泡排序是这样实现的: 首先将所有待排序的数字放入工作列表中。 从列表的第一个数字到倒数第二个数字,逐个检查:若某一位上的数字大于他的下一位,则将它与它的下一位交换。 重复2号步骤,直至再也不能交换。 冒泡排序的平均时间复杂度与插入排序相同,也是平方级的,但也是非常容易实现的算法。 选择排序 选择排序是这样实现的: 设数组内存放了n个待排数字,数组下标从1开始,到n结束。 i=1 从数组的第i个元素开始到第n个元素,寻找最小的元素。 将上一步找到的最小元素和第i位元素交换。 如果i=n-1算法结束,否则回到第3步 选择排序的平均时间复杂度也是O(n²)的。 举例: 564 比如说这个,我想让它从小到大排序,怎么做呢。 第一步:从第一位开始找最小的元素,654中4最小,与第一位交换。结果为465 第二步:从第二位开始找最小的元素,65中5最小,与第二位交换。结果为456 第三步:i=2,n=3,此时i=n-1,算法结束 完成 快速排序 现在开始,我们要接触高效排序算法了。实践证明,快速排序是所有排序算法中最高效的一种。它采用了分治的思想:先保证列表的前半部分都小于后半部分,然后分别对前半部分和后半部分排序,这样整个列表就有序了。这是一种先进的思想,也是它高效的原因。因为在排序算法中,算法的高效与否与列表中数字间的比较次数有直接的关系,而"保证列表的前半部分都小于后半部分"就使得前半部分的任何一个数从此以后都不再跟后半部分的数进行比较了,大大减少了数字间不必要的比较。但查找数据得另当别论了。 堆排序 堆排序与前面的算法都不同,它是这样的: 首先新建一个空列表,作用与插入排序中的"有序列表"相同。 找到数列中最大的数字,将其加在"有序列表"的末尾,并将其从原数列中删除。 重复2号步骤,直至原数列为空。 堆排序的平均时间复杂度为nlogn,效率高(因为有堆这种数据结构以及它奇妙的特征,使得"找到数列中最大的数字"这样的操作只需要O(1)的时间复杂度,维护需要logn的时间复杂度),但是实现相对复杂(可以说是这里7种算法中比较难实现的)。 看起来似乎堆排序与插入排序有些相像,但他们其实是本质不同的算法。至少,他们的时间复杂度差了一个数量级,一个是平方级的,一个是对数级的。 各算法的时间复杂度 平均时间复杂度 插入排序 O(n2) 冒泡排序 O(n2) 选择排序 O(n2) 快速排序 O(n log n) 堆排序 O(n log n) 归并排序 O(n log n) 基数排序 O(n) 希尔排序 O(n1.25) 来源 http://baike.baidu.com/view/297739.htm

青衫无名 2019-12-02 01:17:20 0 浏览量 回答数 0

回答

内部排序 217  8.1 排序的基本概念 217  8.1.1 排序 217  8.1.2 内部排序和外部排序 218  8.1.3 排序算法评价 218  8.1.4 排序算法的稳定性 218  8.1.5 待排序记录序列的存储结构 218  8.2 直接插入排序和希尔排序 218  8.2.1 直接插入排序 219  8.2.2 折半查找插入排序 222  8.2.3 希尔排序 223  8.3 选择排序和堆排序 225  8.3.1 选择排序 226  8.3.2 堆排序 227  8.4 冒泡排序和快速排序 229  8.4.1 冒泡排序 229  8.4.2 快速排序 231  8.5 归并排序 235  8.6 基数排序 236  8.6.1 基本思想 236  8.6.2 基数排序过程与算法 237  8.7 各种内部排序方法的比较讨论 241  8.8 外部排序 243  8.8.1 外部存储系统 243  8.8.2 外部排序面临的问题 246  8.8.3 外部排序的基本过程 246  8.9 小结 247  练习八 248

行者武松 2019-12-02 01:22:16 0 浏览量 回答数 0

回答

最常用的是快速排序,基数排序,计数排序,归并排序,堆排序,(偶尔还有插入排序) 都有各自的应用,快排就是单纯的快,但是特殊数据下复杂度会退化 基数排序可以配合一些特定的算法,譬如后缀数组的构建 计数排序简单且常用,通常排序值域小但是数据量大的情况 归并直接用来排序并不多,但是可以用来求解一些其他问题,本身的思想也非常重要,有很多拓展的算法(不是排序算法) 堆排序胜在稳定,不论数据如何最坏都是O(nlogn),一般情况比快速排序慢些,但是极端情况下表现十分优秀,常用来配合快速排序,优化其稳定性 插入排序适合极少量数据的排序(几个到十几个),速度要比这些高级算法快一些

聚小编 2019-12-02 01:18:04 0 浏览量 回答数 0

回答

假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中,ri=rj,且ri在rj之前,而在排序后的序列中,ri仍在rj之前,则称这种排序算法是稳定的;否则称为不稳定的。 对于不稳定的排序算法,只要举出一个实例,即可说明它的不稳定性;而对于稳定的排序算法,必须对算法进行分析从而得到稳定的特性。需要注意的是,排序算法是否为稳定的是由具体算法决定的,不稳定的算法在某种条件下可以变为稳定的算法,而稳定的算法在某种条件下也可以变为不稳定的算法。 例如,对于如下冒泡排序算法,原本是稳定的排序算法,如果将记录交换的条件改成r[j]>=r[j+1],则两个相等的记录就会交换位置,从而变成不稳定的算法。 void BubbleSort(int r[ ], int n){ exchange=n; //第一趟冒泡排序的范围是r[1]到r[n] while (exchange) //仅当上一趟排序有记录交换才进行本趟排序 { bound=exchange; exchange=0; for (j=1; j if (r[j]>r[j+1]) { r[j]←→r[j+1]; exchange=j; //记录每一次发生记录交换的位置 } } } 再如,快速排序原本是不稳定的排序方法,但若待排序记录中只有一组具有相同关键码的记录,而选择的轴值恰好是这组相同关键码中的一个,此时的快速排序就是稳定的。 稳定的排序方法: 堆排序、快速排序、希尔排序、直接选择排序不是稳定的排序算法,而基数排序、冒泡排序、直接插入排序、折半插入排序、归并排序是稳定的排序算法。 首先,排序算法的稳定性大家应该都知道,通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单形式化一下,如果Ai = Aj, Ai原来在位置前,排序后Ai还是要在Aj位置前。 其次,说一下稳定性的好处。排序算法如果是稳定的,那么从一个键上排序,然后再从另一个键上排序,第一个键排序的结果可以为第二个键排序所用。基数排序就 是这样,先按低位排序,逐次按高位排序,低位相同的元素其顺序再高位也相同时是不会改变的。 回到主题,现在分析一下常见的排序算法的稳定性,每个都给出简单的理由。 (1)冒泡排序 冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较,交换也发生在这两个元素之间。如果两个相等的元素没有相邻,那么即使通过前面的两两交换把两个相邻起来,这时候也不会交换,所以相同元素的前后顺序并没有改 变,所以冒泡排序是一种稳定排序算法。 (2)选择排序 选择排序是给每个位置选择当前元素最小的,比如给第一个位置选择最小的,在剩余元素里面给第二个元素选择第二小的,依次类推,直到第n-1个元素,第n个 元素不用选择了,因为只剩下它一个最大的元素了。那么,在一趟选择,如果当前元素比一个元素小,而该小的元素又出现在一个和当前元素相等的元素后面,那么 交换后稳定性就被破坏了。举个例子,序列5 8 5 2 9, 第一遍选择第1个元素5会和2交换,那么原序列中2个5的相对前后顺序就被破坏了,所以选择排序不是一个稳定的排序算法。 (3)插入排序 插入排序是在一个已经有序的小序列的基础上,一次插入一个元素。当然,刚开始这个有序的小序列只有1个元素,就是第一个元素。比较是从有序序列的末尾开 始,也就是想要插入的元素和已经有序的最大者开始比起,如果比它大则直接插入在其后面,否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相 等的,那么插入元素把想插入的元素放在相等元素的后面。所以,相等元素的前后顺序没有改变,从原无序序列出去的顺序就是排好序后的顺序,所以插入排序是稳 定的。 (4)快速排序 快速排序有两个方向,左边的i下标一直往右走,当a[i] <= a[center_index],其中center_index是中枢元素的数组下标,一般取为数组第0个元素。而右边的j下标一直往左走,当a[j] > a[center_index]。如果i和j都走不动了,i <= j, 交换a[i]和a[j],重复上面的过程,直到i>j。 交换a[j]和a[center_index],完成一趟快速排序。在中枢元素和a[j]交换的时候,很有可能把前面的元素的稳定性打乱,比如序列为 5 3 3 4 3 8 9 10 11, 现在中枢元素5和3(第5个元素,下标从1开始计)交换就会把元素3的稳定性打乱,所以快速排序是一个不稳定的排序算法,不稳定发生在中枢元素和a[j] 交换的时刻。 (5)归并排序 归并排序是把序列递归地分成短序列,递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换),然后把各个有序的段序列合并成一个有 序的长序列,不断合并直到原序列全部排好序。可以发现,在1个或2个元素时,1个元素不会交换,2个元素如果大小相等也没有人故意交换,这不会破坏稳定 性。那么,在短的有序序列合并的过程中,稳定是不会受到破坏,合并过程中可以保证如果两个当前元素相等时,把处在前面的序列的元素保存在结 果序列的前面,这样就保证了稳定性。所以,归并排序也是稳定的排序算法。 (6)基数排序 基数排序是按照低位先排序,然后收集;再按照高位排序,然后再收集;依次类推,直到最高位。有时候有些属性是有优先级顺序的,先按低优先级排序,再按高优 先级排序,最后的次序就是高优先级高的在前,高优先级相同的低优先级高的在前。基数排序基于分别排序,分别收集,所以其是稳定的排序算法。 (7)希尔排序(shell) 希尔排序是按照不同步长对元素进行插入排序,当刚开始元素很无序的时候,步长最大,所以插入排序的元素个数很少,速度很快;当元素基本有序了,步长很小, 插入排序对于有序的序列效率很高。所以,希尔排序的时间复杂度会比o(n^2)好一些。由于多次插入排序,一次插入排序是稳定的,不会改变相同元 素的相对顺序,但在不同的插入排序过程中,相同的元素可能在各自的插入排序中移动,最后其稳定性就会被打乱,所以shell排序是不稳定的。 (8)堆排序 堆的结构是节点i的孩子为2*i和2*i+1节点,大顶堆要求父节点大于等于其2个子节点,小顶堆要求父节点小于等于其2个子节点。在一个长为n 的序列,堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为n /2-1, n/2-2, ...1这些个父节点选择元素时,就会破坏稳定性。有可能第n/2个父节点交换把后面一个元素交换过去了,而第n/2-1个父节点把后面一个相同的元素没 有交换,那么这2个相同的元素之间的稳定性就被破坏了。所以,堆排序不是稳定的排序算法。 综上,得出结论: 选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法,而冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。

小旋风柴进 2019-12-02 01:18:09 0 浏览量 回答数 0

问题

为什么希尔排序法的时间复杂度比堆排序法大?

知与谁同 2019-12-01 20:11:39 784 浏览量 回答数 1

回答

排序算法 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。 分类 在计算机科学所使用的排序算法通常被分类为: 计算的复杂度(最差、平均、和最好表现),依据串列(list)的大小(n)。一般而言,好的表现是O。(n log n),且坏的行为是Ω(n2)。对於一个排序理想的表现是O(n)。仅使用一个抽象关键比较运算的排序算法总平均上总是至少需要Ω(n log n)。 记忆体使用量(以及其他电脑资源的使用) 稳定度:稳定排序算法会依照相等的关键(换言之就是值)维持纪录的相对次序。也就是一个排序算法是稳定的,就是当有两个有相等关键的纪录R和S,且在原本的串列中R出现在S之前,在排序过的串列中R也将会是在S之前。 一般的方法:插入、交换、选择、合并等等。交换排序包含冒泡排序(bubble sort)和快速排序(quicksort)。选择排序包含shaker排序和堆排序(heapsort)。 当相等的元素是无法分辨的,比如像是整数,稳定度并不是一个问题。然而,假设以下的数对将要以他们的第一个数字来排序。 (4, 1) (3, 1) (3, 7) (5, 6) 在这个状况下,有可能产生两种不同的结果,一个是依照相等的键值维持相对的次序,而另外一个则没有: (3, 1) (3, 7) (4, 1) (5, 6) (维持次序) (3, 7) (3, 1) (4, 1) (5, 6) (次序被改变) 不稳定排序算法可能会在相等的键值中改变纪录的相对次序,但是稳定排序算法从来不会如此。不稳定排序算法可以被特别地时作为稳定。作这件事情的一个方式是人工扩充键值的比较,如此在其他方面相同键值的两个物件间之比较,就会被决定使用在原先资料次序中的条目,当作一个同分决赛。然而,要记住这种次序通常牵涉到额外的空间负担。 排列算法列表 在这个表格中,n是要被排序的纪录数量以及k是不同键值的数量。 稳定的 冒泡排序(bubble sort) — O(n2) 鸡尾酒排序 (Cocktail sort, 双向的冒泡排序) — O(n2) 插入排序 (insertion sort)— O(n2) 桶排序 (bucket sort)— O(n); 需要 O(k) 额外 记忆体 计数排序 (counting sort) — O(n+k); 需要 O(n+k) 额外 记忆体 归并排序 (merge sort)— O(n log n); 需要 O(n) 额外记忆体 原地归并排序 — O(n2) 二叉树排序 (Binary tree sort) — O(n log n); 需要 O(n) 额外记忆体 鸽巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 额外记忆体 基数排序 (radix sort)— O(n·k); 需要 O(n) 额外记忆体 Gnome sort — O(n2) Library sort — O(n log n) with high probability, 需要 (1+ε)n 额外记忆体 不稳定 选择排序 (selection sort)— O(n2) 希尔排序 (shell sort)— O(n log n) 如果使用最佳的现在版本 Comb sort — O(n log n) 堆排序 (heapsort)— O(n log n) Smoothsort — O(n log n) 快速排序 (quicksort)— O(n log n) 期望时间, O(n2) 最坏情况; 对於大的、乱数串列一般相信是最快的已知排序 Introsort — O(n log n) Patience sorting — O(n log n + k) 最外情况时间, 需要 额外的 O(n + k) 空间, 也需要找到最长的递增子序列(longest increasing subsequence) 不实用的排序算法 Bogo排序 — O(n × n!) 期望时间, 无穷的最坏情况。 Stupid sort — O(n3); 递回版本需要 O(n2) 额外记忆体 Bead sort — O(n) or O(√n), 但需要特别的硬体 Pancake sorting — O(n), 但需要特别的硬体 排序的算法 排序的算法有很多,对空间的要求及其时间效率也不尽相同。下面列出了一些常见的排序算法。这里面插入排序和冒泡排序又被称作简单排序,他们对空间的要求不高,但是时间效率却不稳定;而后面三种排序相对于简单排序对空间的要求稍高一点,但时间效率却能稳定在很高的水平。基数排序是针对关键字在一个较小范围内的排序算法。 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序 插入排序 插入排序是这样实现的: 首先新建一个空列表,用于保存已排序的有序数列(我们称之为"有序列表")。 从原数列中取出一个数,将其插入"有序列表"中,使其仍旧保持有序状态。 重复2号步骤,直至原数列为空。 插入排序的平均时间复杂度为平方级的,效率不高,但是容易实现。它借助了"逐步扩大成果"的思想,使有序列表的长度逐渐增加,直至其长度等于原列表的长度。 冒泡排序 冒泡排序是这样实现的: 首先将所有待排序的数字放入工作列表中。 从列表的第一个数字到倒数第二个数字,逐个检查:若某一位上的数字大于他的下一位,则将它与它的下一位交换。 重复2号步骤,直至再也不能交换。 冒泡排序的平均时间复杂度与插入排序相同,也是平方级的,但也是非常容易实现的算法。 选择排序 选择排序是这样实现的: 设数组内存放了n个待排数字,数组下标从1开始,到n结束。 i=1 从数组的第i个元素开始到第n个元素,寻找最小的元素。 将上一步找到的最小元素和第i位元素交换。 如果i=n-1算法结束,否则回到第3步 选择排序的平均时间复杂度也是O(n²)的。 快速排序 现在开始,我们要接触高效排序算法了。实践证明,快速排序是所有排序算法中最高效的一种。它采用了分治的思想:先保证列表的前半部分都小于后半部分,然后分别对前半部分和后半部分排序,这样整个列表就有序了。这是一种先进的思想,也是它高效的原因。因为在排序算法中,算法的高效与否与列表中数字间的比较次数有直接的关系,而"保证列表的前半部分都小于后半部分"就使得前半部分的任何一个数从此以后都不再跟后半部分的数进行比较了,大大减少了数字间不必要的比较。但查找数据得另当别论了。 堆排序 堆排序与前面的算法都不同,它是这样的: 首先新建一个空列表,作用与插入排序中的"有序列表"相同。 找到数列中最大的数字,将其加在"有序列表"的末尾,并将其从原数列中删除。 重复2号步骤,直至原数列为空。 堆排序的平均时间复杂度为nlogn,效率高(因为有堆这种数据结构以及它奇妙的特征,使得"找到数列中最大的数字"这样的操作只需要O(1)的时间复杂度,维护需要logn的时间复杂度),但是实现相对复杂(可以说是这里7种算法中比较难实现的)。 看起来似乎堆排序与插入排序有些相像,但他们其实是本质不同的算法。至少,他们的时间复杂度差了一个数量级,一个是平方级的,一个是对数级的。 平均时间复杂度 插入排序 O(n2) 冒泡排序 O(n2) 选择排序 O(n2) 快速排序 O(n log n) 堆排序 O(n log n) 归并排序 O(n log n) 基数排序 O(n) 希尔排序 O(n1.25)

小旋风柴进 2019-12-02 01:17:41 0 浏览量 回答数 0

回答

A。(在堆排序和快速排序中,若原始记录接近正序或反序,则选用_堆排序____,若原始记录无序,则最好选用__快速排序___。) C错了。C的原题是下列排序法中,时间复杂度不收数据初始状态影响,总是为O(n2)的是__直接选择排序 ____。

聚小编 2019-12-02 01:18:48 0 浏览量 回答数 0

回答

A。(在堆排序和快速排序中,若原始记录接近正序或反序,则选用_堆排序____,若原始记录无序,则最好选用__快速排序___。)C错了。C的原题是下列排序法中,时间复杂度不收数据初始状态影响,总是为O(n2)的是__直接选择排序____。

知与谁同 2019-12-02 01:18:50 0 浏览量 回答数 0

回答

堆排序法,就是通过堆这种数据结构来实现排序,算法复杂度为O(nlogn)。 堆是一种完全二叉树且所有的父节点均大于(或小于)其子节点。 堆排序就是将所有待排序的元素组成一个堆,然后不断弹出堆顶的元素并调用函数维持堆序,直到所有元素均被弹出后,排序完成。被弹出的元素序列即一个有序数列。 维持堆序的一般做法是这样: 当一个节点被插入时,将该节点放在堆的末尾(这是为了保证堆是完全二叉树)然后将该节点与它的父节点比较,看该节点是否大于(或小于)其父节点,即判断当前的堆是否满足堆序。如果不满足,则将该节点与其父节点交换。再将该节点与其新的父节点做比较,依此类推,直到该节点不再需要与其父节点交换为止。(即满足堆序时停止) 当一个根节点被弹出(即被从堆中删除)时,将堆最尾部的节点移动到头结点的位置,然后将该节点不断与其子节点比较,如果不符合堆序则交换,直到符合堆序为止。 以下是我自己写的一个C++的堆排序的程序,希望对你理解该算法有帮助。 #include<iostream> using namespace std; int heap[10000],size; void Percup(int s) { if(s==1) return ; if(heap[s/2]<heap[s]) { swap(heap[s/2],heap[s]); Percup(s/2); } } void Percdown(int s) { if(s*2+1<=size&&heap[s*2+1]>heap[s]) { swap(heap[s*2+1],heap[s]); Percdown(s*2+1); } if(s*2<=size&&heap[s*2]>heap[s]) { swap(heap[s*2],heap[s]); Percdown(s*2); } } void Insert(int k) { heap[++size]=k; Percup(size); } int Pop() { int h=heap[1]; heap[1]=heap[size--]; Percdown(1); return h; } int main() { int a,n,i; cin>>n; for(i=0;i<n;i++) { cin>>a; Insert(a); } for(i=0;i<n;i++) cout<<Pop()<<' '; system("pause"); return 0; }

祁同伟 2019-12-02 01:18:42 0 浏览量 回答数 0

回答

1.稳定性比较 插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的 选择排序、希尔排序、快速排序、堆排序是不稳定的 2.时间复杂性比较 插入排序、冒泡排序、选择排序的时间复杂性为O(n2) 其它非线形排序的时间复杂性为O(nlog2n) 线形排序的时间复杂性为O(n); 3.辅助空间的比较 线形排序、二路归并排序的辅助空间为O(n),其它排序的辅助空间为O(1); 4.其它比较 插入、冒泡排序的速度较慢,但参加排序的序列局部或整体有序时,这种排序能达到较快的速度。 反而在这种情况下,快速排序反而慢了。 当n较小时,对稳定性不作要求时宜用选择排序,对稳定性有要求时宜用插入或冒泡排序。 若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。 当n较大时,关键字元素比较随机,对稳定性没要求宜用快速排序。 当n较大时,关键字元素可能出现本身是有序的,对稳定性有要求时,空间允许的情况下。 宜用归并排序。 当n较大时,关键字元素可能出现本身是有序的,对稳定性没有要求时宜用堆排序。

一键天涯 2019-12-02 01:17:46 0 浏览量 回答数 0

回答

排序算法 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。 分类 在计算机科学所使用的排序算法通常被分类为: 计算的复杂度(最差、平均、和最好表现),依据串列(list)的大小(n)。一般而言,好的表现是O。(n log n),且坏的行为是Ω(n2)。对於一个排序理想的表现是O(n)。仅使用一个抽象关键比较运算的排序算法总平均上总是至少需要Ω(n log n)。 记忆体使用量(以及其他电脑资源的使用) 稳定度:稳定排序算法会依照相等的关键(换言之就是值)维持纪录的相对次序。也就是一个排序算法是稳定的,就是当有两个有相等关键的纪录R和S,且在原本的串列中R出现在S之前,在排序过的串列中R也将会是在S之前。 一般的方法:插入、交换、选择、合并等等。交换排序包含冒泡排序(bubble sort)和快速排序(quicksort)。选择排序包含shaker排序和堆排序(heapsort)。 当相等的元素是无法分辨的,比如像是整数,稳定度并不是一个问题。然而,假设以下的数对将要以他们的第一个数字来排序。 (4, 1) (3, 1) (3, 7) (5, 6) 在这个状况下,有可能产生两种不同的结果,一个是依照相等的键值维持相对的次序,而另外一个则没有: (3, 1) (3, 7) (4, 1) (5, 6) (维持次序) (3, 7) (3, 1) (4, 1) (5, 6) (次序被改变) 不稳定排序算法可能会在相等的键值中改变纪录的相对次序,但是稳定排序算法从来不会如此。不稳定排序算法可以被特别地时作为稳定。作这件事情的一个方式是人工扩充键值的比较,如此在其他方面相同键值的两个物件间之比较,就会被决定使用在原先资料次序中的条目,当作一个同分决赛。然而,要记住这种次序通常牵涉到额外的空间负担。 排列算法列表 在这个表格中,n是要被排序的纪录数量以及k是不同键值的数量。 稳定的 冒泡排序(bubble sort) — O(n2) 鸡尾酒排序 (Cocktail sort, 双向的冒泡排序) — O(n2) 插入排序 (insertion sort)— O(n2) 桶排序 (bucket sort)— O(n); 需要 O(k) 额外 记忆体 计数排序 (counting sort) — O(n+k); 需要 O(n+k) 额外 记忆体 归并排序 (merge sort)— O(n log n); 需要 O(n) 额外记忆体 原地归并排序 — O(n2) 二叉树排序 (Binary tree sort) — O(n log n); 需要 O(n) 额外记忆体 鸽巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 额外记忆体 基数排序 (radix sort)— O(n·k); 需要 O(n) 额外记忆体 Gnome sort — O(n2) Library sort — O(n log n) with high probability, 需要 (1+ε)n 额外记忆体 不稳定 选择排序 (selection sort)— O(n2) 希尔排序 (shell sort)— O(n log n) 如果使用最佳的现在版本 Comb sort — O(n log n) 堆排序 (heapsort)— O(n log n) Smoothsort — O(n log n) 快速排序 (quicksort)— O(n log n) 期望时间, O(n2) 最坏情况; 对於大的、乱数串列一般相信是最快的已知排序 Introsort — O(n log n) Patience sorting — O(n log n + k) 最外情况时间, 需要 额外的 O(n + k) 空间, 也需要找到最长的递增子序列(longest increasing subsequence) 不实用的排序算法 Bogo排序 — O(n × n!) 期望时间, 无穷的最坏情况。 Stupid sort — O(n3); 递回版本需要 O(n2) 额外记忆体 Bead sort — O(n) or O(√n), 但需要特别的硬体 Pancake sorting — O(n), 但需要特别的硬体 排序的算法 排序的算法有很多,对空间的要求及其时间效率也不尽相同。下面列出了一些常见的排序算法。这里面插入排序和冒泡排序又被称作简单排序,他们对空间的要求不高,但是时间效率却不稳定;而后面三种排序相对于简单排序对空间的要求稍高一点,但时间效率却能稳定在很高的水平。基数排序是针对关键字在一个较小范围内的排序算法。 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序 插入排序 插入排序是这样实现的: 首先新建一个空列表,用于保存已排序的有序数列(我们称之为"有序列表")。 从原数列中取出一个数,将其插入"有序列表"中,使其仍旧保持有序状态。 重复2号步骤,直至原数列为空。 插入排序的平均时间复杂度为平方级的,效率不高,但是容易实现。它借助了"逐步扩大成果"的思想,使有序列表的长度逐渐增加,直至其长度等于原列表的长度。 冒泡排序 冒泡排序是这样实现的: 首先将所有待排序的数字放入工作列表中。 从列表的第一个数字到倒数第二个数字,逐个检查:若某一位上的数字大于他的下一位,则将它与它的下一位交换。 重复2号步骤,直至再也不能交换。 冒泡排序的平均时间复杂度与插入排序相同,也是平方级的,但也是非常容易实现的算法。 选择排序 选择排序是这样实现的: 设数组内存放了n个待排数字,数组下标从1开始,到n结束。 i=1 从数组的第i个元素开始到第n个元素,寻找最小的元素。 将上一步找到的最小元素和第i位元素交换。 如果i=n-1算法结束,否则回到第3步 选择排序的平均时间复杂度也是O(n²)的。 快速排序 现在开始,我们要接触高效排序算法了。实践证明,快速排序是所有排序算法中最高效的一种。它采用了分治的思想:先保证列表的前半部分都小于后半部分,然后分别对前半部分和后半部分排序,这样整个列表就有序了。这是一种先进的思想,也是它高效的原因。因为在排序算法中,算法的高效与否与列表中数字间的比较次数有直接的关系,而"保证列表的前半部分都小于后半部分"就使得前半部分的任何一个数从此以后都不再跟后半部分的数进行比较了,大大减少了数字间不必要的比较。但查找数据得另当别论了。 堆排序 堆排序与前面的算法都不同,它是这样的: 首先新建一个空列表,作用与插入排序中的"有序列表"相同。 找到数列中最大的数字,将其加在"有序列表"的末尾,并将其从原数列中删除。 重复2号步骤,直至原数列为空。 堆排序的平均时间复杂度为nlogn,效率高(因为有堆这种数据结构以及它奇妙的特征,使得"找到数列中最大的数字"这样的操作只需要O(1)的时间复杂度,维护需要logn的时间复杂度),但是实现相对复杂(可以说是这里7种算法中比较难实现的)。 看起来似乎堆排序与插入排序有些相像,但他们其实是本质不同的算法。至少,他们的时间复杂度差了一个数量级,一个是平方级的,一个是对数级的。 平均时间复杂度 插入排序 O(n2) 冒泡排序 O(n2) 选择排序 O(n2) 快速排序 O(n log n) 堆排序 O(n log n) 归并排序 O(n log n) 基数排序 O(n) 希尔排序 O(n1.25) 冒泡排序 654 比如说这个,我想让它从小到大排序,怎么做呢。 第一步:6跟5比,发现比它大,则交换。564 第二步:5跟4比,发现比它大,则交换。465 第三步:6跟5比,发现比它大,则交换。456

聚小编 2019-12-02 01:17:59 0 浏览量 回答数 0

回答

排序算法 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。 分类 在计算机科学所使用的排序算法通常被分类为: 计算的复杂度(最差、平均、和最好表现),依据串列(list)的大小(n)。一般而言,好的表现是O。(n log n),且坏的行为是Ω(n2)。对於一个排序理想的表现是O(n)。仅使用一个抽象关键比较运算的排序算法总平均上总是至少需要Ω(n log n)。 记忆体使用量(以及其他电脑资源的使用) 稳定度:稳定排序算法会依照相等的关键(换言之就是值)维持纪录的相对次序。也就是一个排序算法是稳定的,就是当有两个有相等关键的纪录R和S,且在原本的串列中R出现在S之前,在排序过的串列中R也将会是在S之前。 一般的方法:插入、交换、选择、合并等等。交换排序包含冒泡排序(bubble sort)和快速排序(quicksort)。选择排序包含shaker排序和堆排序(heapsort)。 当相等的元素是无法分辨的,比如像是整数,稳定度并不是一个问题。然而,假设以下的数对将要以他们的第一个数字来排序。 (4, 1) (3, 1) (3, 7) (5, 6) 在这个状况下,有可能产生两种不同的结果,一个是依照相等的键值维持相对的次序,而另外一个则没有: (3, 1) (3, 7) (4, 1) (5, 6) (维持次序) (3, 7) (3, 1) (4, 1) (5, 6) (次序被改变) 不稳定排序算法可能会在相等的键值中改变纪录的相对次序,但是稳定排序算法从来不会如此。不稳定排序算法可以被特别地时作为稳定。作这件事情的一个方式是人工扩充键值的比较,如此在其他方面相同键值的两个物件间之比较,就会被决定使用在原先资料次序中的条目,当作一个同分决赛。然而,要记住这种次序通常牵涉到额外的空间负担。 排列算法列表 在这个表格中,n是要被排序的纪录数量以及k是不同键值的数量。 稳定的 冒泡排序(bubble sort) — O(n2) 鸡尾酒排序 (Cocktail sort, 双向的冒泡排序) — O(n2) 插入排序 (insertion sort)— O(n2) 桶排序 (bucket sort)— O(n); 需要 O(k) 额外 记忆体 计数排序 (counting sort) — O(n+k); 需要 O(n+k) 额外 记忆体 归并排序 (merge sort)— O(n log n); 需要 O(n) 额外记忆体 原地归并排序 — O(n2) 二叉树排序 (Binary tree sort) — O(n log n); 需要 O(n) 额外记忆体 鸽巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 额外记忆体 基数排序 (radix sort)— O(n·k); 需要 O(n) 额外记忆体 Gnome sort — O(n2) Library sort — O(n log n) with high probability, 需要 (1+ε)n 额外记忆体 不稳定 选择排序 (selection sort)— O(n2) 希尔排序 (shell sort)— O(n log n) 如果使用最佳的现在版本 Comb sort — O(n log n) 堆排序 (heapsort)— O(n log n) Smoothsort — O(n log n) 快速排序 (quicksort)— O(n log n) 期望时间, O(n2) 最坏情况; 对於大的、乱数串列一般相信是最快的已知排序 Introsort — O(n log n) Patience sorting — O(n log n + k) 最外情况时间, 需要 额外的 O(n + k) 空间, 也需要找到最长的递增子序列(longest increasing subsequence) 不实用的排序算法 Bogo排序 — O(n × n!) 期望时间, 无穷的最坏情况。 Stupid sort — O(n3); 递回版本需要 O(n2) 额外记忆体 Bead sort — O(n) or O(√n), 但需要特别的硬体 Pancake sorting — O(n), 但需要特别的硬体 排序的算法 排序的算法有很多,对空间的要求及其时间效率也不尽相同。下面列出了一些常见的排序算法。这里面插入排序和冒泡排序又被称作简单排序,他们对空间的要求不高,但是时间效率却不稳定;而后面三种排序相对于简单排序对空间的要求稍高一点,但时间效率却能稳定在很高的水平。基数排序是针对关键字在一个较小范围内的排序算法。 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序 插入排序 插入排序是这样实现的: 首先新建一个空列表,用于保存已排序的有序数列(我们称之为"有序列表")。 从原数列中取出一个数,将其插入"有序列表"中,使其仍旧保持有序状态。 重复2号步骤,直至原数列为空。 插入排序的平均时间复杂度为平方级的,效率不高,但是容易实现。它借助了"逐步扩大成果"的思想,使有序列表的长度逐渐增加,直至其长度等于原列表的长度。 冒泡排序 冒泡排序是这样实现的: 首先将所有待排序的数字放入工作列表中。 从列表的第一个数字到倒数第二个数字,逐个检查:若某一位上的数字大于他的下一位,则将它与它的下一位交换。 重复2号步骤,直至再也不能交换。 冒泡排序的平均时间复杂度与插入排序相同,也是平方级的,但也是非常容易实现的算法。 选择排序 选择排序是这样实现的: 设数组内存放了n个待排数字,数组下标从1开始,到n结束。 i=1 从数组的第i个元素开始到第n个元素,寻找最小的元素。 将上一步找到的最小元素和第i位元素交换。 如果i=n-1算法结束,否则回到第3步 选择排序的平均时间复杂度也是O(n²)的。 快速排序 现在开始,我们要接触高效排序算法了。实践证明,快速排序是所有排序算法中最高效的一种。它采用了分治的思想:先保证列表的前半部分都小于后半部分,然后分别对前半部分和后半部分排序,这样整个列表就有序了。这是一种先进的思想,也是它高效的原因。因为在排序算法中,算法的高效与否与列表中数字间的比较次数有直接的关系,而"保证列表的前半部分都小于后半部分"就使得前半部分的任何一个数从此以后都不再跟后半部分的数进行比较了,大大减少了数字间不必要的比较。但查找数据得另当别论了。 堆排序 堆排序与前面的算法都不同,它是这样的: 首先新建一个空列表,作用与插入排序中的"有序列表"相同。 找到数列中最大的数字,将其加在"有序列表"的末尾,并将其从原数列中删除。 重复2号步骤,直至原数列为空。 堆排序的平均时间复杂度为nlogn,效率高(因为有堆这种数据结构以及它奇妙的特征,使得"找到数列中最大的数字"这样的操作只需要O(1)的时间复杂度,维护需要logn的时间复杂度),但是实现相对复杂(可以说是这里7种算法中比较难实现的)。 看起来似乎堆排序与插入排序有些相像,但他们其实是本质不同的算法。至少,他们的时间复杂度差了一个数量级,一个是平方级的,一个是对数级的。 平均时间复杂度 插入排序 O(n2) 冒泡排序 O(n2) 选择排序 O(n2) 快速排序 O(n log n) 堆排序 O(n log n) 归并排序 O(n log n) 基数排序 O(n) 希尔排序 O(n1.25) 冒泡排序 654 比如说这个,我想让它从小到大排序,怎么做呢。 第一步:6跟5比,发现比它大,则交换。564 第二步:5跟4比,发现比它大,则交换。465 第三步:6跟5比,发现比它大,则交换。456

马铭芳 2019-12-02 01:17:41 0 浏览量 回答数 0

回答

排序另一种分法 外排序:需要在内外存之间多次交换数据才能进行 内排序: 插入类排序 直接插入排序 希尔排序 选择类排序 简单选择排序 堆排序 交换类排序 冒泡排序 快速排序 归并类排序 归并排序

沉默术士 2019-12-02 01:18:57 0 浏览量 回答数 0

回答

H5edu教育Html5开发为您解答: 1.稳定性比较 插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的 选择排序、希尔排序、快速排序、堆排序是不稳定的 2.时间复杂性比较 插入排序、冒泡排序、选择排序的时间复杂性为O(n2) 其它非线形排序的时间复杂性为O(nlog2n) 线形排序的时间复杂性为O(n); 3.辅助空间的比较 线形排序、二路归并排序的辅助空间为O(n),其它排序的辅助空间为O(1); 4.其它比较 插入、冒泡排序的速度较慢,但参加排序的序列局部或整体有序时,这种排序能达到较快的速度。 反而在这种情况下,快速排序反而慢了。 当n较小时,对稳定性不作要求时宜用选择排序,对稳定性有要求时宜用插入或冒泡排序。 若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。 当n较大时,关键字元素比较随机,对稳定性没要求宜用快速排序。 当n较大时,关键字元素可能出现本身是有序的,对稳定性有要求时,空间允许的情况下。 宜用归并排序。 当n较大时,关键字元素可能出现本身是有序的,对稳定性没有要求时宜用堆排序。

玄学酱 2019-12-02 01:17:33 0 浏览量 回答数 0

回答

冒泡排序快速排序Shell排序堆排序计数排序归并排序基数排序桶排序

aoteman675 2019-12-02 01:18:13 0 浏览量 回答数 0

回答

排序算法一般分为以下几种: (1)非线性时间比较类排序:交换类排序(快速排序和冒泡排序)、插入类排序(简单插入排序和希尔排序)、选择类排序(简单选择排序和堆排序)、归并排序(二路归并排序和多路归并排序); (2)线性时间非比较类排序:计数排序、基数排序和桶排序。

boxti 2019-12-02 01:18:45 0 浏览量 回答数 0

回答

排序算法一般分为以下几种: (1)非线性时间比较类排序:交换类排序(快速排序和冒泡排序)、插入类排序(简单插入排序和希尔排序)、选择类排序(简单选择排序和堆排序)、归并排序(二路归并排序和多路归并排序);(2)线性时间非比较类排序:计数排序、基数排序和桶排序。

祁同伟 2019-12-02 01:17:23 0 浏览量 回答数 0

回答

排序另一种分法  外排序:需要在内外存之间多次交换数据才能进行 内排序:  归并排序 冒泡排序 快速排序 简单选择排序 堆排序 直接插入排序 希尔排序 插入类排序  选择类排序  交换类排序  归并类排序 

小哇 2019-12-02 01:18:55 0 浏览量 回答数 0

回答

1冒泡排序 选择排序 合并排序 插入排序 (他们是原地排序)2堆排序3快速排序4线性时间排序,分为:计数排序 基数排序 桶排序排序是可以相互渗透的,比如在选择排序中用2分的思想各种排序的思想、算法、运行时间及其期望空的话,可以问问我~

游客886 2019-12-02 01:18:05 0 浏览量 回答数 0

回答

讲的全是好东西哦,且听我一一道来: 堆排序 快速排序 线性时间中的排序 中值与顺序统计 基本的数据结构 散列表 二叉查找树 红-黑树 扩充的数据结构 动态规划 贪婪算法 分摊分析 B-树 二项式堆 斐波纳契堆 不相交集的数据结构 基本的图算法 最小生成树 单源最短路径 全对的最短路径 最大流 排序网络 矩阵运算 线性规划 多项式与快速傅里叶变换 数论算法 字符串匹配 计算几何学 NP-完备性 近似算法 注:看完这本书之后你就长生不老了。

行者武松 2019-12-02 01:19:33 0 浏览量 回答数 0

回答

冒泡排序、选择排序、插入排序、希尔排序、堆排序、归井排序、快速排序

yuanatom 2020-09-11 10:43:06 0 浏览量 回答数 0

回答

冒泡排序、选择排序、插入排序、希尔排序、堆排序、归井排序、快速排序

茶什i 2019-12-02 03:09:02 0 浏览量 回答数 0
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 企业信息查询 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 2020阿里巴巴研发效能峰会 企业建站模板 云效成长地图 高端建站