数据结构期末复习题附答案1-4章

第一章 绪论

下面程序段的时间复杂度是（ C ）。
for(i=0;i<m;i++)
for(j=0;j<n;j++)
a[i][j]=ij;
A. O(m2)
B. O(n2)
C. O(mn)
D. O(m+n)
答案解析：由于程序为嵌套循环，外层循环的执行次数为 m，内存循环的执行次数为 n，
语句”A[i][j]=ij”的执行次数为 f(n)=mn 次。所以：T(n)=O(m*n) 。

某算法的语句执行频度为（3n+nlog2n+n2+8）,其时间复杂度表示（ C ）。
A. O(n)
B. O(nlog2n)
C. O(n2)
D. O(log2n)
答案解析：时间复杂度取表达式中最高阶，所以为O(n2)。

下面程序段的时间复杂度是（ B ）。
i=s=0;
while(s<n){
i++;s+=i;
}
A. Ｏ(n)
B. Ｏ(√𝑛)
C. Ｏ(log2n)
D. Ｏ(n3)
答案解析：设基本语句” i++;s+=i”的执行次数为 f(n)， s 是求前 i 项的和，根据等差
数列求和公式 s=i(i+1)/2，循环结束的条件是 s=n，即 i(i+1)/2=n，取最高阶，i2=2n， i= √2𝑛。即 f(n)= √2𝑛。 T(n)=Ｏ(√𝑛)。

下列程序段的时间复杂度为（B）。
x=n;y=0;
while(x>=(y+1)*(y+1))
y++;
A. O(n)
B.
O( n)
C. O(1)
D. O(n2)
答案解析：设基本语句“y++;”的执行次数为 f(n)，则𝑥 ≥ (𝑓(𝑛) + 1)2，又 x=n，所以𝑓(𝑛) ≤ √𝑛 − 1。即 T(n)=Ｏ(√n)。

下列程序段的时间复杂度为（ C ）。
答案解析：设基本语句” i=i3”的执行次数为 f(n)，则3𝑓(𝑛) ≤ 𝑛。因此，T(n)=Ｏ (𝐿𝑜𝑔3𝑛)。
A. Ｏ(n)
B. Ｏ(√𝑛)
C. Ｏ(log3n)
D. Ｏ(n3)
分析下面各程序段的时间复杂度
解：（1）
由于程序为嵌套循环，外层循环的执行次数为 n，内存循环的执行次数为 m，语
句”A[i][j]=0”的执行次数为 f(n)=nm 次。所以：T(n)=O(nm) 。 (2) 由于程序为嵌套循环，外层循环的执行次数为 n，内存循环的执行次数为 n，语句”
s+=B[i][j];”的执行次数为 f(n)=nn 次。所以：T(n)=O(n
2 ) 。 （3）由于程序为嵌套循环，外层循环共执行 n-1 次，内层循环的执行次数分别为：n-1,n-
2,n-3……1，当外层循环 i=1 时，内层循环执行 n-1 次，当外层循环 i=2 时，内层循环执
行 n-2 次，……当外层循环 i=n-1 时，内层循环执行 1 次。语句” x++;”的执行次数 f(n)= (n-1)+(n-2)+……+1=(𝑛−1)(𝑛−1+1) 2 = 𝑛(𝑛2−1)。所以：T(n)=O(n
2 ) 。

第 2 章 线性表
1．选择题
（1）顺序表中第一个元素的存储地址是 100，每个元素的长度为 2，则第 5 个元素的地址是（ ）。
A．110 B．108 C．100 D．120
答案：B
解释：顺序表中的数据连续存储，所以第 5 个元素的地址为：100+2*4=108。

（2）在 n 个结点的顺序表中，算法的时间复杂度是 O(1)的操作是（ ）。
A．访问第 i 个结点（1≤i≤n）和求第 i 个结点的直接前驱（2≤i≤n）
B．在第 i 个结点后插入一个新结点（1≤i≤n）
C．删除第 i 个结点（1≤i≤n）
D．将 n 个结点从小到大排序
答案：A
解释：在顺序表中插入一个结点的时间复杂度都是 O(n2)，排序的时间复杂度为 O(n2)或 O(nlog2n)。
顺序表是一种随机存取结构，访问第 i 个结点和求第 i 个结点的直接前驱都可以直接通过数组的下标直接定位，
时间复杂度是 O(1)。

（3） 向一个有 127 个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动 的元素个数
为（ ）。
A．8 B．63.5 C．63 D．7
答案：B
解释：平均要移动的元素个数为：n/2。 （4）链接存储的存储结构所占存储空间（ ）。
A．分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针
B．只有一部分，存放结点值
C．只有一部分，存储表示结点间关系的指针
D．分两部分，一部分存放结点值，另一部分存放结点所占单元数
答案：A

（5）线性表若采用链式存储结构时，要求内存中可用存储单元的地址（ ）。
A．必须是连续的 B．部分地址必须是连续的
C．一定是不连续的 D．连续或不连续都可以
答案：D

（6）线性表Ｌ在（ ）情况下适用于使用链式结构实现。
A．需经常修改Ｌ中的结点值 Ｂ．需不断对Ｌ进行删除插入
C．Ｌ中含有大量的结点 Ｄ．Ｌ中结点结构复杂
答案：B
解释：链表最大的优点在于插入和删除时不需要移动数据，直接修改指针即可。

（7）单链表的存储密度（ ）。
A．大于 1 B．等于 1 C．小于 1 D．不能确定
答案：C
解释：存储密度是指一个结点数据本身所占的存储空间和整个结点所占的存储空间之比，假设单
链表一个结点本身所占的空间为 D，指针域所占的空间为 N，则存储密度为：D/(D+N)，一定小于 1。

（8）将两个各有 n 个元素的有序表归并成一个有序表，其最少的比较次数是（ ）。
A．n B．2n-1 C．2n D．n-1
答案：A
解释：当第一个有序表中所有的元素都小于（或大于）第二个表中的元素，只需要用第二个表中
的第一个元素依次与第一个表的元素比较，总计比较 n 次。

（9）在一个长度为 n 的顺序表中，在第 i 个元素（1≤i≤n+1）之前插入一个新元素时须向后移动（ ）个元素。
A．n-i B．n-i+1 C．n-i-1 D．I
答案：B

(10) 线性表 L=(a1，a2,……an)，下列说法正确的是（ ）。
A．每个元素都有一个直接前驱和一个直接后继
B．线性表中至少有一个元素
C．表中诸元素的排列必须是由小到大或由大到小
D．除第一个和最后一个元素外，其余每个元素都有一个且仅有一个直接前驱和直接后继。
答案：D

(11) 创建一个包括 n 个结点的有序单链表的时间复杂度是（ ）。
A．O(1) B．O(n) C．O(n2
) D．O(nlog2n)
答案：C
解释：单链表创建的时间复杂度是 O(n)，而要建立一个有序的单链表，则每生成一个新结点时需
要和已有的结点进行比较，确定合适的插入位置，所以时间复杂度是 O(n2)。

(12) 以下说法错误的是（ ）。
A．求表长、定位这两种运算在采用顺序存储结构时实现的效率不比采用链式存储结构时实现的效率
低 B．顺序存储的线性表可以随机存取
C．由于顺序存储要求连续的存储区域，所以在存储管理上不够灵活
D．线性表的链式存储结构优于顺序存储结构
答案：D
解释：链式存储结构和顺序存储结构各有优缺点，有不同的适用场合。

(13) 在单链表中，要将 s 所指结点插入到 p 所指结点之后，其语句应为（ ）。
A．s->next=p+1; p->next=s;
B．(*p).next=s; (*s).next=(*p).next;
C．s->next=p->next; p->next=s->next;
D．s->next=p->next; p->next=s;
答案：D

(14) 在双向链表存储结构中，删除 p 所指的结点时须修改指针（ ）。
A．p->next->prior=p->prior; p->prior->next=p->next;
B．p->next=p->next->next; p->next->prior=p;
C．p->prior->next=p; p->prior=p->prior->prior;
D．p->prior=p->next->next; p->next=p->prior->prior;
答案：A
(15) 在双向循环链表中，在 p 指针所指的结点后插入 q 所指向的新结点，其修改指针的操作是（ ）。
A．p->next=q; q->prior=p; p->next->prior=q; q->next=q;
B．p->next=q; p->next->prior=q; q->prior=p; q->next=p->next;
C．q->prior=p; q->next=p->next; p->next->prior=q; p->next=q;
D．q->prior=p; q->next=p->next; p->next=q; p->next->prior=q;
答案：C

2．算法设计题 （1）将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空
间, 不另外占用其它的存储空间。表中不允许有重复的数据。
[题目分析]
合并后的新表使用头指针 Lc 指向，pa 和 pb 分别是链表 La 和 Lb 的工作指针,初始化为相应链表的第一
个结点，从第一个结点开始进行比较，当两个链表 La 和 Lb 均为到达表尾结点时，依次摘取其中较小者重新
链接在 Lc 表的最后。如果两个表中的元素相等，只摘取 La 表中的元素，删除 Lb 表中的元素，这样确保合
并后表中无重复的元素。当一个表到达表尾结点，为空时，将非空表的剩余元素直接链接在 Lc 表的最后。
[算法描述]
void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc)
{//合并链表 La 和 Lb，合并后的新表使用头指针 Lc 指向
pa=La->next; pb=Lb->next;
//pa 和 pb 分别是链表 La 和 Lb 的工作指针,初始化为相应链表的第一个结点
Lc=pc=La; //用 La 的头结点作为 Lc 的头结点
while(pa && pb)
{if(pa->datadata){pc->next=pa;pc=pa;pa=pa->next;}
//取较小者 La 中的元素，将 pa 链接在 pc 的后面，pa 指针后移
else if(pa->data>pb->data) {pc->next=pb; pc=pb; pb=pb->next;}
//取较小者 Lb 中的元素，将 pb 链接在 pc 的后面，pb 指针后移
else //相等时取 La 中的元素，删除 Lb 中的元素
{pc->next=pa;pc=pa;pa=pa->next;
q=pb->next;delete pb ;pb =q;
}
}
pc->next=pa?pa:pb; //插入剩余段
delete Lb; //释放 Lb 的头结点
}

（2）将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来两个链表的存
储空间, 不另外占用其它的存储空间。表中允许有重复的数据。
[题目分析]
合并后的新表使用头指针 Lc 指向，pa 和 pb 分别是链表 La 和 Lb 的工作指针,初始化为相应链表的第一
个结点，从第一个结点开始进行比较，当两个链表 La 和 Lb 均为到达表尾结点时，依次摘取其中较小者重新
链接在 Lc 表的表头结点之后，如果两个表中的元素相等，只摘取 La 表中的元素，保留 Lb 表中的元素。当
一个表到达表尾结点，为空时，将非空表的剩余元素依次摘取，链接在 Lc 表的表头结点之后。
[算法描述]
void MergeList(LinkList& La, LinkList& Lb, LinkList& Lc, )
{//合并链表 La 和 Lb，合并后的新表使用头指针 Lc 指向
pa=La->next; pb=Lb->next;
//pa 和 pb 分别是链表 La 和 Lb 的工作指针,初始化为相应链表的第一个结点
Lc=pc=La; //用 La 的头结点作为 Lc 的头结点
Lc->next=NULL;
while(pa||pb )
{//只要存在一个非空表，用 q 指向待摘取的元素
if(!pa) {q=pb; pb=pb->next;}
//La 表为空，用 q 指向 pb，pb 指针后移
else if(!pb) {q=pa; pa=pa->next;}
//Lb 表为空，用 q 指向 pa，pa 指针后移
else if(pa->data<=pb->data) {q=pa; pa=pa->next;}
//取较小者（包括相等）La 中的元素，用 q 指向 pa，pa 指针后移
else {q=pb; pb=pb->next;}
//取较小者 Lb 中的元素，用 q 指向 pb，pb 指针后移
q->next = Lc->next; Lc->next = q;
//将 q 指向的结点插在 Lc 表的表头结点之后
}
delete Lb; //释放 Lb 的头结点
}

（3）设计一个算法，通过一趟遍历在单链表中确定值最大的结点。
[题目分析]
假定第一个结点中数据具有最大值，依次与下一个元素比较，若其小于下一个元素，则设其下一个元素
为最大值，反复进行比较，直到遍历完该链表。
[算法描述]
ElemType Max (LinkList L ){
if(L->next==NULL) return NULL;
pmax=L->next; //假定第一个结点中数据具有最大值
p=L->next->next;
while(p != NULL ){//如果下一个结点存在
if(p->data > pmax->data) pmax=p;//如果 p 的值大于 pmax 的值，则重新赋值
p=p->next;//遍历链表
}
return pmax->data;

（4）设计一个算法，通过遍历一趟，将链表中所有结点的链接方向逆转，仍利用原表的存储空间。
[题目分析]
从首元结点开始，逐个地把链表 L 的当前结点 p 插入新的链表头部。 [算法描述]
void inverse(LinkList &L)
{// 逆置带头结点的单链表 L
p=L->next; L->next=NULL;
while ( p) {
q=p->next; // q 指向*p 的后继
p->next=L->next;
L->next=p; // *p 插入在头结点之后
p = q;
} }
注意：以上的“题目分析”的文字不是算法。需用文字表达解决问题的具体方法和步
骤。

第三章 栈和队列
[单选题]
若让元素 1，2，3，4，5 依次进栈，则出栈次序不可能出现在（ C ）种情况。
A．5，4，3，2，1
B．2，1，5，4，3
C．4，3，1，2，5
D．2，3，5，4，1 [答案解析]栈是后进先出的线性表，不难发现 C 选项中元素 1 比元素 2 先出栈，
违背了栈的后进先出原则，所以不可能出现 C 选项所示的情况。
若已知一个栈的入栈序列是 1，2，3，…，n，其输出序列为 p1，p2，p3，…，pn，若
p1=n，则 pi 为（ C ）。
A．i
B．n-i
C．n-i+1
D．不确定
[答案解析]栈是后进先出的线性表，一个栈的入栈序列是 1，2，3，…，n，而输
出序列的第一个元素为 n，说明 1，2，3，…，n 一次性全部进栈，再进行输出，所以
p1=n，p2=n-1，…，pi=n-i+1。
数组Ｑ［ｎ］用来表示一个循环队列，ｆ为当前队列头元素的前一位置，ｒ为队尾元
素的位置，假定队列中元素的个数小于ｎ，计算队列中元素个数的公式为（ D ）。
A．r-f
B．(n+f-r)%n
C．n+r-f
D．（n+r-f)%n
[答案解析]对于非循环队列，尾指针和头指针的差值便是队列的长度，而对于循环
队列，差值可能为负数，所以需要将差值加上 MAXSIZE（本题为 n），然后与 MAXSIZE（本
题为 n）求余，即（n+r-f)%n。
链式栈结点为：(data,link)，top 指向栈顶.若想摘除栈顶结点，并将删除结点的值
保存到 x 中,则应执行操作（ A ）。 A．x=top->data;top=top->link；
B．top=top->link;x=top->link；
C．x=top;top=top->link；
D．x=top->link； [答案解析]x=top->data 将结点的值保存到 x 中，top=top->link 栈顶指针指向栈
顶下一结点，即摘除栈顶结点。
设有一个递归算法如下
int fact(int n) { //n 大于等于 0
if(n<=0) return 1;
else return n*fact(n-1); }
则计算 fact(n)需要调用该函数的次数为（ A ）。 A． n+1
B． n-1
C． n
D． n+2
[答案解析]特殊值法。设 n=0，易知仅调用一次 fact(n)函数，故选 A。
栈在 （ D ）中有所应用。
A．递归调用
B．函数调用
C．表达式求值
D．前三个选项都有
[答案解析]递归调用、函数调用、表达式求值均用到了栈的后进先出性质。
为解决计算机主机与打印机间速度不匹配问题，通常设一个打印数据缓冲区。主机将
要输出的数据依次写入该缓冲区，而打印机则依次从该缓冲区中取出数据。该缓冲区的逻
辑结构应该是（ A ）。
A．队列
B．栈
C． 线性表
D．有序表
[答案解析]解决缓冲区问题应利用一种先进先出的线性表，而队列正是一种先进先
出的线性表。
设栈 S 和队列 Q 的初始状态为空，元素 e1、e2、e3、e4、e5 和 e6 依次进入栈 S，一
个元素出栈后即进入 Q，若 6 个元素出队的序列是 e2、e4、e3、e6、e5 和 e1，则栈 S 的容
量至少应该是（B ）。
A．2
B．3
C．4
D． 6 [答案解析]元素出队的序列是 e2、e4、e3、e6、e5 和 e1，可知元素入队的序列是
e2、e4、e3、e6、e5 和 e1，即元素出栈的序列也是 e2、e4、e3、e6、e5 和 e1，而元素 e1、
e2、e3、e4、e5 和 e6 依次进入栈，易知栈 S 中最多同时存在 3 个元素，故栈 S 的容量至
少为 3。
若一个栈以向量 V[1…n]存储，初始栈顶指针 top 设为 n+1，则元素 x 进栈的正确操
作是( C )。 A．top++; V[top]=x; B．V[top]=x; top++;
C．top–; V[top]=x; D．V[top]=x; top–; [答案解析]初始栈顶指针 top 为 n+1，说明元素从数组向量的高端地址进栈，又因
为元素存储在向量空间 V[1…n]中，所以进栈时 top 指针先下移变为 n，之后将元素 x 存
储在 V[n]。
设计一个判别表达式中左，右括号是否配对出现的算法，采用（ ）数据结构最佳。
A．线性表的顺序存储结构
B．队列
C. 线性表的链式存储结构
D. 栈 [答案解析]利用栈的后进先出原则。
用链接方式存储的队列，在进行删除运算时（D ）。
A. 仅修改头指针
B. 仅修改尾指针
C. 头、尾指针都要修改
D. 头、尾指针可能都要修改
[答案解析]一般情况下只修改头指针，但是，当删除的是队列中最后一个元素时，
队尾指针也丢失了，因此需对队尾指针重新赋值。
循环队列存储在数组 A[0…m]中，则入队时的操作为（D ）。
A. rear=rear+1
B. rear=(rear+1)%(m-1)
C. rear=(rear+1)%m
D. rear=(rear+1)%(m+1)
[答案解析]数组 A[0…m]中共含有 m+1 个元素，故在求模运算时应除以 m+1。
最大容量为 n 的循环队列，队尾指针是 rear，队头是 front，则队空的条件是（ B）。
A. (rear+1)%nfront
B. rearfront
C．rear+1front
D. (rear-l)%nfront
[答案解析]最大容量为 n 的循环队列，队满条件是(rear+1)%nfront，队空条件是
rearfront。
栈和队列的共同点是（C ）。
A. 都是先进先出
B. 都是先进后出
C. 只允许在端点处插入和删除元素
D. 没有共同点
[答案解析]栈只允许在栈顶处进行插入和删除元素，队列只允许在队尾插入元素和
在队头删除元素。
一个递归算法必须包括（B ）。
A. 递归部分
B. 终止条件和递归部分
C. 迭代部分
D. 终止条件和迭代部分
[填空题]
队列的插入操作是在 队尾 ，删除操作是在 队头 ，栈的操作是在栈顶。

第四章 串、数组和广义表 1.【单选题】 设二维数组 A[1… m，1… n]（即 m 行 n 列）按行存储在数组 B[1… m*n]中，则二维数组 元素 A[i,j]在一维数组 B 中的下标为（ A ）。 A.(i-1)n+j B.(i-1)n+j-1 C.i(j-1) D.jm+i-1 2.【单选题】 二维数组 A 的元素都是 6 个字节组成的串，行下标 i 的范围从 0 到 8，列下标 j 的范围从 1 到 10，从供选择的答案中分别选出正确答案。 存放 A 至少需要（ D ）字节 A.90 B.180 C.270 D.540 3.【单选题】 二维数组 A 的元素都是 6 个字节组成的串，行下标 i 的范围从 0 到 8，列下标 j 的范围从 1 到 10，从供选择的答案中分别选出正确答案。 A 的第 8 列和第 5 行共占（ A ）字节 A.108 B.114 C.54 D.60 4.【单选题】 数组 A[0…4,-1…-3,5…7]中含有元素的个数（B ）。 A.55
B.45 C.36 D.16 5.【单选题】 设有数组 A[i,j]，数组的每个元素长度为 3 字节，i 的值为 1 到 8，j 的值为 1 到 10，数 组从内存首地址 BA 开始顺序存放，当用以列为主存放时，元素 A[5,8]的存储首地址为 （ B ）。 A.BA+141 B.BA+180 C.BA+222 D.BA+225 6.【单选题】 广义表((a,b,c,d))的表尾是（ B ）。 A.a B.( ) C.(a,b,c,d) D.(b,c,d) 答案解析：广义表的表尾为除去表头之外，由其余元素构成的表，表为一定是个广义表， ((a,b,c,d))的表尾为空表( )。 7.【单选题】 对特殊矩阵采用压缩存储的主要目的的（ D ） A.表达变得简单 B.对矩阵元素的存取变得简单 C.去掉矩阵中多余的元素 D.减少不必要的存储究竟
答案解析：特殊矩阵中包括很多值相同的元素或者是零元素。为了节省存储空间，可以对 这类矩阵进行压缩存储。所谓压缩存储，是指为多个值相同的元素只分配一个存储空间， 对零元素不分配存储空间。 8.【单选题】 对于 KMP 算法，在模式匹配时批示主串匹配位置的指针（ B ） A.不会变大 B.不会变小 C.都有可能 D.无法判断 9.【单选题】 基串 S=“software”，其子串的数目是（ B ） A.8 B.37 C.36 D.9 10.【单选题】 广义表((a,b,c,d))的表头是（ C ）。 A.a B.( ) C.(a,b,c,d) D.(b,c,d) 答案解析：表头为非空广义表的第一个元素，可以是一个单原子，也可以是一个子表， ((a,b,c,d))的表头为一个子表(a,b,c,d) 11.【单选题】 设广义表 L=((a,b,c))，则 L 的长度和深度分别为（ C ）。 A.1 和 1
B.1 和 3 C.1 和 2 D.2 和 3 答案解析：广义表的深度是指广义表中展开后所含括号的层数，广义表的长度是指广义表 中所含元素的个数。根据定义易知 L 的长度为 1，深度为 2。 12.【单选题】 串下面关于串的的叙述中，（ B ）是不正确的？ A.串是字符的有限序列 B.空串是由空格构成的串 C.模式匹配是串的一种重要运算 D.串既可以采用顺序存储，也可以采用链式存储 答案解析：空格常常是串的字符集合中的一个元素，有一个或多个空格组成的串成为空格 串，零个字符的串成为空串，其长度为零。 [计算题] 数组 A 中，每个元素 A[i,j]的长度均为 32 个二进位,行下标从-1 到 9，列下标从 1 到 11， 从首地址 S 开始连续存放主存储器中，主存储器字长为 16 位。求： ①存放该数组所需多少单元？ ②存放数组第 4 列所有元素至少需多少单元？ ③数组按行存放时，元素 A[7,4]的起始地址是多少？ ④数组按列存放时，元素 A[4,7]的起始地址是多少？ [参考答案] 解：每个元素 32 个二进制位，主存字长 16 位，故每个元素占 2 个字长。 （1）行下标-1 到 9，平移至 1 到 11，该数组包括的元素个数总计有：（11-1+1）×（11-1+1） =121，每个元素占 2 个字长，故：存放该数组所需单元总计为 121×2=242 个. （2）第 4 列包括的元素个数总计有: （11-1+1）=11, 每个元素占 2 个字长，因此，存
放第 4 列所有元素至少需单元为 11×2=22 个。 （3）行下标-1 到 9，平移至 1 到 11，A[7,4]即为平移后的 A[9,4]，LOC=S+((9-1)×(11-1+1)+(4-1)) ×2=S+182。 （4）行下标-1 到 9，平移至 1 到 11，A[4,7]即为平移后的 A[6,7]，LOC=S+((7-1)×（11-1+1）+(6-1) ×2=S+142。

第四章 串、数组和广义表

1.【单选题】 设二维数组 A[1… m，1… n]（即 m 行 n 列）按行存储在数组 B[1… m*n]中，则二维数组 元素 A[i,j]在一维数组 B 中的下标为
（ A ）。 A.(i-1)n+j B.(i-1)n+j-1 C.i(j-1) D.jm+i-1 2.

2.【单选题】 二维数组 A 的元素都是 6 个字节组成的串，行下标 i 的范围从 0 到 8，列下标 j 的范围从 1 到 10，从供选择的答案中分别选出正确答案。 存放 A 至少需要（ D ）字节
A.90 B.180 C.270 D.540

3.【单选题】 二维数组 A 的元素都是 6 个字节组成的串，行下标 i 的范围从 0 到 8，列下标 j 的范围从 1 到 10，从供选择的答案中分别选出正确答案。 A 的第 8 列和第 5 行共占（ A ）字节
A.108 B.114 C.54 D.60

4.【单选题】 数组 A[0…4,-1…-3,5…7]中含有元素的个数（B ）。
A.55 B.45 C.36 D.16

5.【单选题】 设有数组 A[i,j]，数组的每个元素长度为 3 字节，i 的值为 1 到 8，j 的值为 1 到 10，数 组从内存首地址 BA 开始顺序存放，当用以列为主存放时，元素 A[5,8]的存储首地址为 （ B ）。
A.BA+141 B.BA+180 C.BA+222 D.BA+225
6.【单选题】 广义表((a,b,c,d))的表尾是（ B ）。
A.a B.( ) C.(a,b,c,d) D.(b,c,d)
答案解析：广义表的表尾为除去表头之外，由其余元素构成的表，表为一定是个广义表， ((a,b,c,d))的表尾为空表( )。
7.【单选题】 对特殊矩阵采用压缩存储的主要目的的（ D ）
A.表达变得简单 B.对矩阵元素的存取变得简单
C.去掉矩阵中多余的元素 D.减少不必要的存储究竟
答案解析：特殊矩阵中包括很多值相同的元素或者是零元素。为了节省存储空间，可以对 这类矩阵进行压缩存储。所谓压缩存储，是指为多个值相同的元素只分配一个存储空间， 对零元素不分配存储空间。

8.【单选题】 对于 KMP 算法，在模式匹配时批示主串匹配位置的指针（ B ） A.不会变大 B.不会变小 C.都有可能 D.无法判断

9.【单选题】 基串 S=“software”，其子串的数目是（ B ）
A.8 B.37 C.36 D.9

10.【单选题】 广义表((a,b,c,d))的表头是（ C ）。
A.a B.( ) C.(a,b,c,d) D.(b,c,d)
答案解析：表头为非空广义表的第一个元素，可以是一个单原子，也可以是一个子表， ((a,b,c,d))的表头为一个子表(a,b,c,d)
11.【单选题】 设广义表 L=((a,b,c))，则 L 的长度和深度分别为（ C ）。
A.1 和 1 B.1 和 3 C.1 和 2 D.2 和 3
答案解析：广义表的深度是指广义表中展开后所含括号的层数，广义表的长度是指广义表 中所含元素的个数。根据定义易知 L 的长度为 1，深度为 2。

12.【单选题】 串下面关于串的的叙述中，（ B ）是不正确的？
A.串是字符的有限序列 B.空串是由空格构成的串
C.模式匹配是串的一种重要运算 D.串既可以采用顺序存储，也可以采用链式存储
答案解析：空格常常是串的字符集合中的一个元素，有一个或多个空格组成的串成为空格 串，零个字符的串成为空串，其长度为零。

[计算题] 数组 A 中，每个元素 A[i,j]的长度均为 32 个二进位,行下标从-1 到 9，列下标从 1 到 11， 从首地址 S 开始连续存放主存储器中，主存储器字长为 16 位。求：
①存放该数组所需多少单元？
②存放数组第 4 列所有元素至少需多少单元？
③数组按行存放时，元素 A[7,4]的起始地址是多少？
④数组按列存放时，元素 A[4,7]的起始地址是多少？

[参考答案] 解：每个元素 32 个二进制位，主存字长 16 位，故每个元素占 2 个字长。 （1）行下标-1 到 9，平移至 1 到 11，该数组包括的元素个数总计有：（11-1+1）×（11-1+1） =121，每个元素占 2 个字长，故：存放该数组所需单元总计为 121×2=242 个. （2）第 4 列包括的元素个数总计有: （11-1+1）=11, 每个元素占 2 个字长，因此，存
放第 4 列所有元素至少需单元为 11×2=22 个。 （3）行下标-1 到 9，平移至 1 到 11，A[7,4]即为平移后的 A[9,4]，LOC=S+((9-1)×(11-1+1)+(4-1)) ×2=S+182。 （4）行下标-1 到 9，平移至 1 到 11，A[4,7]即为平移后的 A[6,7]，LOC=S+((7-1)×（11-1+1）+(6-1) ×2=S+142。

有空再更新。