数据结构作业系统第十章答案教学文稿Word文档格式.docx
《数据结构作业系统第十章答案教学文稿Word文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构作业系统第十章答案教学文稿Word文档格式.docx（10页珍藏版）》请在冰豆网上搜索。
0;
i--）
{
L.r[L.length+1]=L.r[i+1];
if（GT（L.r[i],L.r[i+1]））
L.r[L.length+1]=L.r[i];
L.r[i]=L.r[i+1];
}
for（j=i+2;
LT（L.r[j],L.r[L.length+1]）;
j++）
L.r[j-1]=L.r[j];
L.r[j-1]=L.r[L.length+1];
}
10.26②如下所述改写教科书1.4.3节中的起泡排序算法：
将算法中用以起控制作用的布尔变量change改为一个整型变
量，指示每一趟排序中进行交换的最后一个记录的位置，并
以它作为下一趟起泡排序循环终止的控制值。
voidBubbleSort（SqList&
/*元素比较和交换必须调用以下比较函数和交换函数：
*/
/*StatusLT（RedTypea,RedTypeb）;
比较：
"
<
*/
/*StatusGT（RedTypea,RedTypeb）;
>
/*voidSwap（RedType&
a,RedType&
b）;
交换*/
比较函数和交换函数:
StatusLT（RedTypea,RedTypeb）;
//比较函数：
StatusGT（RedTypea,RedTypeb）;
voidSwap（RedType&
//交换函数
/*元素比较和交换必须调用如下定义的比较函数和交换函数：
inti,j,change=1;
for（i=L.length;
1;
i=change）
{
change=1;
for（j=1;
j<
i;
if（GT（L.r[j],L.r[j+1]））
Swap（L.r[j],L.r[j+1]）;
change=j;
}
10.32⑤荷兰国旗问题：
设有一个仅由红、白、兰
这三种颜色的条块组成的条块序列。
请编写一个时
间复杂度为O（n）的算法，使得这些条块按红、白、
兰的顺序排好，即排成荷兰国旗图案。
voidHFlag（FlagList&
f）
/*"
荷兰国旗"
的元素为red，white和blue，*/
/*分别用字符'
0'
'
1'
和'
2'
表示*/
的顺序表的类型FlagList定义如下：
#definered'
#definewhite'
#defineblue'
typedefcharColorType;
typedefstruct{
ColorTyper[MAX_LENGTH+1];
}FlagList;
voidswap（ColorType&
a,ColorType&
b）
ColorTypetemp;
temp=a;
a=b;
b=temp;
inti,j,k;
charc;
for（i=1,j=1,k=f.length;
=k;
）
c=f.r[j];
if（c==red）
swap（f.r[i++],f.r[j++]）;
if（c==white）
j++;
if（c==blue）
swap（f.r[j],f.r[k--]）;
10.34③已知（k1,k2,...,kp）是堆，则可以写一个时
间复杂度为O（log（n））的算法将（k1,k2,...,kp,kp+1）
调整为堆。
试编写"
从p=1起，逐个插入建堆"
的算法，
并讨论由此方法建堆的时间复杂度。
voidCreateHeap（HeapType&
h,char*s）;
堆（顺序表）的类型HeapType定义如下：
typedefcharKeyType;
......
}SqList,HeapType;
h,char*s）
inti,j,locate,k;
KeyTypee;
h.length=0;
for（i=0;
s[i]!
='
\0'
;
i++）
h.length++;
h.r[h.length].key=s[i];
e=h.r[h.length].key;
locate=h.length;
k=h.length/2;
for（j=h.length;
k>
j=j/2,k=j/2）
if（e<
h.r[k].key）
h.r[j].key=h.r[k].key;
locate=k;
h.r[locate].key=e;
10.35③假设定义堆为满足如下性质的完全三叉树：
（1）空树为堆；
（2）根结点的值不小于所有子树根的值，且所有子树
均为堆。
编写利用上述定义的堆进行排序的算法，并分析推导
算法的时间复杂度。
voidHeapSort（HeapType&
h）;
StatusLT（RedTypea,RedTypeb）
{returna.key<
b.key?
TRUE:
FALSE;
StatusGT（RedTypea,RedTypeb）
{returna.key>
{RedTypec;
c=a;
b=c;
voidHeapAdjust（HeapType&
H,ints,intm）
{
intj,flag;
RedTyperc;
rc=H.r[s];
for（j=3*s-1;
=m;
j=3*j-1）
flag=0;
printf（"
Do%d\n"
j）;
if（j<
m&
&
LT（H.r[j],H.r[j+1]））{j++;
flag=1;
printf（"
）;
if（flag）{if（j<
LT（H.r[j],H.r[j+1]））j++;
elseif（j+1<
LT（H.r[j],H.r[j+2]））j=j+2;
if（!
LT（rc,H.r[j]））break;
H.r[s]=H.r[j];
s=j;
H.r[s]=rc;
h）
inti;
//printf（"
%d"
h.length）;
for（i=（h.length+1）/3;
HeapAdjust（h,i,h.length）;
%d,OK\n"
i）;
for（i=h.length;
Swap（h.r[1],h.r[i]）;
HeapAdjust（h,1,i-1）;
10.42④序列的"
中值记录"
指的是：
如果将此序列排序
后，它是第n/2个记录。
试写一个求中值记录的算法。
KeyTypeMidElement（SqList&
inti,j,k,n;
RedTypetemp;
if（L.length==0）return'
#'
for（i=1;
i<
L.length;
k=i;
temp=L.r[i];
for（j=i+1;
=L.length;
if（temp.key>
L.r[j].key）
temp=L.r[j];
k=j;
L.r[i]=L.r[k];
L.r[k]=temp;
if（L.length%2==0）n=L.length/2;
elsen=L.length/2+1;
returnL.r[n].key;
10.43③已知记录序列a[1..n]中的关键字各不相同，
可按如下所述实现计数排序：
另设数组c[1..n]，对每
个记录a[i]，统计序列中关键字比它小的记录个数存
于c[i]，则c[i]=0的记录必为关键字最小的记录，然
后依c[i]值的大小对a中记录进行重新排列，试编写算
法实现上述排序方法。
voidCountSort（SqList&
/*采用顺序表存储结构，L.r存储序列a，L.length为n*/
/*在函数内自行定义计数数组c*/
inti,j,count;
intc[100];
SqLists;
count=0;
if（L.r[i].key>
count++;
c[i-1]=count;
s.r[i]=L.r[i];
s.length=L.length;
L.r[c[i]+1]=s.r[i+1];
升级会员 