第十章：内部排序练习题
数据结构第十章习题课
1．下列排序算法中，其中（）是稳定的。
A. 堆排序，冒泡排序B. 快速排序，堆排序C. 直接选择排序，归并排序D. 归并排序，冒泡排序2．若需在O(nlog2n)的时间内完成对数组的排序，且要求排序是稳定的，则可选择的排序方法是（）。
A. 快速排序B. 堆排序C. 归并排序D. 直接插入排序3．排序趟数与序列的原始状态有关的排序方法是( )排序法。
A．插入 B. 选择 C. 冒泡 D. 快速4．对一组数据（84，47，25，15，21）排序，数据的排列次序在排序的过程中的变化为（1）84 47 25 15 21 （2）15 47 25 84 21 （3）15 21 25 84 47 （4）15 21 25 47 84 则采用的排序是( )。
A. 选择B. 冒泡C. 快速D. 插入5．对序列{15，9，7，8，20，-1，4}进行排序，进行一趟后数据的排列变为{4，9，-1，8，20，7，15}；则采用的是（）排序。
A. 选择B. 快速C. 希尔D. 冒泡6．若上题的数据经一趟排序后的排列为{9，15，7，8，20，-1，4}，则采用的是（）排序。
A．选择 B. 堆 C. 直接插入 D. 冒泡7．在文件“局部有序”或文件长度较小的情况下，最佳内部排序的方法是（）A．直接插入排序B．冒泡排序C．简单选择排序8．下列排序算法中，（）算法可能会出现下面情况：在最后一趟开始之前，所有元素都不在其最终的位置上。
A. 堆排序B. 冒泡排序C. 快速排序D. 插入排序9. 下列排序算法中，占用辅助空间最多的是：( )A. 归并排序B. 快速排序C. 希尔排序D. 堆排序10．用直接插入排序方法对下面四个序列进行排序（由小到大），元素比较次数最少的是（）。
A．94,32,40,90,80,46,21,69 B．32,40,21,46,69,94,90,80C．21,32,46,40,80,69,90,94 D．90,69,80,46,21,32,94,4011. 若用冒泡排序方法对序列{10,14,26,29,41,52}从大到小排序，需进行（）次比较。
中南大学数据结构与算法第10章内部排序课后作业答案
第10章内部排序习题练习答案1.以关键字序列(265，301，751，129，937，863，742，694，076，438)为例，分别写出执行以下排序算法的各趟排序结束时，关键字序列的状态。
(1) 直接插入排序(2)希尔排序(3)冒泡排序(4)快速排序(5) 直接选择排序(6) 堆排序(7) 归并排序(8)基数排序上述方法中，哪些是稳定的排序?哪些是非稳定的排序?对不稳定的排序试举出一个不稳定的实例。
答：(1)直接插入排序:(方括号表示无序区)初始态: 265[301 751 129 937 863 742 694 076 438]第一趟：265 301[751 129 937 863 742 694 076 438]第二趟：265 301 751[129 937 863 742 694 076 438]第三趟：129 265 301 751[937 863 742 694 076 438]第四趟：129 265 301 751 937[863 742 694 076 438]第五趟：129 265 301 751 863 937[742 694 076 438]第六趟：129 265 301 742 751 863 937[694 076 438]第七趟：129 265 301 694 742 751 863 937[076 438]第八趟：076 129 265 301 694 742 751 863 937[438]第九趟：076 129 265 301 438 694 742 751 863 937(2)希尔排序(增量为5，3，1)初始态: 265 301 751 129 937 863 742 694 076 438第一趟：265 301 694 076 438 863 742 751 129 937第二趟：076 301 129 265 438 694 742 751 863 937第三趟：076 129 265 301 438 694 742 751 863 937(3)冒泡排序(方括号为无序区)初始态[265 301 751 129 937 863 742 694 076 438]第一趟：076 [265 301 751 129 937 863 742 694 438]第二趟：076 129 [265 301 751 438 937 863 742 694]第三趟：076 129 265 [301 438 694 751 937 863 742]第四趟：076 129 265 301 [438 694 742 751 937 863]第五趟：076 129 265 301 438 [694 742 751 863 937]第六趟：076 129 265 301 438 694 742 751 863 937(4)快速排序：（方括号表示无序区，层表示对应的递归树的层数）初始态：[265 301 751 129 937 863 742 694 076 438]第二层：[076 129] 265 [751 937 863 742 694 301 438] 第三层：076 [129] 265 [438 301 694 742] 751 [863 937] 第四层：076 129 265 [301] 438 [694 742] 751 863 [937] 第五层：076 129 265 301 438 694 [742] 751 863 937第六层：076 129 265 301 438 694 742 751 863 937 (5)直接选择排序：(方括号为无序区)初始态[265 301 751 129 937 863 742 694 076 438]第一趟：076 [301 751 129 937 863 742 694 265 438]第二趟：076 129 [751 301 937 863 742 694 265 438]第三趟：076 129 265[ 301 937 863 742 694 751 438]第四趟：076 129 265 301 [937 863 742 694 751 438]第五趟：076 129 265 301 438 [863 742 694 751 937]第六趟：076 129 265 301 438 694 [742 751 863 937]第七趟：076 129 265 301 438 694 742 [751 863 937]第八趟：076 129 265 301 438 694 742 751 [937 863]第九趟：076 129 265 301 438 694 742 751 863 937(6)堆排序：（通过画二叉树可以一步步得出排序结果）初始态[265 301 751 129 937 863 742 694 076 438]建立初始堆：[937 694 863 265 438 751 742 129 075 301]第一次排序重建堆：[863 694 751 765 438 301 742 129 075] 937第二次排序重建堆：[751 694 742 265 438 301 075 129] 863 937第三次排序重建堆：[742 694 301 265 438 129 075] 751 863 937第四次排序重建堆：[694 438 301 265 075 129] 742 751 863 937第五次排序重建堆：[438 265 301 129 075] 694 742 751 863 937第六次排序重建堆：[301 265 075 129] 438 694 742 751 863 937第七次排序重建堆：[265 129 075] 301 438 694 742 751 863 937第八次排序重建堆：[129 075]265 301 438 694 742 751 863 937第九次排序重建堆：075 129 265 301 438 694 742 751 863 937(7)归并排序（为了表示方便，采用自底向上的归并，方括号为有序区）初始态：[265] [301] [751] [129] [937] [863] [742] [694] [076] [438]第一趟：[265 301] [129 751] [863 937] [694 742] [076 438]第二趟：[129 265 301 751] [694 742 863 937] [076 438]第三趟：[129 265 301 694 742 751 863 937] [076 438]第四趟：[076 129 265 301 438 694 742 751 863 937](8)基数排序（方括号内表示一个箱子共有10个箱子，箱号从0到9）初始态：265 301 751 129 937 863 742 694 076 438第一趟：[] [301 751] [742] [863] [694] [265] [076] [937] [438] [129]第二趟：[301] [] [129] [937 438] [742] [751] [863 265] [076] [] [694]第三趟：[075] [129] [265] [301] [438] [] [694] [742 751] [863] [937]在上面的排序方法中，直接插入排序、冒泡排序、归并排序和基数排序是稳定的，其他排序算法均是不稳定的，现举实例如下：以带*号的表示区别。
数据结构第10章作业 内部排序答案
第10章内部排序答案一、填空题1. 大多数排序算法都有两个基本的操作：比较（两个关键字的大小）和移动（记录或改变指向记录的指针）。
2. 在对一组记录（54，38，96，23，15，72，60，45，83）进行直接插入排序时，当把第7个记录60插入到有序表时，为寻找插入位置至少需比较3次。
(可约定为，从后向前比较)3. 在插入和选择排序中，若初始数据基本正序，则选用插入排序（到尾部）；若初始数据基本反序，则选用选择排序。
4. 在堆排序和快速排序中，若初始记录接近正序或反序，则选用堆排序；若初始记录基本无序，则最好选用快速排序。
5. 对于n个记录的集合进行冒泡排序，在最坏的情况下所需要的时间是O(n2) 。
若对其进行快速排序，在最坏的情况下所需要的时间是O(n2) 。
6. 对于n个记录的集合进行归并排序，所需要的平均时间是O(nlog2n) ，所需要的附加空间是O(n) 。
7．【计研题2000】对于n个记录的表进行2路归并排序，整个归并排序需进行log2n 趟（遍），共计移动n log2n次记录。
(即移动到新表中的总次数！共log2n趟，每趟都要移动n个元素)8.设要将序列（Q, H, C, Y, P, A, M, S, R, D, F, X）中的关键码按字母序的升序重新排列，则：冒泡排序一趟扫描的结果是H, C, Q, P, A, M, S, R, D, F, X ,Y；初始步长为4的希尔（shell）排序一趟的结果是P, A, C, S, Q, D, F, X , R, H,M, Y；二路归并排序一趟扫描的结果是H, Q, C, Y，A, P, M, S, D, R, F, X ；快速排序一趟扫描的结果是F, H, C, D, P, A, M, Q, R, S, Y，X；堆排序初始建堆的结果是Y, S, X, R, P, C, M, H, Q, D, F, A。
9. 在堆排序、快速排序和归并排序中，若只从存储空间考虑，则应首先选取堆排序方法，其次选取快速排序方法，最后选取归并排序方法；若只从排序结果的稳定性考虑，则应选取归并排序方法；若只从平均情况下最快考虑，则应选取快速排序方法；若只从最坏情况下最快并且要节省内存考虑，则应选取堆排序方法。
数据结构(c语言版)题集答案——第十章_内部排序.docx
第十章内部排序10.23void Insert_Sortl(SqList &L)〃监视哨设在高下标端的插入排序算法{k=L」ength;for(i=k-l;i;-i)//从后向前逐个插入排序if(L.r[i].key>L.r[i+1] .key){L.r[k+l].key=L.r[i].key;// 监视哨for(j=i+l;L.rfj].key>L.r[i].key；4-+j)L.r [j-1 ] .key=L.r[j] .key; 〃前移L.r [j-1 ] .key=L.r[k+1 ] .key; 〃插入}}//Insert_Sortl10.24void BiInsert_Sort(SqList &L)〃二路插入排序的算法{int dlMAXSIZE];//辅助存储x=L.r .key;d =x;first= 1 ;final= 1;for(i=2;i<=L.length;i++){if(L.r[i].key>=x) //插入前部{for(j=final;d[j]>L.r[i].key;j—)dU+l]=dU];d[j+l]=L.r[i].key;final++;}else//插入后部{for(j=first;d[j]d[j-l]=d[j];dl(j-2)%MAXSIZE+ l]=L.r[iJ.key;first=(first-2)%MAXSIZE+1; //&种形式的表达式是为了兼顾first=l的情况}}//forfor(i=first j= 1 ;dLiJ ；i=i%MAXS!ZE+1 ,j++)//^l 各序列复制回去L.r[j].key=d[i];}//BiInsert_Sort10.25void SLInsert_Sort(SLList &L)〃静态链农的插入排序算法L.r[0].key=0;L.r[0].next=l;L.r[l].ncxt=O; 〃建初始循环链表for(i=2;i<=L.length;i++) // 逐个插入{p=O;x=L.r[i].key;while(L.rLL.r[p].next].keyp=L.r[p].next;q=L.r[p].next;L.r[p].ncxt=i;L.r[i].next=q;}//forp=L.r[OJ.next;for(i=l;i{whilc(pq=L.r[p].ncxt;if(p!二i){L.r[pJ<->L.r[iJ;L.r[i].next=p;}p=q；}//for}//SLInsert_Sort10.26void Bubble_Sortl(int a[ ],int n)〃对包含n个元素的数组a进彳亍改进的冒泡排序{change=n-l; //change指示上一趟冒泡中最后发生交换的元素while(change){for(c=0,i=0;iif(a[i]>a[i+1]){a[i]<->a[i+l];c=i+l;//c指示这一趟冒泡屮发生交换的元素}changc=c;}//while}//Bubble_Sortl10.27void Bubblc_Sort2(int a[ ],int n)〃相邻两趟是反方向起泡的冒泡排序算法{low=0;high=n-1; 〃冒泡的上F界change=l;while(low{change=():for(i=low;iif(a[i]>a[i+1])chanse=l:}high-;//修改上界for(i=high;i>low;i-) //从F 向上起泡a[i]<->a[i-l];changc=l;}low++;〃修改卜-界}//while}//Bubble_Sort210.28void Bubble_Sort3(int a[ ],int n)〃对上一题的算法进行化简，循环体中只包含一次冒泡{int b[ 3 ]; //b[0]为冒泡的下界,b[ 2 ]为上界,b[l]无用d=l;b[0]=0;b[2]=n-l;//d为冒泡方向的标识,1为向上,・1为向下changc=l;while(b[0]{change=0;for(i=b[l -dl ;i!=bfl +d] ;i+=d) // 统一的冒泡算法if((a[i]・a[i+d])*d>0)//注意这个交换条件{a[i]<->a[i+d];change=l;}b[l+d]-=d; //修改边界d*=-l；〃换个方向}//while}//Bubble_Sort310.29void OE_Sort(int a[ ],int n)〃奇偶交换排序的算法{change=l;while(cha nge){change=():for(i= 1 ;iif(a[i]>a[i+1]){a[i]<->a[i+l];change=l;}for(i=0;iif(a[i]>a[i+1])}}//while}//OE_Sort分析:木算法的结束条件是连续两趟比较无交换发生10.30typcdcf struct {int low;int high;} boundary; //了序列的上下界类型void QSort_NotRecurve(int SQList &L)〃快速排序的非递归算法{low= 1 ;high=L.length;InitStack(S); //S 的元素为boundary 类型while(low{if(high-Iow>2) //如果当前了序列氏度大于3 尚未排好序{pivot=Partition(L,low,high); 〃进行一趟划分if(high-pivot>pivot-low){Push(S,{pivot+1 ,high}); //把长的了序列边界入栈high=pivot-l; 〃短的子序列留待下次排序}else{Push(S,{ low,pivot-1});low=pivot+l;}}〃讦else if(low{Easy_Sort(L,low,high); //直接进行比较排序low=high; 〃当前子序列标,忐为已排好序}else//如果当前子序列己排好序但栈屮还有未排序的子序列{Pop(S,a); 〃从栈中取出一个了序列low=a.low;high=a.high;}}//while}//QSort_NotRecurveint Partition(SQList &L,int low,int high)//-•趟划分的算法，与书上相同L.r[0]=L.r[low];pivotkey=L.r[low] .key;while(low=pivotkey)high-;L.r[low]=L.r[high];while(lowlow++;L.r[high]=L.r[low];}//whileL.r[lowJ=L.r[OJ;return low;{//Partitionvoid Easy_Sort(SQList &L,int low,int high)//对长度小于3的子序列进行比较排序{if(high-low==l)//子序列只含两个元索if(L.r[low] .key>L.r[high] .key) L.r[low]<->L.r[high];C1SC//T序列含冇三个元素{if(L.r[low].key>L.r[low+ l].key) L.r[low]<->L.r[low+1 ];if(L.r[low+1 J.key>L.r[high].key) L.r[low+1 J<->L.r[high];if(L.r[low].key>L.r[low+ l].key) L.r[low]<->L.r[low+ 1J;}}//Easy_Sort10.31void Divide(int a[ l,int n)〃把数组a中所有值为负的记录调到非负的记录ZMj{low=();high=n-l;whilc(low{while(low=0) high-; 〃以0作为虚拟的枢轴记录a[lowJ<->aLhighJ;while(lowallow]<->a[high];}[//Divide10.32typedef enum {RED,WHITE,BLUE} color; //三种颜色void Flag_Arrange(color a[ ],int n)〃把由三种颜色组成的序列重排为按照红，白，蓝的顺序排列{i=0;j=0;k=n-1;while(j<=k)switch(a[jj){case RED:i++；j++；break;case WHITE:j++；break;case BLUE:a[j]<->a[k];k-; 〃这里没有j++;语句是为了防止交换后a[j]仍为蓝色的情况}}//Flag_Arrange分析:这个算法屮设立了三个指针.其屮,j表示当前元素;i以前的元素全部为红色;k以示的元索全部为蓝色.这样，就可以根据j的颜色，把其交换到序列的前部或者后部.10.33void LinkedList_Select_Sort(LinkedList &L)〃单链表上的简单选择排序算法{for(p=L;p->next->next;p=p->next){q=p->ncxt;x=q->data;for(r=q,s=q;r->next;r=r->next)//?l： q后面寻找元素值最小的结点if(「>n ext->data{x=r- >n ext->data;s=r;}if(s!=q) //找至【J了值比q->data更小的最小结点s->next{p->next=s->next;s->next=q;(二q・> next;q・>next二pp->ncxt->ncxt=t;} 〃交换q和s->next两个结点}//for}//LinkedList_Select_Sort10.34void Build_Heap(Heap &H,int n)〃从低下标到高下标逐个插入建堆的算法{for(i=2;i{ 〃此时从H.r[l]到H.r[i・l]己经是大顶堆• •J=l;while(j!=l)//把H.r[i]插入{k=j/2;if(H.r|j] .key>H.r[kJ .key)H.r[j]<->H.r[k];j=k;}}//for}//Build_Heap10.35void TriHeap_Sort(Heap &H)〃利用三叉树形式的堆进行排序的算法{for(i=H.length/3;i>0;i—)Heap_Adjust(H,i,H.length);for(i=H」ength;i>l;i—){H.r[l]<->H.r[i];Heap_Adjust(H, 1 ,i-l);}}//TriHeap_Sortvoid Heap_Adjust(Heap &H,int s,int m)//顺序表H 中,H.r[s+1]到H.r[m]已经是堆，把H.r[s]插入并调整成堆{rc=H.r[s];for(j=3 *s-1 ;j<=m;j=3 *j-1){s=j；}H.rfs]=rc;}//Heap_ Adjust分析:本算法与课本上的堆排序算法相比，只有两处改动:1.建初始堆时,i的上限从H.length/3 开始(为什么?)2.调整堆的时候，要从结点的三个孩子结点中选择最大的那一个，最左边的孩子的序号的计算公式为j=3*s・l(为什么?)10.36void Merge_Sort(int a[ ],int n)〃归并排序的非递归算法{for(l= 1 ;lfor(i=0;(2*i-l)*l{start 1 =2*1 *i; //求出待归并的两段的上下界end l=start 1+1-1;start2=cnd 1+1;end2=(start2+l-1 )>(n-1 )?(n-1 )start2+l-1);//注意end2 可能超出边界Merge(a,start 1 ,end 1 ,start2,end2); 〃归)[■}}//Merge_Sortvoid Merge(int a[ ],int sl,int el,int s2,int e2)〃将有序子序列a[sl]到a[el]和a[s2]到a[e2]归并为有序序列a[sl]到a[e2]{int bfMAXSIZE]; 〃设立辅助存储数组bfor(i=s 1 ,j=s2,k=s 1 ;i<=e 1 &&jv二e2;k++) if(a[i]else b[k]=a[j++]; while(i<=el) b[k++]=a[i++];while(j<=e2) b[k++]=a[j++]；〃归并到b 屮for(i=s 1 ;i<=e2;i++) // 复制回去a[iJ=bLiJ；}//Merge10.37void LinkedList_Merge_Sort 1 (LinkedList &L)〃链农结构上的归并排序非递归算法{for(l= 1 ;lfor(p=L->next,e2=p;p->next;p=e2){for(i= 1 ,q=p;i<=l&&q->next;i++,q=q->next);cl=q；for(i= l;i<=l&&q->next;i++,q=q->next);e2=q; 〃求出两个待归并子序列的尾指针if (el !=e2) LinkedList_Merge(L,p,el,e2); // 归并}}//LinkcdList_Mcrgc_Sort 1void LinkedList_Merge(LinkedList &L,LNode *p,LNode *el,LNode *e2)〃対链表上的子序列进行归并，第一个子序列是从p->next到el,第二个是从e 1 ->next到e2{q=p->ncxt;r=c 1 ->ncxt; //q和r为两个了序列的起始位置while(q!=el->next&&r!=e2->next){if(q->datadata) //^择关键字较小的那个结点接在p的后而{p->next=q;p=q;q=q->ncxt;}else{p->next=r;p=r;r=r->ncxt;}}//whilewhile(q!=el->next) //接上剩余部分{p->ncxt=q;p=q;q=q->next;}while(r!=e2->next){p->next=r;p=r;r=r->next;}//LinkedList_Merge10.38void LinkedList_Merge_Sort2(LinkedList &L)〃初始归并段为最大有序子序列的归并排序，采用链表存储结构{LNodc *cnd[MAXSIZE]; 〃设立一个数组来存储各冇序了序列的尾指针for(p=L->next->nextj=0;p;p=p->next) // 求各有序子序列的尾指针if(!p->nextllp->data>p->next->data) end[i++]=p;while(end[O]->next) //当不止一个子序列时进行两两归并{j=O；k=O；//j：当前子序列尾指针存储位B!；k：归并后的子序列尾指针存储位置for(p=L->next,e2=p;p->next;p=e2) //两两归并所有子序列{el二end[j];e2=end[j+l]; //确定两个子序列if(e 1 ->next) LinkedList_Merge(L,p,e 1 ,e2); 〃归并cnd[k++]=c2; //用新序列的尾指针取代原来的尾指针j+=2;〃转到后面两个子序列}}//while}//LinkedList_Merge_Sort2void LinkcdList_Mcrgc(LinkcdList &L,LNodc *p,LNodc *cl,LNodc *c2)〃对链表上的了序列进行归并，第一个了序列是从p->next到el,第二个是从el->next到e2{q=p->next;r=e 1 ->next;while(q!=e 1 ->next&&r!=e2->next){if(q->datadata){p->next=q;p=q;q=q->next;}else{p->next=r;p=r;r=r->next;}}//whilewhile(q!=e 1 ->next){p->next=q;p=q;q=q->next;}while(r!=e2->next)p->next=r;p=r;}//LinkedList_Merge,与上一题完全相同10.39void SL_Mcrgc(int a[ ],int ll,int 12)//把长度分别为11,12且11A2<(11+12)的两个有序子序列归并为有序序列{startl=0;start2=ll;//分别表示序列1和序列2的剩余未归并部分的起始位直for(i=0;i{for(j=start2;jk=j-start2; //k为要向右循环移动的位数RSh(a,start 1 j-1 ,k);//W a[startl]到a[j・l]之间的子序列循环右移k位start l+=k+l;start2=j; 〃修改两序列尚未归并部分的起始位置}}//SL_Mergevoid RSh(int a[ ] jnt start,int end,int k)〃将a[start]到a[end]之间的子序列循环右移k 位,算法原理参见5.18{len=end-start+l;for(i=l;i<=k;i++)if(len%i==0&&k%i==0) p=i; 〃求len 和k 的最大公约数pfor(i=0;i{j=start+i;l=start+(i+k)%len;temp=a|jj;while(l!=start+i){a[j]=tcmp;temp=a[l];all]=a|j]；j=l；l=start+(j-start4-k)%len; // 依次|H J右移}a[start+i]=temp;}//for}//RSh10.40E后给出的解题思路在表述上存在问题，无法理解•比如说,“把第一个序列划分为两个子序列, 使其中的第一个子序列含有si个记录,0<=s 110.41void Hash_Sort(int a[ J)//X'j 1000个关键字为四位整数的记录进行排序{int b[ 10000];for(i=0;ivl000;i卄)〃直接按关键字散列{for(j=a[i] ;b[j] ;j=(j+1)% 10000);fo「(i=0,j=0;ivl000;j++)〃将散列收回a 中if(b[j]){for(x=b[j],k=j ;b[kj ;k=(k+1)%10000)if(b[k>=x){a[i++]=x;b[k]=0;}}//if}//Hash_Sort10.42typedef stmct {int gt; //大于该记录的个数int It; 〃小于该记录的个数} place; 〃整个序列中比某个关键字大或小的记录个数int Get_Mid(int a[ J,int n)〃求一个序列的中值记录的位置{place b[MAXSIZEJ;for(i=();ifor(j=0;j{if(a[j]>a[i])b[i].gt++;else if(a[j]}mid=0;min_dif=abs(b[0].gt-b[0].lt);for(i=0;iif(abs(b[i].gt-b[i].lt)return mid;}//Gct_Mid10.43void Count_Sort(int a[ ],int n)〃计数排序算法{int cfMAXSIZE];for(i=0;i{for(j=0,count=0;jif(a[j]c[i]=count;}for(i=0;i{min=();for(j=0;jif(c[j]a[i]<->a[min]; 〃与第i 个记录交换c[minJ=INFINITY; //修改该记录的c值为无穷大以便下一次选収}}//Count_Sort10.44void Enum_Sort(int a[ ],int n)〃对关键字只能取v到w Z间任意整数的序列进行排序int number[w+1 J,pos[w+1J; for(i=0;ifor(pos[0]=0,i=l；ipos[i]=pos[i-l]+num[i]; //pos 数组可以把关键字的值映射为元素在排好的序列中的位置for(i=0;ic[pos[a[i]]++]=a[i];for(i=0;ia[i]=c[i];}//Enum_Sort分析:木算法参考了第五章三元组稀疏矩阵转置的算法思想，其中的pos数组和那里的cpot数组起的是相类似的作用.10.45typedef enum {0,1,2,3,4,5,6,7,8,9} digit; //个位数类型typedef digit[3] num; //3位自然数类型，假设低位存储在低下标，高位存储在高卜•标void Enuni_Radix_Sort(num a[ ],int n)〃利用计数实现基数排序,其屮关键字为3位白然数，共有n个自然数{int number ,pos ;num c[MAXSIZEJ;for(j=0;j<3;j++) //依次对个位，十位和百位排序{for(i=0;ifor(pos[0]=0,i=l;ipos[iJ=pos[i-l]+numLi]; //把关键字的值映射为元素在排好的序列中的位置for(i=0;ic[pos[a[ij[j]]++]=a[i];for(i=0;ia[i]=c[i];}//for}//Enum_Radix_Sort分析:计数排序是一种稳定的排序方法.」E因为如此，它才能够被用来实现基数排序.10.46typedef struct {int key;int pos;} Shadow;//影子序列的记录类型void Shadow_Sort(Rectype b[ ],Rectype &a[ ],int n)〃对元素很人的记录序列b进行排序,结果放入a中，不移动元素{Shadow d[MAXSIZE];for(i=0;i{d[i].key=b[i].key;dfi].pos=i;}for(i=n-l ,change= 1 ;i> 1 &&change;i・・)//对影子序列执行冒泡排序{change=0;for(j=O;jif(d[j].key>d[j+l].key){dU]<->dU+U；change=l;}//forfor(i=0;ia[i]=b[d[i].pos]; }//Shadow_Sort。
【免费下载】数据结构第10章排序练习及答案
9.1 选择题 1．从末排序的序列中依次取出一个元素与已排序序列中的元素依次进行比较，然后将其放 在排序序列的合适位置，该排序方法称为（ ）排序法。 A）插入 B）选择 C）希尔 D）二路归并 【答案】A 2．下面各种排序方法中，最好情况下时间复杂度为 O(n)的是（ ） A）快速排序 B）直接插入排序 C）堆排序 D）归并排序 【答案】B 3．用某种排序方法对线性表（25,84,21,47,15,27,68,35,20）进行排序时，无序序列的变化情 况如下： 25 84 21 47 15 27 68 35 20 20 15 21 25 47 27 68 35 84 15 20 21 25 35 27 47 68 84 15 20 21 25 27 35 47 68 84 则所采用的排序方法是（ ） Ａ）选择排序 Ｂ）希尔排序 Ｃ）归并排序 Ｄ）快速排序 【答案】Ｄ 4．下面给出的四种排序法中，（ ）排序是不稳定排序法。 A）插入 B）冒泡 C）二路归并 D）堆 【答案】D 5．快速排序方法在（ ）情况下最不利于发挥其长处。 Ａ）要排序的数据量太大 Ｂ）要排序的数据中含有多个相同值 Ｃ）要排序的数据已基本有序 Ｄ）要排序的数据个数为奇数 【答案】Ｃ 6．一组记录的关键码为（46,79,56,38,40,84），则利用快速排序的方法，以第一个记录为基 准得到的一次划分结果为（ ） Ａ）38,40,46,56,79,84 B）40,38,46,79,56,84 C）40,38,46,56,79,84 D）40,38,46,84,56,79 【答案】Ｃ 7．对记录的关键码{50，26，38，80，70，90，8，30，40，20}进行排序，各趟排序结束 时的结果为： 50,26,38,80,70,90 ,8,30,40,20 50,8,30,40,20,90,26,38,80,70 26,8,30,40,20,80,50,38,90,70 8,20,26,30,38,40,50,70,80,90 其使用的排序方法是（ ） A）快速排序 B）基数排序 C）希尔排序 D）归并排序 【答案】C
第十章内排习题
第十章内部排序一，选择1. 基于比较方法的n个数据的内部排序。
最坏情况下的时间复杂度能达到的最好下界是（）。
A. O(nlogn)B. O(logn)C. O(n)D. O(n*n)2．下列排序算法中，其中（）是稳定的。
A. 堆排序，冒泡排序B. 快速排序，堆排序C. 直接选择排序，归并排序D. 归并排序，冒泡排序3．若要求排序是稳定的，且关键字为实数，则在下列排序方法中应选（）排序为宜。
A．直接插入 B．直接选择 C．堆 D．快速4．若需在O(nlog2n)的时间内完成对数组的排序，且要求排序是稳定的，则可选择的排序方法是（）。
A. 快速排序B. 堆排序C. 归并排序D. 直接插入排序5. 有一组数据（15，9，7，8，20，-1，7，4），用堆排序的筛选方法建立的初始堆为（）A．-1，4，8，9，20，7，15，7 B．-1，7，15，7，4，8，20，9C．-1，4，7，8，20，15，7，9 D．A，B，C均不对。
6．在排序算法中每一项都与其它各项进行比较，计算出小于该项的项的个数，以确定该项的位置叫( )A．插入排序 B．枚举排序 C．选择排序 D．交换排序7．就排序算法所用的辅助空间而言，堆排序，快速排序，归并排序的关系是（）A．堆排序〈快速排序〈归并排序 B．堆排序〈归并排序〈快速排序C．堆排序〉归并排序〉快速排序 D．堆排序 > 快速排序 > 归并排序8．在下列排序算法中,哪一个算法的时间复杂度与初始排序无关（）。
A．直接插入排序 B. 气泡排序 C. 快速排序 D. 直接选择排序9．将两个各有N个元素的有序表归并成一个有序表,其最少的比较次数是( ) A．N B．2N-1 C．2N D．N-110．一组记录的关键码为（46，79，56，38，40，84），则利用快速排序的方法，以第一个记录为基准得到的一次划分结果为（）。
A．(38,40,46,56,79,84) B. (40,38,46,79,56,84)C．(40,38,46,56,79,84) D. (40,38,46,84,56,79)11. 在下面的排序方法中，辅助空间为O（n）的是( ) 。
数据结构教程李春葆课后答案第10章内排序
2 else d=d/3; } }
数据结构教程学习指导
（1）指出fun(a，n)算法的功能。 （2）当a[]={5，1，3，6，2，7，4，8}时，问fun(a，8)共执行几趟排序，各趟的排序 结果是什么？ 答：（1）fun(a，n)算法的功能是采用增量递减为1/3的希尔排序方法对a数组中元素进 行递增排序。 （2）当a[]={5，1，3，6，2，7，4，8}时，执行fun(a，8)的过程如下： d=2：2 1 3 6 4 7 5 8 d=1：1 2 3 4 5 6 7 8 共有两趟排序。 4. 在实现快速排序的非递归算法时，可根据基准元素，将待排序序列划分为两个子 序列。若下一趟首先对较短的子序列进行排序，试证明在此做法下，快速排序所需要的栈 的深度为 O(log2n)。 答：由快速排序的算法可知，所需递归工作栈的深度取决于所需划分的最大次数。在 排序过程中每次划分都把整个待排序序列根据基准元素划分为左、右两个子序列，然后对 这两个子序列进行类似的处理。 设S(n)为对n个记录进行快速排序时平均所需栈的深度， 则： S(n)=
KeyType QuickSelect(RecType R[],int s,int t,int k) //在 R[s..t]序列中找第 k 小的元素 { int i=s,j=t; RecType tmp; if (s<t) //区间内至少存在 2 个元素的情况 { tmp=R[s]; //用区间的第 1 个记录作为基准 while (i!=j) //从区间两端交替向中间扫描,直至 i=j 为止 { while (j>i && R[j].key>=tmp.key) j--; //从右向左扫描,找第 1 个关键字小于 tmp 的 R[j] R[i]=R[j]; //将 R[j]前移到 R[i]的位置 while (i<j && R[i].key<=tmp.key) i++; //从左向右扫描,找第 1 个关键字大于 tmp 的 R[i] R[j]=R[i]; //将 R[i]后移到 R[j]的位置 } R[i]=tmp; if (k-1==i) return R[i].key; else if (k-1<i) return QuickSelect(R,s,i-1,k); //在左区间中递归查找 else return QuickSelect(R,i+1,t,k); //在右区间中递&& s==k-1) return R[k-1].key; else return -1; }
第10章 排序
第十章排序一、单项选择题1.有一组序列48,36,68,99,75,24,58,52进行快速排序，要求结果按从小到大排序，则进行一次划分之后结果为_____。
A. (24 28 36) 48 (52 68 75 99)B. (28 36 24) 48 (75 99 68 52)C. (36 68 99) 48 (75 24 28 52)D. (28 36 24) 48 (99 75 68 52)2.已知两个有序表，若要将它们组合成一个新的有序表，最好的方法是_____。
A. 希尔排序B. 二分插入排序C. 合并排序D. 冒泡排序3.排序译意风稳定的和不稳定的之分，下列四个说法中，只有______是正确的。
A. 快速排序是稳定的排序方法B. 堆排序是不稳定的排序方法C. 希尔排序是稳定的排序方法D. 冒泡排序是不稳定的排序方法4. 下列排序方法中，____方法是不稳定的。
A. 冒泡排序B. 希尔排序C. 冒泡排序D. 直接插入排序5. 下列排序方法中，在待排序的数据已经有序时，花费时间反而最多的是______。
A.快速排序B. 希尔排序C. 冒泡排序D. 堆排序6. 快速排序方法在最好情况下的时间复杂度为______。
A. O(n)B. O(n2)C. O(nlog2n)D.(log2n)7. 下列排序方法中，时间复杂度不受数据初始状态影响，恒为O(n2)的是_______。
A. 堆排序B.冒泡排序C. 直接选择排序D.快速排序8. 依次将待排序序列中的元素和有序子序列合并为一个新的有序子序列的排序方法是____。
A. 快速排序B.插入排序C. 冒泡排序D. 堆排序9. 在表R中排序前已按键值递增顺序排序，则_____方法的比较次数最少。
A. 直接插入排序B. 快速排序C. 归并排序D. 选择排序10. 已知表A中每个元素距其最终位置不远，采用______方法最节省时间。
A. 堆排序B. 冒泡排序C. 快速排序D. 直接选择排序11. 在下列排序方法中，字比较的次数与记录的初始排列次序无关的是______。
(严蔚敏)第10章 内部排序 习题答案
参考程序为： 参考程序为： #include <iostream> using namespace std; //直接插入排序法 直接插入排序法 void InsertSort ( int r[ ], int n ) { for ( int i=2; i<=n; i++ ) if (r[i] < r[i-1]) { r[0] = r[i]; // 复制为监视哨 for ( int j = i-1 ; r[0] < r[j]; j-- ) r[j+1] = r[j]; // 记录后移 r[j+1] = r[0]; // 插入到正确位置 } }
第10章 内部排序 章 习题及答案
一、单项选择题 ( C ) 1. 一组记录的关键码为 ( 46, 79, 56, 38, 40, 84 ) 利用快速排序方法， 利用快速排序方法，以第一个记录为基准 得到的一次划分结果为。 得到的一次划分结果为。 A. 38, 40, 46, 56, 79, 84 B. 40, 38, 46, 79, 56, 84 C. 40, 38, 46, 56, 79, 84 D. 40, 38, 46, 84, 56, 79
（1）直接插入排序 ） 1 2 3 初始 [83] 40 63 i=2 [40 83] i=3 [40 63 83] i=4 [13 40 63 i=5 [13 40 63 i=6 [13 35 40 i=7 [13 35 40 i=8 [13 35 40
4 13
5 84
6 35
7 96
8 57
83] 83 63 63 57
三、应用题 1. 已知关键码序列 （83, 40, 63, 13, 84, 35, 96, 57） ） 分别画出用直接插入排序、简单选择排序、 分别画出用直接插入排序、简单选择排序、 直接插入排序 快速排序对上述序列进行操作的各趟结果。 快速排序对上述序列进行操作的各趟结果。 对上述序列进行操作的各趟结果
数据结构Ch10习题答案
第十章内部排序一、择题1．用直接插入排序法对下面四个表进行（由小到大）排序，比较次数最少的是（B）。
A．（94，32，40，90，80，46，21，69）插32，比2次插40，比2次插90，比2次插80，比3次插46，比4次插21，比7次插69，比4次B．（21，32，46，40，80，69，90，94）插32，比1次插46，比1次插40，比2次插80，比1次插69，比2次插90，比1次插94，比1次C．（32，40，21，46，69，94，90，80）插40，比1次插21，比3次插46，比1次插69，比1次插94，比1次插90，比2次插80，比3次D．（90，69，80，46，21，32，94，40）插69，比2次插80，比2次插46，比4次插21，比5次插32，比5次插94，比1次插40，比6次2．下列排序方法中，哪一个是稳定的排序方法（BD）。
A．希尔排序B．直接选择排序C．堆排序D．冒泡排序下列3题基于如下代码：for(i=2;i<=n;i++){ x=A[i];j=i-1;while(j>0&&A[j]>x){ A[j+1]=A[j];j--;}A[j+1]=x}3．这一段代码所描述的排序方法称作（A）。
A．插入排序B．冒泡排序C．选择排序D．快速排序4．这一段代码所描述的排序方法的平均执行时间为（D）A．O(log2n) B．O(n) C．O(nlog2n) D．O(n2)5．假设这段代码开始执行时，数组A中的元素已经按值的递增次序排好了序，则这段代码的执行时间为（B）。
A．O(log2n) B．O(n) C．O(nlog2n) D．O(n2)6．在快速排序过程中，每次被划分的表（或了表）分成左、右两个子表，考虑这两个子表，下列结论一定正确是（B）。
A．左、右两个子表都已各自排好序B．左边子表中的元素都不大于右边子表中的元素C．左边子表的长度小于右边子表的长度D．左、右两个子表中元素的平均值相等7．对n个记录进行堆排序，最坏情况下的执行时间为（C）。
第10章 内部排序习题
第10章内部排序习题一、单项选择题1.若待排序对象序列在排序前已按其排序码递增顺序排列，则采用（）方法比较次数最少。
A. 直接插入排序B. 快速排序C. 归并排序D. 直接选择排序2.如果只想得到1024个元素组成的序列中的前5个最小元素，那么用（）方法最快。
A. 起泡排序B. 快速排序C. 直接选择排序D. 堆排序3.对待排序的元素序列进行划分，将其分为左、右两个子序列，再对两个子序列施加同样的排序操作，直到子序列为空或只剩一个元素为止。
这样的排序方法是（）。
A. 直接选择排序B. 直接插入排序C. 快速排序D. 起泡排序4.对5个不同的数据元素进行直接插入排序，最多需要进行（）次比较？A. 8B. 10C. 15D. 255.如果输入序列是已经排好顺序的，则下列算法中（）算法最快结束？A. 起泡排序B. 直接插入排序C. 直接选择排序D. 快速排序6.如果输入序列是已经排好顺序的，则下列算法中（）算法最慢结束？A. 起泡排序B. 直接插入排序C. 直接选择排序D. 快速排序7.下列排序算法中（）算法是不稳定的。
A. 起泡排序B. 直接插入排序C. 基数排序D. 快速排序8.9.采用任何基于排序码比较的算法，对5个互异的整数进行排序，至少需要（）次比较。
A. 5B. 6C. 7D. 810.下列算法中（）算法不具有这样的特性：对某些输入序列，可能不需要移动数据对象即可完成排序。
A. 起泡排序B. 希尔排序C. 快速排序D. 直接选择排序11.使用递归的归并排序算法时，为了保证排序过程的时间复杂度不超过O(nlog2n)，必须做到（）。
A. 每次序列的划分应该在线性时间内完成B. 每次归并的两个子序列长度接近C. 每次归并在线性时间内完成D. 以上全是12.在基于排序码比较的排序算法中，（）算法的最坏情况下的时间复杂度不高于O(nlog2n)。
A. 起泡排序B. 希尔排序C. 归并排序D. 快速排序13.一个对象序列的排序码为{ 46, 79, 56, 38, 40, 84 }，采用快速排序（以位于最左位置的对象为基准而）得到的第一次划分结果为：A. { 38, 46, 79, 56, 40, 84 }B. { 38, 79, 56, 46, 40, 84 }C. { 40, 38, 46, 79, 56, 84 }D. { 38, 46, 56, 79, 40, 84 }参考答案： 1. A 2. D 3. C 4. B 5. A6. D7. D8. C9. C 10. C11. D 12. C 13. C二、填空题1.第i (i = 1, 2, …, n-1) 趟从参加排序的序列中取出第i个元素，把它插入到由第0个~第i-1个元素组成的有序表中适当的位置，此种排序方法叫做________排序。
数据结构课后习题第十章
1.在下列排序算法中，稳定的事（），平均速度最快的是（），所需辅助存储空间最多的是（）。
A.希尔排序B.快速排序C.堆排序D.归并排序2.若要在O(n)数量级的时间内完成对数组的排序，且要求排序是稳定的，则可选择的排序方式应该是（）。
A.快速排序B.堆排序C.归并排序D.希尔排序3.在下列排序算法中，（）算法的时间复杂度与初始排序无关。
A.直接插入排序B.起泡排序C.快速排序D.直接选择排序4.一组记录关键字序列是（46,79,56,38,40,84），则用堆排序方法建立的初始大根堆是（）。
A.79,46,56,38,40,84B.84,79,56,38,40,46C.84,79,56,46,40,38D.94,56,79,40,46,385.一组记录的关键字序列是（46,79,56,38,40,84），则用快速排序方法，以第一个关键字为支点，得到的第一次划分结果是（）。
A.38,40,46,56,79,84B.40,38,46,79,56,84C.40,38,46,56,79,84D.40,38,46,84,56,796.一组记录的关键字序列是（25,48,16,35,79,82,26,40,36,72），用二路归并排序方法进行排序，则第二趟归并的结果是（）。
A.16,25,35,48,23,40,79,82,36,72B.16,25,35,48,79,82,23,36,40,72C.16,25,35,46,23,36,40,79,82,72D.16,25,35,48,79,23,36,40,72,827.在以下排序方法中，关键字比较的次数与记录的初始排列次序有关的是（）A.归并排序B.堆排序C.插入排序D.选择排序8.下列排序算法中，（）算法可能会出现下面情况：初始数据有序时，花费的时间反而最多。
A.堆排序B.冒泡排序C.希尔排序D.快速排序9.数据序列（8,9,10,4,5,6,20,1,2）只能是下列排序算法中的（）的两趟排序后的结果。
内部排序习题
第10章内部排序【例10-1】已知关键字序列（12，77，21，65，38，7，38，53），给出采用直接插入排序方法按关键字递增序排列时的每一趟结果。
解：初始1趟2趟3趟4趟5趟6趟7趟（表示有序区）【例10-2】待排序列为（39，80，76，41，13，29，50，78，30，11，100，7，41，86），步长因子分别取5、3、1，给出采用希尔排序方法按关键字递增序排列时的每一趟结果。
解：排序过程如下：p=539 80 76 41 13 29 50 78 30 11 100 7 41 86子序列分别为{39，29，100}，{80，50，7}，{76，78，41}，{41，30，86}，{13，11}。
第一趟排序结果：p=3 29 7 41 30 11 39 50 76 41 13 100 80 78 86子序列分别为{29，30，50，13，78}，{7，11，76，100，86}，{41，39，41，80}。
第二趟排序结果：p=1 13 7 39 29 11 41 30 76 41 50 86 80 78 100此时，序列基本“有序”，对其进行直接插入排序，得到最终结果：7 11 13 29 30 39 41 41 50 76 78 80 86 100【例10-3】已知序列（17，18，60，40，7，32，73，65，85），请给出采用冒泡排序法对该序列作升序排序时的每一趟的结果。
解：初始1趟2趟3趟4趟5趟17 17 17 17 7 718 18 18 7 17 1760 40 7 18 18 1840 7 32 32 32 327 32 40 40 40 4032 60 60 60 60 6073 65 65 65 65 6565 73 73 73 73 7385 85 85 85 85 85（表示有序区）【例10-4】已知关键字序列（38，12，21，77，65，7，38，53）给出采用快速排序方法按关键字增序排序时的第一趟快排过程，并举出一个反例说明快速排序是不稳定排序。
排序自测试题
6．设计一个用链表表示的直接插入排序算法。
{for(i=1;i<=________;i++)/*每次循环，选择出一个最小键值*/
{k=i;
for(j=i+1;j<=n;j++)if(r[j].key<r[k].key)________;
if(______)swap(r[k],r[i]）;/*函数swap(r[k],r[i]）交换r[k]和r[i]的位置*/
16.若树形选择排序的叶子数为n，除第一次需执行________次比较就选择出一个最小的键值外，以后的每次都只经过________次比较就选择出一个最小的键值。所以树形选择排序总的时间开销为________。
17.从一个无序序列建立一个堆的方法是：首先将要排序的所有键值分放到一棵________的各个结点中，然后从i=________的结点ki开始，逐步把以kn/2,kn/2-1,kn/2-2,……为根的子树排成堆，直到以k1为根的树排成堆，就完成了建堆的过程。
①直接插入排序和快速排序②直接插入排序和归并排序
③直接选择排序和归并排序④快速排序和归并排序
14．（ ）方法是从未排序序列中依次取出元素与已排序序列中的元素作比较，将其放入已排序序列的正确位置上。
①归并排序②插入排序③快速排序④选择排序
15（ ）方法是从未排序序列中挑选元素，并将其依次放入已排序序列的一端。
①直接插入排序②冒泡排序③直接选择排序④归并排序
7．对于大文件的排序要研究在外设上的排序技术，即 （ ）
数据结构(内排序)练习题与答案
1、以下关于排序的叙述中正确的是（）。
A.排序方法都是在顺序表上实现的，在链表上无法实现排序方法B.稳定的排序方法优于不稳定的排序方法，因为稳定的排序方法效率较高C.在顺序表上实现的排序方法在链表上也同样适合D.对同一个顺序表使用不同的排序方法进行排序，得到的排序结果可能不同正确答案：D解析： D、稳定的排序方法的效率不一定都比不稳定的排序方法高。
有些排序方法既可以上顺序表上实现，也可以在链表上实现，但不是所有的排序方法都如此。
由于排序方法具有不同的稳定性，所以对同一个顺序表（存在相同的多个关键字记录）使用不同的排序方法进行排序，得到的排序结果可能不同。
2、以下不属于内排序方法的是（）。
A.直接插入排序B.拓扑排序C.二路归并排序D.堆排序正确答案：B解析： B、拓扑排序是一种产生拓扑序列的方法，不属内排序方法。
3、目前来讲，基于比较的内排序方法最好的平均时间复杂度为（）。
A. O(log2n)B. O(n2)C. O(nlog2n)D. O(n)正确答案：C解析： C、目前来讲，基于比较的内排序方法最好的平均时间复杂度为O(nlog2n)。
4、对有n个记录的表进行直接插入排序，在最好情况下需比较（）次关键字。
A.n(n-1)/2B.n-1C.n/2D.n+1正确答案：B解析： B、直接插入排序在初始数据正序时效率最好，此时只需要n-1次关键字比较。
5、数据序列{8，9，10，4，5，6，20，1，2}只能是（）算法的两趟排序后的结果。
A.堆排序B.简单选择排序C.冒泡排序D.直接插入排序正确答案：D解析： D、采用排除法，因为两趟排序后结果中的有序区不是全局有序的，所以只能是直接插入排序，不可能是其他三种排序方法。
6、对数据序列{15，9，7，8，20，-1，4}进行排序，进行一趟后数据的排序变为{4，9，-1，8，20，7，15}，则采用的是（）算法。
A.冒泡排序B.希尔排序C.快速排序D.简单选择排序正确答案：B解析： B、因为一趟排序后结果中的有序区不是全局有序的，所以不可能是简单选择排序和冒泡排序。
数据结构(内部排序)习题与答案
一、单选题1、对关键字序列（21,19,37,5,2），经直接插入排序法由小到大排序，第一趟后所得结果为（）。
A.(19，21，5，2，37)B.(19，21，37，5，2)C.(19，21，2，5，37)D.(19，21，5，37，2)正确答案：B2、对关键字序列（21,19,37,5,2），经冒泡排序法由小到大排序，第一趟后所得结果为（）。
A.(19，21，37，5，2)B.(19，21，2，5，37)C.(19，21，5，37，2)D.(19，21，5，2，37)正确答案：D3、对关键字序列（149,138,165,197,176,113,127），采用基数排序的第一趟之后所得结果为（）。
A.(113，165，176，197，127，138，149)B.(113，165，176，127，197，138，149)C.(113，127，138，149，165，176，197)D.(149，138，165，197，176，113，127)正确答案：A4、下列各项键值（）序列不是堆的。
A.(5，23，68，16，94)B.(5，23，16，94，68)C.(5，16，23，68，94)D.(5，23，16，68，94)正确答案：A5、假设一组待排序的关键字序列为（24,62,36,19），要求从小到大进行排序，（）是归并排序的过程。
A.(24，62，36，19)(24，36，62，19)(19，24，36，62)B.(24，62，19，36)(19，24，36，62)C.(62，24，36，19)(19，24，36，62)D.(24，19，36，62)(24，19，36，62)(19，24，36，62)正确答案：B6、在第一趟排序之后，不能确保将数据表中某一个元素放在其最终位置上的排序算法是（）。
A.归并排序B.快速排序C.冒泡排序D.选择排序正确答案：A7、对于下列排序，（）的时间效率与关键字初始序列有直接关系。
第10章习题(带答案)
1、对待排序的元素序列进行划分，将其分为左、右两个子序列，再对两个子序列施加同样的排序操作，直到子序列为空或只剩一个元素为止。
这样的排序方法是 ( )。
A. 直接选择排序B. 直接插入排序C. 快速排序D. 起泡排序2、对5个不同的数据元素进行直接插入排序，最多需要进行 () 次比较。
A. 8B. 10C. 15D. 253、用快速排序法对n个数据进行排序，在最好情况下的时间复杂度是O(nlogn)，在最坏情况下的时间复杂度是O(n2)，在平均情况下的时间复杂度是O(nlogn)。
4、用归并排序法对n个数据进行排序，在最好情况下的时间复杂度是O(nlogn)，在最坏情况下的时间复杂度是O(nlogn)，在平均情况下的时间复杂度是O(nlogn)。
5、在对n个元素进行直接插入排序的过程中，共需要进行2n趟。
（错）快速排序在最坏情况下的时间复杂度为)。
（对）n(26、若一组记录的关键字为（46，79，56，38，40，84），则利用快速排序的方法，以第一个记录为基准得到一次划分结构为( )。
A.40，38，46，84，56，79B.40，38，46，56，79，84C.40，38，46，79，56，84D.38，40，46，56，79，847、下列四个序列中，哪一个是堆（）。
A. 75,65,30,15,25,45,20,10B. 75,65,45,10,30,25,20,15C. 75,45,65,30,15,25,20,10D. 75,45,65,10,25,30,20,158、由无序序列{ 15，9，7，8，20，7}建立的初始小顶堆为7,8,7,9,20,15_。
9、已知5个数据元素为（54，28，16，34，73），对该数列按从小到大排序，经过一趟冒泡排序后的序列为28,16,34,54,73_ 。
10、若不考虑基数排序，则在排序过程中，主要进行的两种基本操作是关键字的__ 比较_____和记录的___移动__。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第十章：内部排序练习题
一、选择题
1、下述几种排序方法中，平均查找长度最小的是（）。
A、插入排序
B、选择排序
C、快速排序
D、归并排序
2、设关键字序列为（3，7，6，9，7，1，4，5，20），对其进行排序的最小交换次数为（）。
A、6
B、7
C、8
D、20
3、下列排序算法中不稳定的有（）。
A、直接选择排序
B、直接插入排序
C、冒泡排序
D、二叉排序
E、Shell排序
F、快速排序
G、归并排序
H、堆排序
I、基数排序
4、内部排序多个关键字的文件，最坏情况下最快的排序方法是（），相应的时间复杂度为（），该算法是（）排序方法。
A、快速排序
B、插入排序
C、归并排序
D、简单选择排序
E、O(nlog2n)
F、O(n2)
G、O(n2log2n)
H、O(n)
I、稳定J、不稳定
5、对初始状态为递增的表按递增顺序排序，最省时间的是（）算法，最费时间的算法是（）。
A、堆排序
B、快速排序
C、插入排序
D、归并排序
6、下述几种排序方法中，要求内存量最大的是（）。
A、插入排序
B、选择排序
C、快速排序
D、归并排序
7、在下面的排序方法中，关键字比较的次数与记录的初始排列次序无关的是（）。
A、希尔排序
B、冒泡排序
C、插入排序
D、选择排序
8、下列排序中，排序速度与数据的初始排列状态没有关系的是（）。
A、直接选择排序
B、基数排序
C、堆排序
D、直接插入排序
9、若需在O(nlog2n)的时间内完成对数组的排序，且要求排序是稳定的，则可选择的排序方法为（）。
A、快速排序
B、堆排序
C、归并排序
D、直接插入排序
10、排序方法中，从未排序序列中依次取出元素与已排序序列（初始时为空）中的元素进行比较，将其放入已排序序列正确位置上的方法，称为（）。
A、希尔排序
B、冒泡排序
C、插入排序
D、选择排序
11、每次把待排序的元素划分为左右两个子区间，其中左区间中元素的关键字均小于等于基准元素的关键字，右区间中元素的关键字均大于基准元素的关键字，则此排序方法为（）。
A、堆排序
B、快速排序
C、冒泡排序
D、Shell排序
12、排序方法中，从未排序序列中挑选元素，并将其依次放入已排序序列（初始时为空）的一端的方法，称为（）。
A、希尔排序
B、归并排序
C、插入排序
D、选择排序
13、n个记录的直接插入排序所需记录关键码的最大比较次数为（）。
A、nlog2n
B、n2/2
C、(n+2)(n-1)/2
D、n-1
14、n个记录的直接插入排序所需的记录最小移动次数为（）。
A、2(n-1)
B、n2/2
C、(n+3)(n-2)/2
D、2n
15、快速排序在（）情况下最不利于发挥其长处，在（）情况下最易发挥其长处。
A、被排序的数据量很大
B、被排序的数据已基本有序
C、被排序的数据完全有序
D、被排序的数据中最大与最小值相差不大
E、要排序的数据中含有多个相同值。
16、直接插入排序和冒泡排序的平均时间复杂度为（），若初始数据有序（正序），则时间复杂度为（）。
A、O(n)
B、O(log2n)
C、O(nlog2n)
D、O(n2)
17、一组记录的关键字为（45，80，55，40，42，85），则利用堆排序的方法建立的初始堆为（）。
A、（80，45，55，40，42，85）
B、（85，80，55，40，42，45）
C、（85，80，55，45，42，40）
D、（85，55，80，42，45，40）
二、填空题
1、在直接插入和直接选择排序中，若初始数据基本有序，则选用（），若初始数据基本反序，则选用（）。
2、在对一组记录（50，40，95，20，15，70，60，45，80）进行冒泡排序时，第一趟需进行相邻记录的交换的次数为（），在整个排序过程中共需进行（）趟才可完成。
3、n个记录的冒泡排序算法所需最大移动次数为（），最小移动次数为（）。
4、对n个结点进行快速排序，最大比较次数为（）。
5、在对一组记录（50，40，95，20，15，70，60，45，80）进行（大根）堆排序时，根据初始记录构成初始堆后，最后4条记录为（）。
6、对于直接插入排序、冒泡排序、简单选择排序、堆排序、快速排序有：（1）当文件“局部有序”或文件长度较小时，最佳的内部排序方法是（）。
（2）快速排序在最坏情况下时间复杂度是（）比（）性能差；（3）就平均时间而言，（）最佳。
7、在堆排序、快速排序和归并排序中，若只从存储时间考虑，则应首先选取（）方法，其次选用（）方法，最后选用（）方法；若只从排序结果的稳定性考虑，则应选取（）方法；若只从平均情况下排序最快考虑，则应选取（）方法，若只从最坏情况下排序最快并节省内存，则应选取（）方法。
三、简答题
1、简要回答下列问题：
（1）什么是内部排序、外部排序？（2）什么是排序方法的稳定性？
2、已知序列（70，83，100，65，10，32，7，9），请给出采用插入排序、快速排序和
冒泡排序方法对该序列做升序排序的每一趟的结果。
3、有如下一组关键字（25，67，78，24，38，64，55，22，15，48），判定其是否为
堆，若不是堆，请调整为一个小根堆，使堆排序将按关键字从大到小排列，写出调整过程。
习题答案
一、选择题
1C 2A 3AEFH 4CEI 5CB 6D 7D 8B 9C 10C 11B
12D 13C 14A 15BC 16DA 17B 18BD
二、填空题
1、直接插入排序、直接选择排序
2、6，7
3、3n(n-1)/2,0
4、n(n-10)/2
5、(50,60,40,20)
6、(1)直接插入排序（2）O(n2) ，堆排序(3)快速排序
7、堆排序，快速排序，归并排序，归并排序，快速排序，堆排序
三、简答题
1、P263
2、采用插入排序的各趟结果如下：
（1）（70，83），100，65，10，32，7，9
（2）（70，83，100），65，10，32，7，9
（3）（65，70，83，100），10，32，7，9
（4）（10，65，70，83，100），32，7，9
（5）（10，32，65，70，83，100），7，9
（6）（7，10，32，65，70，83，100），9
（7）（7，9，10，32，65，70，83，100）
其他排序略
3、略。