线性表习题解答.docx
《线性表习题解答.docx》由会员分享，可在线阅读，更多相关《线性表习题解答.docx（15页珍藏版）》请在冰豆网上搜索。
线性表习题解答
第2章习题
第2章习题
2.1若将顺序表中记录其长度的分量listlen改为指向最后一个元素的位置last,在实现各基本运算时需要做那些修改？
【解】
〃用线性表最后一个元素的下标last代替listLen实现顺序表
#defiiieMAXLEN100
typedefintelementType;
typedefstiuctsllLast
{
elementTypedata[N!
AXLEN];
iiitlast;
}seqList;
〃初始化
voiduiitialList（seqList&S）
{
S」ast=-l;
}
〃求表长度
intlistLengtli（seqListS）
{
returnS.last+1;
}
〃按序号取元素
boolgetElement（seqListSjnti^elementType&x）
{
if（Kl||i>S.last+l）//i为元素编号，有效范围在1-S.last+l之间
returnfalse;
else
x=S.data[i-l];returntnie;
〃查找元素x,成功：
返回元素编号；失败：
返回0
intlistLocate（seqListS,elementTypex）
{
mti;
fbr（i=O;i<=S.last;i++）
{
if（S.data[i]==x）
retuini+1;//找到，转换为元素编号输出
}
return0;
}
〃插入元素
intlistIiisen（seqList&S^elementTvpex,inti）
{
iiitk;
if（S.last>MAXLEN-l）return0;〃表满，返回0elseif（iS.last+2）
return1;//插入位置查处范围，返回1
else
{
fbr（k=S.last;k>=i-l;k—）
S.data[k+l]=S.data[k];S.data[i-l]=x;
S.last++;
return2;
}
}
〃删除元素
intlistDelete（seqList&S.inti）
{
iiitk;
if（S.last=-l）
return0;〃空表，返回0
elseif（iS.last+l）
return1;〃删除元素编号超出范围，返回1
else
for（k=i;k<=S.last;k++）
S.data[k-l]=S.data[k];
S」ast—;
return2;
}
}
//7.打印表中所有元素
voidpiiiitList（seqListL）
{
mti;
fbr（i=O;i<=L.last;i++）
cout«L.data[i]«^'\t,,;〃元素之间以制表符分割cout«endl;
}
//&交互输入数据元素-特殊输入结束
voidlistIiiputC（seqList&L）
{
if（L.last>=0）
{
cout«"顺序表已经存在，请先初始化，再输入元素。
”《endl;letuni;
}
elementTypex;
cout«“请输入数据元素（整数，-9999退出）：
-'«endl;
cout«Hx=H;
cin»x;
wlule（x?
=-9999）
{
L.last++;
L.data[L.last]=x;
cout«Hx=H;cin»x;
〃随机数创建顺序表voidrndCList（seqList&L）
mti;
iiitn,m;
L.last=-1;
cout«“请输入要产生的随机数个数，11=";
ciii»n;
if（n>MAXLEN-l）
{
cout«"您要求产生的随机数个数超出了查找表长度••«MAXLEN-1«H,创建顺序表失败<>"«endl;
return;
}
cout«”请输入控制随机数人小参数，比如100以内数，请输入100,m=“；ciii»m;
srand（（unsigned）tune（NULL））;〃产生随机数种子//siand（（unsigiied）GetTickCount（））;〃产生随机数种子
for（i=0;iL.data[i]=rand（）%m;
L.last=n-1;〃表长度为n
cout«endl;
2.2试用顺序表表示较多位数的大整数，以便于这类数据的存储。
请选择合适的存放次序，并分别写出这类人数的比较、力口、减、乘、除等运算，并分析算法的时间性能。
【解】顺序表0单元存放操作数的符号，区分操作数是正数还是负数；为方便处理运算时进位和借位，数据的低位存放数组低位，高位存放数组高位。
【时间性能】
加减法：
O（max（m、n））
乘除法：
O（mxn）
2.3试用顺序表表示集合，并确定合适的约定，在此基础上编写算法以实现集合的交、并、差等运算，并分析各算法的时间性能。
【解】
〃求C=AQE
依次读取A的元素，检查次元素是否在E中，若在B中，则为交集元素，插入C中。
voidiiiterSet（seqListA,seqListB,seqList&C）
{
mti;
fbr（i=O;i{
if（listLocate（B,A.data[i]）!
=0）//A.data[i]在B中出现，是交集元素，插入C中listliisert（&C,A.data[i],C.listLen+1）;
}
}
//^C=AUB
现将A中元素全部插入C中。
依次读取B中元素，检查是否出现在A中，若不在A中,则为并集元素，插入C中。
voidmergeSet（seqListA,seqListB,seqList&C）
{
mti;
for（i=0;i{
listInsert（&C,A.data[i],C.listLen+l）;
}
for（i=0;ii++）
{
if（listLocate（A,B.data[i]）=0）//B.data[i]不在A中，插入Clistliiseit（&CE.data[i],C.listLen+1）;
}
}
〃求C=A-B
依次读取A中元素，检查是否在E中出现，若不在E中，则为差集元素，插入C中。
voiddifferenceSet（seqListA,seqListB,seqList&C）
{
mti;
fbr（i=O;i{
if（listLocate（B,A.data[i]）=0）
listIiisert（&C,A.data[i],C.listLen+l）;//A.data[i]不在B中,插入C
【算法分析】
时间复杂度：
0（|A|X|B|）
2.4假设顺序表L中的元素递增有序，设计算法在顺序表中插入元素x,要求插入后仍保持其递增有序特性，并要求时间尽可能少。
【解】
如果表空间满，插入失败，返回-1：
否则，从L最后一个元素开始，与x比较，若大于x,元素后移，直到L中元素小于或等于x,这个元素的后面的单元即为x的插入位置，插入成功返回插入位置。
〃空间满：
返回值」；正确插入：
返回表中的插入位置
mtmcInseit（seqList&L,elementTypex）
{
iiiti=L.listLen-l;
if（L.listLen==MAXLEN）
return-1;〃表空间已满，不能插入新的元素
else
{
while（i>=0&&L.data[i]>x）
{
L.data[i+1]=L.data[i];
i-S
}
}
L.data[i+l]=x;〃插入x
L.listLen++;〃修改表长度
return1+2;〃成功插入，返回x在顺序表中的插入位置（元素编号）
}
【算法分析】
时间复杂度：
O（n）
2.5假设顺序表L中的元素递增有序，设计算法在顺序表中插入元素x,并要求在插入后也没有相同的元素，即若表中存在相同的元素，则不执行插入操作。
【解】
与上题相似，只是在移动插入元素之前，检查L中是否已经存在值x,若存在，插入失败，返回-2。
〃空间满：
返回值」：
x已经存在返回・2；正确插入：
返回表中的插入位置
mtmcInseit（seqList&L,elementTypex）
mti;
//表空间已满，不能插入新的元素
〃元素x已经存在，插入失败，返回・2
〃后移元素
if（L.listLen==MAXLEN）return-1;
else
fbr（i=O;ii=L.listLen-l;while（i>=0&&L.data[i]>x）{
L.data[i+l]=L.data[i];
}
}L.data[i+l]=x;〃插入x
L.listLen++；〃修改表长度
return1+2;〃成功插入，返回x在顺序表中的插入位置（元素编号）}
2.6设计算法以删除顺序表中重复的元素，并分析算法的时间性能。
【解】
【分析】
三重循坏实现。
第一层循坏，从左往右依次取出L元素，用1指示；第二层循坏，对］元素在L中循环查重，用下标J指示；第三重循环，删除重复元素。
查重和删除从j=L.listLen-l始，效率稍微好一点，因为这样重复元素本身不需重复移动。
如果从1+1开始查重、删除，则J+1以后的重复元素会被移动。
【算法描述】
voidDeleteRepeatData（seqList&L）
{
inti,j；
if（L.listLen==O）
{
cout«H当前顺序表空！
yxeturn:
}
if（L.listLen==l）
cout«H^前顺序表只有一个元素！
“vvendl;
xeturn:
}
1=0；
wliile（i{
for（j=L.listLen-l;j>i;j-）〃从后往前删除，效率较高
{
if（L.data[i]==L.data|j]）〃元素重复，调用删除
{hstDelete（&L,j+l）;//调用删除函数，下标差1,所以+1〃以下部分代码是直接删除，没有调用删除函数
//intk;
//foi（k=j;k//L.data[k]=L.data[k+l];
//L.listLen—;
}
}
i++；
}
}
【算法分析】时间性能：
O（i?
）
2.7假设顺序表L中的元素按从小到大的次序排列，设计算法以删除表中重复的元素，并要求时间尽可能少。
要求：
（1）对顺序表（1,1,2,2,2,3,4,5,5,5,6,6,7,7,8,&&9）模拟执行本算法，并统计移动元素的次数。
（2）分析算法的时间性能。
【解】
【分析】
将元素分成两个部分：
已经处理元素和待处理元素。
已经处理部分返回L中，用下标1指示最后一个元素，初始化1=0。
待处理部分用下标j指示第一个元素，初始化J=l.
左边卞标小于1的元素已经处理好重复，等于1是当前正在处理的元素，将data[i]与datajj]进行比较，会出现下列情况：
（Ddata[i]==data|j].说明j指示的是]的重复元素，继续处理j的下一个元素，即执行
j++。
②data[i]=j，将j元素复制到i+1,
即：
L.data[i+l]=L.data|j],再执行j++,i++；若i+l=j，说明j是i的直接后继，无需复制，直接执行i++，j++o
循环执行上述操作，直到表尾。
（3）A.data[ia]>B.data[ib],当前元素为非交集元素，只需移动ib,即ib++
重复以上过程，直至A、B中至少一个表结束。
修改A表长度为i+1。
【算法描述】
voidIiiterSet（seqList&A,seqList&E）
{
〃为了最后更新交集元素表长度操作一致，初始化为-1
mtia=0,ib=0;//A、E表当前元素的数组卜-标
wlule（ia{
if（A.data[ia]=B.data[ib]）//ia和lb指示的是交集元素
{
if（ia!
=i+l）〃山元素复制到i+l,否则ia位置即目标位置，不需复制元素A.data[i+l]=A.data[ia];
1卄；
ia++;ib++;
}
elseif（A.data[ia]ia++;
else
ib++;
}A.listLen=i+l;〃更新A表长度，使等于交集元素个数。
}
2.9递增有序顺序表A、E分别表示一个集合，设计算法求解A=A—E,并分析其时间性能。
【解】【分析】
审题：
A=A-B,即要求要利用A表的空间保存差集元素，而不是创建一个新表。
设置两个指针ia、ib分别指向A、B表当前处理的元素；
设置一个指针1指示已经求取的差集元素在A的表中的最后元素位置；
比较A、E表当前元素，会出现以下三种情况
（1）A.data[ia]=B.data[ib],贝IIia或ib是交集元素,不是A-E中元素，直接跳过，修改指针•：
ia++,ib++。
（2）A.data[ia]>B.data[ib],ia指示的元素可能在B表ib指示的元素后面，ia不动，移动ib,即ib++a
（3）A.data[ia]需要的话迁移到目标位置，即（i+l）!
=ia时，执行A.data[i+l]=A.data[ia]。
若（i+l）==ia,ia即为目标位置，无需复制迁移。
迁移完成，移动指示器：
1++,山卄。
重复以上过程，直至A、B中至少一个表结束。
还有一种情况：
B表已结束，但A表尚未结束，说明A剩下元素不在B中，全为A-E中元素，全部迁移到目标位置。
最后，修改A表长度为i+1。
【算法描述】
voidSetSubtiaction（seqList&A,seqList&E）
{
mti=-l;〃指示A中已经处理的最后元素
mtia=0,ib=0;〃指示A、E中，当前待处理的元素，初始指向第一个元素while（ia{
if（A.data[ia]==B.data[ib]）〃非A-E中元素，ia、ib同时后移
{
ia++;
ib++;
}
elseif（A.data[ia]>B.data[ib]）
ib-H-;〃此时，指示元素可能在B中lb指示的元素后面，移动ib。
else〃此为，A.data[ia]{〃所以ia指示元素必在A-B中。
〃如果（i+l）==ia,说明山元素不需迁移位置，直接为A-E中元素if（i+l!
=ia）//（i+l!
=ia）,需要将ia指示元素迁移到目标位置i+1A.data[i+l]=A.data[ia];
1++；〃A-B集合最后元素指示器后移
ia++;〃A的指示器后移
}
}
〃处理E已经，A尚未结束情况，A中剩下部分元素全部为A-E元素while（ia{
if（i+l!
=ia）
A.data[i+1]=A.data[ia];
i++;〃A-E集合最后元素指示器后移
m++;//A的指示器后移
}
A.listLen=i+l;〃更新表A的长度，使等于|A-E|
}
【算法分析】时间性能O（|A|+|B|）
【思考问题】A、B两表谁先结束？
下面是本题的另一种解法，因为用到A表中交集元素的删除，所以效率较差。
【算法描述-1】
voidSetSubtiaction1（seqList&A,seqList&B）
{
mtia=0,ib=0;〃ia、lb扌旨示A、E表中当前元素。
初始指向第一个元素。
while（ia{
if（A.data[ia]ia++;
elseif（A.data[ia]>B.data[ib]）//A元素可能在B中,移动B到下一个元素{
ib++;
if（ib>=B.listLen）
break;
}
else//A.data[ia]=B.data[ib],删除A中元素，同时移动指针
{
listDelete（&A,ia+1）;
//ia++;不能增加ui,因为A已经往前移动一个元素
ib++;
if（ib>=B.listLen）
break;
}
}
}
【算法分析】时间性能O（|A|+|B|）
升级会员 