第7章排序习题参考答案Word格式.docx
- 文档编号:16498614
- 上传时间:2022-11-24
- 格式:DOCX
- 页数:15
- 大小:81.22KB
第7章排序习题参考答案Word格式.docx
《第7章排序习题参考答案Word格式.docx》由会员分享,可在线阅读,更多相关《第7章排序习题参考答案Word格式.docx(15页珍藏版)》请在冰豆网上搜索。
A.2B.4
8.从待排序的序列中选出关
(B)。
A.希尔排序B.直接选择排序
9.当待排序序列基本有序时,以下排序方法中,
A.直接选择排序B.
55,100,)次。
38,40,84),则利用快速排序的方法,以第一)。
B.(40,38,46,79,56,84)
D.(40,38,46,84,56,79)
33,65,50,40,95},进行直接插入排序
15,
键字值最大的
C.6
记录放到有序
C.冒泡排序
D.8
序列中,该排序方法称为
D.快速排序
(B)最不利于其优势的发挥。
(
直接插入排序C.快速排序
快速排序
10.在待排序序列局部有序时,效率最咼的排序算法是
二、填空题
1.执行排序操作时,根据使用的存储器可将排序算法分为
D.直接插入排序
D.归并排序
内排序和外排序
2.在对一组记录序列{50,40,95,20,15,70,60,45,80}进行直接插入排序时,
60插入到有序表中时,为寻找插入位置需比较3次。
3.在直接插入排序和直接选择排序中,若初始记录序列基本有序,则选用序。
O
当把第7个记录
直接插入排
4.在对一组记录序列{50,40,95,20,15,70,60,45,80}进行直接选择排序时,
择后,未排序记录为{50,70,60,95,80}。
5.n个记录的冒泡排序算法所需的最大移动次数为
第4次交换和选
3n(n-1)/2,最小移动次数为
0。
6.对n个结点进行快速排序,最大的比较次数是n(n-1)/2。
7.对于堆排序和快速排序,若待排序记录基本有序,则选用堆排序。
8.在归并排序中,若待排序记录的个数为20,则共需要进行5趟归并。
9.若不考虑基数排序,则在排序过程中,主要进行的两种基本操作是关键字的比较
和数据元素的移动。
10.在插入排序、希尔排序、选择排序、快速排序、堆排序、归并排序和基数排序中,
平均比较次数最少的是快速排序,需要内存容量最多的是基数排序。
三、算法设计题
1.试设计算法,用插入排序方法对单链表进行排序。
参考答案:
publicstaticvoidinsertSort(LinkListL){
Nodep,q,r,u;
p=L.getHead().getNext();
L.getHead().setNext(null);
//置空表,然后将原链表结点逐个插入到有序表中
while(p!
=null){II当链表尚未到尾,p为工作指针
r=L.getHead();
q=L.getHead().getNext();
while(q!
=null&
&
(Integer.parseInt((String)q.getData()))<
=
(Integer.parseInt((String)p.getData()))){
II查P结点在链表中的插入位置,这时q是工作指针
r=q;
q=q.getNext();
}
u=p.getNext();
p.setNext(r.getNext());
r.setNext(p);
p=u;
II将P结点链入链表中,r是q的前驱,u是下一个待插入结点的指针
}2.试设计算法,用选择排序方法对单链表进行排序。
参考答案:
II单链表选择排序算法
publicstaticvoidselectSort(LinkListL){
IIp为当前最小,r为此过程中最小,q为当前扫描接点
Nodep,r,q;
NodenewNode=newNode();
newNode.setNext(L.getHead());
L.setHead(newNode);
II制造一个最前面的节点newNode解决第一个节点的没有前续节点需要单独
语句的问题。
p=L.getHead();
while(p.getNext().getNext()!
=null){
r=p.getNext();
q=p.getNext().getNext();
while(q.getNext()!
=null){
if(Integer.parseInt((String)q.getNext().getData())<
=(Integer.parseInt((String)r.getNext().getData()))){
if(r!
=p){//交换p与r
Nodeswap=r.getNext();
r.setNext(r.getNext().getNext());
//r的next指向其后继的后继
swap.setNext(p.getNext());
p.setNext(swap);
//p的后继为swap}p=p.getNext();
}//whilep.setNext(null);
3.试设计算法,实现双向冒泡排序(即相邻两遍向相反方向冒泡)。
参考答案:
//产生随机数方法
publicstaticint[]random(intn){
if(n>
0){
inttable[]=newint[n];
for(inti=0;
i<
n;
i++){
table[i]=(int)(Math.random()*100);
//产生一个0~100之间的随机数
}returntable;
returnnull;
//输出数组元素方法publicstaticvoidprint(int[]table)
{
if(table.length>
table.length;
i++){System.out.print(table[i]+"
"
);
}System.out.println();
//双向冒泡排序方法
publicstaticvoiddbubblesort(int[]table){inthigh=table.length;
intleft=1;
intright=high-1;
intt=0;
do{
//正向部分
for(inti=right;
i>
=left;
i--){if(table[i]<
table[i-1]){inttemp=table[i];
table[i]=table[i-1];
table[i-1]=temp;
t=i;
left=t+1;
//反向部分
for(inti=left;
right+1;
i++){if(table[i]<
right=t-1;
}while(left<
=right);
4.试设计算法,使用非递归方法实现快速排序。
publicstaticvoidNonrecursiveQuickSort(int[]ary){if(ary.length<
2){
return;
//数组栈:
记录着高位和低位的值int[][]stack=newint[2][ary.length];
//栈顶部位置
inttop=0;
//低位,高位,循环变量,基准点
//将数组的高位和低位位置入栈stack[1][top]=ary.length-1;
stack[0][top]=0;
top++;
//要是栈顶不空,那么继续
while(top!
=0){
//将高位和低位出栈
//低位:
排序开始的位置
top--;
intlow=stack[0][top];
//高位:
排序结束的位置
inthigh=stack[1][top];
//将高位作为基准位置
//基准位置
intpivot=high;
inti=low;
for(intj=low;
j<
high;
j++){
if(ary[j]<
=ary[pivot]){
inttemp=ary[j];
ary[j]=ary[i];
ary[i]=temp;
i++;
//如果i不是基准位,那么基准位选的就不是最大值
//而i的前面放的都是比基准位小的值,那么基准位
//的值应该放到i所在的位置上
if(i!
=pivot){
inttemp=ary[i];
ary[i]=ary[pivot];
ary[pivot]=temp;
if(i-low>
1){
//此时不排i的原因是i位置上的元素已经确定了,i前面的都是比i小的,i后面的都是比i大的
stack[1][top]=i-1;
stack[0][top]=low;
//当high-i小于等于1的时候,就不往栈中放了,这就是外层while循环能结束的原因
//如果从i到高位之间的元素个数多于一个,那么需要再次排序
if(high-i>
stack[1][top]=high;
stack[0][top]=i+1;
5.试设计算法,判断完全二叉树是否为大顶堆。
booleancheckmax(BiTreeNodet)//判断完全二叉树是否为大顶堆{
BiTreeNodep=t;
if(p.getLchild()==null&
p.getRchild()==null){returntrue;
}else{
if(p.getLchild()!
=null&
p.getRchild()!
if((((RecordNode)p.getLchild().getData()).getKey()).compareTo(((RecordNode)p.getData()).getKey())<
=0&
(((RecordNode)p.getRchild().getData()).getKey()).compareTo(((RecordNode)p.getData()).getKey())<
returncheckmax(p.getLchild())&
checkmax(p.getRchild());
}else
returnfalse;
}elseif(p.getLchild()!
p.getRchild()==null){
returncheckmax(p.getLchild());
}elseif(p.getLchild()==null&
if((((RecordNode)p.getRchild().getData()).getKey()).compareTo(((RecordNode)p.getData()).getKey())<
returncheckmax(p.getRchild());
}else{returnfalse;
四、上机实践题
1.编写程序,对直接插入排序、希尔排序、冒泡排序、快速排序、直接选择排序、堆排序和归并排序进行测试。
参考答案:
packagech07Exercise;
importch07.*;
importjava.util.Scanner;
publicclassExercise7_4_1{
publicstaticvoidmain(String[]args)throwsException{
int[]d={52,39,67,95,70,8,25,52};
int[]dlta={5,3,1};
//希尔排序增量数组
SeqListL=newSeqList(maxSize);
//for(inti=0;
d.length;
RecordNoder=newRecordNode(d[i]);
L.insert(L.length(),r);
System.out.println("
排序前:
Scanners=newScanner(System.in);
intxz=s.nextInt();
switch(xz){
case1:
直接插入排序
L.insertSort();
break;
//case2:
L.shellSort(dlta);
break;
case3:
//
希尔排序
冒泡排序
直接选择排序
堆排序
归并排序
排序后:
"
L.bubbleSort();
//
case4:
L.quickSort();
case5:
L.selectSort();
case6:
L.heapSort();
//break;
case7:
L.mergeSort();
System.out.println("
L.display();
运行结果:
2•编写程序,对带监视哨的直接插入排序进行测试。
packagechO7Exercise;
importch07.RecordNode;
importchO7.SeqList;
publicclassExercise7_4_2extendsSeqList{
publicExercise7_4_2(intmaxSize){
super(maxSize);
publicvoiddisplay(){//输出数组元素
for(inti=1;
length();
System.out.print("
+getRecord()[i].getKey().toString());
System.out.println();
int[]d={52,39,67,95,70,8,25,52};
intmaxSize=20;
//顺序表空间大小
SeqListL=newExercise7_4_2(maxSize);
//建立顺序表
RecordNoder=newRecordNode(O);
L.insert(L.length(),r);
d.length;
r=newRecordNode(d[i]);
System.out.println(”排序前:
”);
L.display();
L.insertSortWithGuard();
System.out.println(”排序后:
运行结果:
3.编写程序,要求随机生成10000个数,并比较直接插入排序、直接选择排序、冒泡排序、快速排序和堆排序的排序性能。
importch07.*;
publicclassExercise7_4_3{
staticintmaxSize=10000;
//排序关键码个数publicstaticvoidmain(String[]args)throwsException{
int[]d=newint[maxSize];
maxSize;
d[i]=(int)(Math.random()*100);
直接插入排序所需时间:
+testSortTime(L,'
i'
)+"
冒泡排序所需时间:
b'
)+快速排序所需时间:
q'
)+直接选择排序所需时间:
s'
堆排序所需时间:
h'
privatestaticSeqListcreateList(int[]d)throwsException{
//建立顺序表for(inti=0;
L.insert(L.length(),r);
returnL;
publicstaticlongtestSortTime(SeqListL,charsortmethod){longstartTime,endTime,testTime;
startTime=System.currentTimeMillis();
switch(sortmethod){
case'
:
L.heapSort();
endTime=System.currentTimeMillis();
testTime=endTime-startTime;
returntestTime;
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 排序 习题 参考答案