第4—5章自测卷答案.doc

第4～5章 串和数组 自测卷答案 姓名 班级

题号
一
二
三
四
五
总分
题分
20
15
20
15
30
100
得分

一、填空题（每空1分，共20分）
1. 不包含任何字符（长度为0）的串 称为空串； 由一个或多个空格（仅由空格符）组成的串 称为空白串。

2. 设S=“A;/document/Mary.doc”，则strlen(s)= 20 , “/”的字符定位的位置为 3 。

4. 子串的定位运算称为串的模式匹配； 被匹配的主串 称为目标串， 子串 称为模式。

5. 设目标T=”abccdcdccbaa”，模式P=“cdcc”，则第 6 次匹配成功。

6. 若n为主串长，m为子串长，则串的古典（朴素）匹配算法最坏的情况下需要比较字符的总次数为 (n-m+1)*m 。

7. 假设有二维数组A6×8，每个元素用相邻的6个字节存储，存储器按字节编址。已知A的起始存储位置（基地址）为1000，则数组A的体积（存储量）为 288 B ；末尾元素A57的第一个字节地址为 1282 ；若按行存储时，元素A14的第一个字节地址为 (8+4)×6+1000=1072 ；若按列存储时，元素A47的第一个字节地址为 (6×7＋4)×6＋1000）＝1276 。
(注：数组是从0行0列还是从1行1列计算起呢？由末单元为A57可知，是从0行0列开始！)

8.设数组a[1…60, 1…70]的基地址为2048，每个元素占2个存储单元，若以列序为主序顺序存储，则元素a[32,58]的存储地址为 8950
。
答：不考虑0行0列，利用列优先公式： LOC(aij)=LOC(ac1，c2)+[(j-c2)*(d1-c1+1)+i-c1)]*L
得：LOC(a32,58)=2048+[(58-1)*(60-1+1)+32-1]]*2＝8950

9. 三元素组表中的每个结点对应于稀疏矩阵的一个非零元素，它包含有三个数据项，分别表示该元素
的 行下标 、 列下标 和 元素值 。

10.求下列广义表操作的结果：
（1） GetHead【((a,b),(c,d))】=== (a, b) ; //头元素不必加括号
（2） GetHead【GetTail【((a,b),(c,d))】】=== (c,d) ;
（3） GetHead【GetTail【GetHead【((a,b),(c,d))】】】=== b ;
（4） GetTail【GetHead【GetTail【((a,b),(c,d))】】】=== （d） ;

二、单选题（每小题1分，共15分）
（ B ）1.串是一种特殊的线性表，其特殊性体现在：
Ａ．可以顺序存储 Ｂ．数据元素是一个字符
Ｃ．可以链式存储 Ｄ．数据元素可以是多个字符

（ B ）2.设有两个串p和q，求q在p中首次出现的位置的运算称作：
Ａ．连接 Ｂ．模式匹配 Ｃ．求子串 Ｄ．求串长

（ D ）3.设串s1=’ABCDEFG’，s2=’PQRST’，函数con(x,y)返回x和y串的连接串，subs(s, i, j)返回串s的从序号i开始的j个字符组成的子串，len(s)返回串s的长度，则con(subs(s1, 2, len(s2)), subs(s1, len(s2), 2))的结果串是：
Ａ．BCDEF Ｂ．BCDEFG Ｃ．BCPQRST Ｄ．BCDEFEF
解：con(x,y)返回x和y串的连接串，即 con(x,y)＝‘ABCDEFGPQRST’；
subs(s, i, j)返回串s的从序号i开始的j个字符组成的子串，则
subs(s1, 2, len(s2))＝subs(s1, 2, 5)=’ BCDEF’; subs(s1, len(s2), 2)＝subs(s1, 5, 2)=’ EF’;
所以con(subs(s1, 2, len(s2)), subs(s1, len(s2), 2))＝con(’ BCDEF’, ’ EF’)之连接，即BCDEFEF

（ A ）4.假设有60行70列的二维数组a[1…60, 1…70]以列序为主序顺序存储，其基地址为10000，每个元素占2个存储单元，那么第32行第58列的元素a[32,58]的存储地址为 。（无第0行第0列元素）
Ａ．16902 Ｂ．16904 Ｃ．14454 Ｄ．答案A, B, C均不对
答：此题与填空题第8小题相似。（57列×60行＋31行）×2字节＋10000=16902

( B )5. 设矩阵A是一个对称矩阵，为了节省存储，将其下三角部分（如下图所示）按行序存放在一维数组B[ 1, n(n-1)/2 ]中，对下三角部分中任一元素ai,j(i≤j), 在一维数组B中下标k的值是：
Ａ．i(i-1)/2+j-1 Ｂ．i(i-1)/2+j Ｃ．i(i+1)/2+j-1 Ｄ．i(i+1)/2+j
解：注意B的下标要求从1开始。
先用第一个元素去套用，可能有B和C；
再用第二个元素去套用B和C，B=2而C＝3（不符）；
所以选B

6. 从供选择的答案中，选出应填入下面叙述 ？ 内的最确切的解答，把相应编号写在答卷的对应栏内。
有一个二维数组A，行下标的范围是0到8，列下标的范围是1到5，每个数组元素用相邻的4个字节存储。存储器按字节编址。假设存储数组元素A[0,1]的第一个字节的地址是0。
存储数组A的最后一个元素的第一个字节的地址是 A 。若按行存储，则A[3,5]和A[5,3]的第一个字节的地址分别是 B 和 C 。若按列存储，则A[7,1]和A[2,4]的第一个字节的地址分别是 D 和 E 。
供选择的答案：
A～E：①28 ② 44 ③ 76 ④ 92 ⑤ 108
⑥ 116 ⑦ 132 ⑧ 176 ⑨ 184 ⑩ 188
答案：ABCDE=8, 3, 5, 1, 6

7. 有一个二维数组A，行下标的范围是1到6，列下标的范围是0到7，每个数组元素用相邻的6个字节存储，存储器按字节编址。那么，这个数组的体积是 A 个字节。假设存储数组元素A[1,0]的第一个字节的地址是0，则存储数组A的最后一个元素的第一个字节的地址是 B 。若按行存储，则A[2,4]的第一个字节的地址是 C 。若按列存储，则A[5,7]的第一个字节的地址是 D 。
供选择的答案
A～D：①12 ② 66 ③ 72 ④ 96 ⑤ 114 ⑥ 120
⑦ 156 ⑧ 234 ⑨ 276 ⑩ 282 （11）283 （12）288
答案：ABCD=12, 10, 3, 9

三、简答题（每小题5分，共15分）
1. KMP算法的设计思想是什么？它有什么优点？
答：其设计思想是，利用已经部分匹配的结果来加快模式串的滑动速度
。
主要优点有二：一是在模式与主串已经部分匹配的情况下，可以大大加快匹配速度；二是主串指针不回溯，可以使外设文件边读入边匹配。

2.已知二维数组Am,m采用按行优先顺序存放，每个元素占K个存储单元，并且第一个元素的存储地址为Loc(a11)，请写出求Loc(aij)的计算公式。如果采用列优先顺序存放呢？
解：
按行存储的元素地址公式是： Loc(aij)= Loc(a11) +[ (i-1)*m+(j-1) ] * K
按列存储的元素地址公式是： Loc(aij)= Loc(a11) +[ (j-1)*m+(i-1) ] * K

3.递归算法比非递归算法花费更多的时间，对吗？为什么？
答：不一定。时间复杂度与样本个数n有关，是指最深层的执行语句耗费时间，而递归算法与非递归算法在最深层的语句执行上是没有区别的，循环的次数也没有太大差异。仅仅是确定循环是否继续的方式不同，递归用栈隐含循环次数，非递归用循环变量来显示循环次数而已。

四、计算题（每题5分，共20分）
1. 设s=’I AM A STUDENT’, t=’GOOD’, q=’WORKER’, 求Replace(s,’STUDENT’,q) 和
Concat(SubString(s,6,2), Concat(t,SubString(s,7,8)))。
解：① Replace(s,’STUDENT’,q)＝’I AM A WORKER’

② 因为 SubString(s,6,2)＝‘A ’；SubString(s,7,8)＝‘ STUDENT’
Concat(t,SubString(s,7,8))＝’GOOD STUDENT’
所以Concat(SubString(s,6,2), Concat(t,SubString(s,7,8)))＝‘A GOOD STUDENT’

2. 已知主串s=’ADBADABBAABADABBADADA’,模式串pat=’ADABBADADA’。写出模式串的nextval函数值，并由此画出KMP算法匹配的全过程。
解：nextval函数值为0 1 0 2 1 0 1 0 4 0 在第12个字符处发现匹配！
s=’ADBADABBAABADABBADADA’
pat=’ADABBADADA’

3. （P60 4-18）用三元组表表示下列稀疏矩阵：

解：参见填空题4. 三元素组表中的每个结点对应于稀疏矩阵的一个非零元素，它包含有三个数据项，分别表示该元素的 行下标 、 列下标 和 元素值 。
所以（1）可列表为： （2）可列表为：
8
8
6
6
4
1
6
-2
2
5
9
4
3
5
6
5
3

5
3
2
3
3
6
8
5
4
6
7
8
5
8
1
2

4. （P60 4-19）下列各三元组表分别表示一个稀疏矩阵，试写出它们的稀疏矩阵。

解：（1）为6×4矩阵，非零元素有6个。 （2）为4×5矩阵，非零元素有5个
0 2 0 0
12 0 0 0
3 0 0 0
0 0 0 4
0 0 6 0
16 0 0 0

1 0 0 0 0
0 0 0 9 0
0 8 0 0 6
0 0 7 0 0

五、算法设计题（每题10分，共30分）
1. 编写一个实现串的置换操作Replace(&S, T, V)的算法。
解：
int Replace(Stringtype &S,Stringtype T,Stringtype V);//将串S中所有子串T替换为
V,并返回置换次数
{
for(n=0,i=1;i<=Strlen(S)-Strlen(T)+1;i++) //注意i的取值范围
if(!StrCompare(SubString(S,i,Strlen(T)),T)) //找到了与T匹配的子串
{ //分别把T的前面和后面部分保存为head和tail
StrAssign(head,SubString(S,1,i-1));
StrAssign(tail,SubString(S,i+Strlen(T),Strlen(S)-i-Strlen(T)+1));
StrAssign(S,Concat(head,V));
StrAssign(S,Concat(S,tail)); //把head,V,tail连接为新串
i+=Strlen(V); //当前指针跳到插入串以后
n++;
n++;
}//if
return n;
}//Replace
分析:i+=Strlen(V);这一句是必需的,也是容易忽略的.如省掉这一句,则在某些情况下, 会引起不希望的后果,虽然在大多数情况下没有影响.请思考:设S='place', T='ace', V='face',则省掉i+=Strlen(V);运行时会出现什么结果?

2. 写出将字符串反序的递归或递推算法，例如字符串为“abcsxw”，反序为“wxscba”编写对串求逆的递推算法)
请注意递归和递推的区别！递推是由“小”到“大”递进； 递归是由“大”到“小”嵌套。

算法思路：
① 假定用单链表结构存储字符串；
if没有到尾部字符就不停调用自身函数，直至到达末尾，再从尾部返回并打印字符；
递归算法的一般形式：
void p(参数表){
if （递归结束条件）
可直接求解步骤； 基本项
else p（较小的参数）； 归纳项
}
否则就打印当前字符并返回。
Invert(stringlistnode *p){
if(!p)return(0);
else Invert(p->next);
printf(“%c”, p->data)
}
如果当前串长为0,则return(-1)
否则开始递归：
if 串没有到末尾，则P=P->next; 再调用invert(s);
else printf(p->data);
return

void String_Reverse(Stringtype s,Stringtype &r)//求s的逆串r
{
StrAssign(r,''); //初始化r为空串
for(i=Strlen(s);i;i--)
{
StrAssign(c,SubString(s,i,1));
StrAssign(r,Concat(r,c)); //把s的字符从后往前添加到r中 /这是递推算法。
}
}//String_Reverse

3. 试设计一个算法，将数组An 中的元素A[0]至A[n-1]循环右移k位，并要求只用一个元素大小的附加存储，元素移动或交换次数为O(n)
解：
分析:要把A的元素循环右移k位,则A[0]移至A[k],A[k]移至A[2k]......直到最终回到A[ 0].然而这并没有全部解决问题,因为有可能有的元素在此过程中始终没有被访问过,而是被跳了过去.分析可知,当n和k的最大公约数为p时,只要分别以A[0],A[1],...A[p-1]为起点执行上述算法,就可以保证每一个元素都被且仅被右移一次,从而满足题目要求.也就是说,A的所有元素分别处在p个"循环链"上面.举例如下:
n=15,k=6,则p=3.
第一条链:A[0]->A[6],A[6]->A[12],A[12]->A[3],A[3]->A[9],A[9]->A[0]. /已“顺便”移动了A[6]、A[12]…
第二条链:A[1]->A[7],A[7]->A[13],A[13]->A[4],A[4]->A[10],A[10]->A[1].
第三条链:A[2]->A[8],A[8]->A[14],A[14]->A[5],A[5]->A[11],A[11]->A[2].
恰好使所有元素都右移一次.
程序如下：
void RSh(int A[n],int k)//把数组A的元素循环右移k位,只用一个辅助存储空间
{
for(i=1;i<=k;i++)
if(n%i==0&&k%i==0) p=i;//求n和k的最大公约数p
for(i=0;i<p;i++)
{
j=i;l=(i+k)%n;temp=A[i];
while(l!=i)
{
A[j]=temp;
temp=A[l];
A[l]=A[j];
j=l;l=(j+k)%n;
}// 循环右移一步
A[i]=temp;
}//for
}//RSh
6