最新数据结构与算法习题库重点.docx

最新数据结构与算法习题库重点.docx

《最新数据结构与算法习题库重点.docx》由会员分享，可在线阅读，更多相关《最新数据结构与算法习题库重点.docx（29页珍藏版）》请在冰豆网上搜索。

最新数据结构与算法习题库重点

第一章绪论

一．选择题

1．数据结构被形式地定义为（K，R），其中K是①_B_的有限集合，R是K上的②_D_的有限集合。

①A．算法B．数据元素C．数据操作D．逻辑结构②A．操作B．映象C．存储D．关系

2．算法分析的目的是①C，算法分析的两个主要方面是②A。

①A．找出数据结构的合理性

B．研究算法中的输入和输出的关系

C．分析算法的效率以求改进

D．分析算法的易懂性和文档性

②A．空间复杂性和时间复杂性

B．正确性和简明性

C．可读性和文档性

D．数据复杂性和程序复杂性

3．在计算机存储器内表示时，物理地址和逻辑地址相同并且是连续的，称之为

（B）

A．逻辑结构B．顺序存储结构

C．链表存储结构D．以上都不对

4．数据结构中，在逻辑上可以把数据结构分成：

（C）。

A．动态结构和静态结构B．紧凑结构和非紧凑结构

C．线性结构和非线性结构D．内部结构和外部结构

5．以下属于顺序存储结构优点的是（A）。

A．存储密度大B．插入运算方便

C．删除运算方便D．可方便地用于各种逻辑结构的存储表示

6．数据结构研究的内容是（D）。

A．数据的逻辑结构B．数据的存储结构

C．建立在相应逻辑结构和存储结构上的算法D．包括以上三个方面

7．链式存储的存储结构所占存储空间（A）。

A．分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针

B．只有一部分，存放结点值

C．只有一部分，存储表示结点间关系的指针

D．分两部分，一部分存放结点值，另一部分存放结点所占单元数

8．一个正确的算法应该具有5个特性，除输入、输出特性外，另外3个特性是（A）。

A．确定性、可行性、有穷性B．易读性、确定性、有效性

C．有穷性、稳定性、确定性D．可行性、易读性、有穷性

9．以下关于数据的逻辑结构的叙述中正确的是（A）。

A．数据的逻辑结构是数据间关系的描述

B．数据的逻辑结构反映了数据在计算机中的存储方式

C．数据的逻辑结构分为顺序结构和链式结构

D．数据的逻辑结构分为静态结构和动态结构

10．算法分析的主要任务是（C）。

A．探讨算法的正确性和可读性B．探讨数据组织方式的合理性

C．为给定问题寻找一种性能良好的解决方案D．研究数据之间的逻辑关系

二．解答

设有一数据的逻辑结构为：

B=（D,S），其中：

D={d1,d2,…,d9}

S={,,,,,,,,,,}画出这个逻辑结构示意图。

第二章线性表

一、选择题

1．下述哪一条是顺序存储结构的优点？

（A）

A．存储密度大B．插入运算方便C．删除运算方便D．可方便地用于各种逻辑结构的存储表示

2．下面关于线性表的叙述中，错误的是哪一个？

（B）

A．线性表采用顺序存储，必须占用一片连续的存储单元。

B．线性表采用顺序存储，便于进行插入和删除操作。

C．线性表采用链接存储，不必占用一片连续的存储单元。

D．线性表采用链接存储，便于插入和删除操作。

3．若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用（A）存储方式最节省时间。

A．顺序表B．双链表C．带头结点的双循环链表D．单循环链表

4．某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则采用（D）存储方式最节省运算时间。

A．单链表B．仅有头指针的单循环链表C．双链表D．仅有尾指针的单循环链表

5．在一个长度为n的顺序表中删除第i个元素（0<=i<=n）时，需向前移动（A）个元素

A．n-iB．n-i+lC．n-i-1D．i

6．从一个具有n个结点的单链表中查找其值等于x的结点时，在查找成功的情况下，需平均比较（C）个元素结点

A．n/2B．nC．（n+1）/2D．（n-1）/2

7．设单链表中指针p指向结点m，若要删除m之后的结点（若存在），则需修改指针的操作为（A）

A．p->next=p->next->next;B．p=p->next;

C．p=p->next->next;D．p->next=p;

8．在一个单链表中，已知q结点是p结点的前趋结点，若在q和p之间插入s结点，则须执行（B）

A．s->next=p->next;p->next=s

B．q->next=s;s->next=p

C．p->next=s->next;s->next=p

D．p->next=s;s->next=q

9．线性表的顺序存储结构是一种（A）的存储结构。

A．随机存取B．顺序存取C．索引存取D．散列存取

二、填空

1．在线性表的顺序存储中，元素之间的逻辑关系是通过性表的链接存储中，元素之间的逻辑关系是通过指针决定的。

2．在双向链表中，每个结点含有两个指针域，一个指向直接前驱结点，另一个指向直接后继结点。

3．当对一个线性表经常进行存取操作，而很少进行插入和删除操作时，则采用_顺序存储结构为宜。

相反，当经常进行的是插入和删除操作时，则采用链式存储结构为宜。

三、算法设计

1．设有一个正整数序列组成的有序单链表（按递增次序有序，且允许有相等的整数存在），试编写能实现下列功能的算法（要求用最少的时间和最小的空间）

①确定在序列中比正整数x大的数有几个（相同的数只计算一次）

②将单链表中比正整数x小的偶数从单链表中删除

intcount（Linklisth,intx）

{

intnum=0;

Linknode*p;

p=h->next;

while（p&&p->data<=x）//p指针向后移动，直至p指向第一个值大于x的结点

p=p->next;

while（p）

if（p->next&&p->data==p->next->data）

//若p没有指向链表中同一数值的最后一个结点，则向后移动

p=p->next;

else

//若p指向数值相同的结点中的最后一个，则num加1，p指针后移，继续执行while循环{

num++;

p=p->next;

}

returnnum;

}

②

voiddelevenl（Linklist&h,intx）

{

Linknode*p,*r;

p=h->next;r=h;

while（p&&p->data

{

if（p->data%2==0）

{

r->next=p->next;

free（p）;

p=r->next;

}

else

{

r=p;

p=p->next;

}

}

}

2．设有一个表头指针为h的单链表。

试设计一个算法，通过遍历一趟链表，将链表中所有结点的链接方向逆转，如下图所示。

要求逆转结果链表的表头指针h指向原链表的最后一个结点。

2．voidconverse（Linklist&h）

{

Linknode*p,*q;

p=h->next;

h->next=NULL;

q=p->next;

while（q）

{

p->next=h;

h=p;

p=q;

q=q->next;

}

p->next=h;

h=p;

}

p

Λ3．设计算法将一个带头结点的单链表A分解为两个具有相同结构的链表B、C，其中B表的结点为A表中值小于零的结点，而C表的结点为A表中值大于零的结点（链表A的元素类型为整型，要求B、C表利用A表的结点）。

3．voiddecompose（LinklistLa,Linklist&Lb,Linklist&Lc）

{

Linknode*p;

Lc=（Linknode*）malloc（sizeof（Linknode））;

Lc->next=NULL;

p=La->next;

Lb=La;

Lb->next=NULL;

while（p）

{

La=p->next;

if（p->data>0）

{

p->next=Lc->next;

Lc->next=p;

}}}else{p->next=Lb->next;Lb->next=p;}p=La;

4.假设链表A、B分别表示一个集合，试设计算法以判断集合A是否是集合B的子集，若是，则返回1，否则返回0，并分析算法的时间复杂度。

4．intsubset（LinkListla,LinkListlb）

{LinkNode*pa,*pb;

pa=la->next;

while（pa）

{pb=lb->next;

while（pb&&（pb->data!

=pa->data））pb=pb->next;

if（!

pb）return0;

pa=pa->next;

}

return1;

}算法时间复杂度O（A.Length*B.Length）

5．设有一单循环链表la，其结点有三个域：

prior、data与next，其中data为数据域,，next域指向直接后继，prior域应指向直接前驱，但目前空着。

试写一算法将此单循环链表改造为双向循环链表。

5．voidpriorset（DuLinkList&la）

{p=la;q=la->next;

while（q!

=la）{q->prior=p;p=q;q=q->next;}

q->prior=p;

}

第三章栈和队列

一、选择题

1．已知栈的最大容量为4。

若进栈序列为1，2，3，4，5，6，且进栈和出栈可以穿插进行,则可能出现的出栈序列为（C）

A.5，4，3，2，1，6B.2，3，5，6，1，4

C.3，2，5，4，1，6D.1，4，6，5，2，3

设有一个栈，元素的进栈次序为A,B,C,D,E,下列是不可能的出栈序列（C）

A．A,B,C,D,EB．B,C,D,E,A

C．E,A,B,C,DD．E,D,C,B,A

2．在一个具有n个单元的顺序栈中，假定以地址低端（即0单元）作为栈底，

以top作为栈顶指针，当做出栈处理时，top变化为（C）

A．top不变B．top=0C．top--D．top++

3．向一个栈顶指针为hs的链栈中插入一个s结点时，应执行（B）

A．hs->next=s;

B．s->next=hs;hs=s;

C．s->next=hs->next;hs->next=s;

D．s->next=hs;hs=hs->next;

4．在具有n个单元的顺序存储的循环队列中，假定front和rear分别为队头指针和队尾指针，则判断队满的条件为（D）

A．rear％n==frontB．（front+l）％n==rear

C．rear％n-1==frontD．（rear+l）％n==front

5．在具有n个单元的顺序存储的循环队列中，假定front和rear分别为队头指针和队尾指针，则判断队空的条件为（C）

A．rear％n==frontB．front+l=rear

C．rear==frontD．（rear+l）％n=front

6．在一个链队列中，假定front和rear分别为队首和队尾指针，则删除一个结点的操作为（A）

A．front=front->nextB．rear=rear->next

C．rear=front->nextD．front=rear->next

7．某堆栈的输入序列为1，2，3，…，n，输出序列的第一个元素是n，则第i个输出元素为（C）

A．iB．n-iC．n-i+1D．哪个元素无所谓

8．用不带头结点的单链表存储队列时,其队头指针指向队头结点,其队尾指针指向队尾结点，则在进行删除操作时（D）。

A．仅修改队头指针B.仅修改队尾指针

C.队头、队尾指针都要修改D.队头,队尾指针都可能要修改

二、解答题

1．一个双向栈S是在同一向量空间内实现的两个栈，它们的栈底分别设在向量空间的两端。

试为此双向栈设计初始化InitStack（S）、入栈Push（S,i,x）和出栈Pop（S,i）等算法，其中i为0或1，用以表示栈号。

1

栈底栈底2//#defineSTACK_SIZE100;

Typedefstruct{

SElemType*base_one,*base_two;//栈底指针

SElemType*top_one,*top_two;//栈顶指针

intstacksize;

}SqStack;

StatusInitStack（SqStack&S）{

//初始化双向栈

S.base_one=S.top_one=（SElemType*）malloc（STACK_SIZE*sizeof（SElemType））;//第一个栈底和栈顶指向数组起点

S.base_two=S.top_two=S.base_one+STACK_SIZE-1;//第二个栈底和栈顶指向数组终点S.stacksize=STACK_SIZE;

returnOK;

}//InitStack

StatusPush（SqStack&S,inti,SElemTypee）{

//入栈操作，i=0时将e存入前栈，i=1时将e存入后栈

if（S.top_two

if（i==0）

*S.top_one++=e;

else

*S.top_two--=e;

returnOK;

}//Push

SElemTypePop（SqStack&S,inti）{

//出栈操作，i=0出前栈，i=1出后栈

if（i==0）{

if（S.top_one==S.base_one）returnERROR;

S.top_one--;e=*S.top_one;

}

else{

if（S.top_two==S.base_two）returnERROR;

S.top_two++;e=*S.top_two;

}

returne;

}//Pop

2．利用两个栈S1、S2模拟一个队列时，如何使用栈的运输实现队列的插入、删除运算。

2．#defineM3

structStack{

Qelemtypedata[M];

inttop;

};

structQueue{

Stacks1;

Stacks2;

};

voidInitQueue（Queue&Q）//初始化队列

{

Q.s1.top=0;

Q.s2.top=0;

}

intIsEmpty（Queue&Q）//判断队列是否为空

{

if（Q.s1.top==0&&Q.s2.top==0）

return1;

if（Q.s2.top==0&&Q.s1.top!

=0）

{

while（Q.s1.top!

=0）

Q.s2.data[Q.s2.top++]=Q.s1.data[--Q.s1.top];}

return0;

}

intIsFull（Queue&Q）

{

if（Q.s1.top==M&&Q.s2.top!

=0）

return1;

if（Q.s1.top==M&&Q.s2.top==0）

{

while（Q.s1.top!

=0）

Q.s2.data[Q.s2.top++]=Q.s1.data[--Q.s1.top];return0;

}

if（Q.s1.top!

=M）

return0;

}

voidInQueue（Queue&Q,Qelemtypee）

{

if（IsFull（Q））

{

cout<<"OVERFLOW"<

return;

}

Q.s1.data[Q.s1.top++]=e;

}

voidDeQueue（Queue&Q,Qelemtype&e）

{

if（IsEmpty（Q））

{

cout<<"UNDERFLOW"<

return;

}

e=Q.s2.data[--Q.s2.top];

}

3．已知一个栈S的输入序列为abcd，下面两个序列能否通过栈的push和pop操作输出？

如果能，请写出操作序列；如果不能，请写明原因。

（1）dbca

（2）cbda

3．

（1）不能

（2）可以原因略

4．假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点（注意不设头指针），试编写相应的置空队、判队空、入队和出队等算法。

4．structQueueNode

{

Qelemtypedata;

QueueNode*next;

};

structLinkQueue

{

QueueNode*rear;

};

voidInitQueue（LinkQueue&Q）//置空队

{

Q.rear=newQueueNode;

Q.rear->next=Q.rear;

}

intEmptyQueue（LinkQueueQ）//判队空

{

returnQ.rear==Q.rear->next;

}

voidEnQueue（LinkQueue&Q,Qelemtypee）//元素入队

{

QueueNode*p;

//新建一个结点，并置其值为e

p=newQueueNode;

p->data=e;

//将结点插入队列末尾

p->next=Q.rear->next;

Q.rear->next=p;

//修改队尾指针

Q.rear=p;

}

voidDeQueue（LinkQueue&Q,Qelemtype&e）//元素出队

{

QueueNode*p;

if（EmptyQueue（Q））//若队中无元素，则无法执行出队操作

{

cout<<"error"<

return;

}

p=Q.rear->next->next;//让p指向队头元素

e=p->data;

if（p==Q.rear）//如队中只有一个元素，则要rear指向头结点，头结点的next指针指向自身{

Q.rear=Q.rear->next;

Q.rear->next=Q.rear;

}

else//若队中不只一个元素，则删除p所指向的结点。

Q.rear->next->next=p->next;

deletep;//释放被删除结点的存储空间

}

5．假设以I和O表示入栈和出栈操作，栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅由I和O组成的序列。

称可以操作的序列为合法序列，否则称为非法序列。

（1）下面所示的序列中哪些是合法的？

A．IOIIOIOOB.IOOIOIIOC.IIIOIOIOD.IIIOOIOO

（2）通过对问题⑴的分析，写出一个算法判定所给的操作序列是否合法。

若合法返回TRUE，否则返回FALSE。

（假定被判定的操作序列已经存入一维数组中）

5．typedefstruct

{

chardata[10];

inttop;

}stack;

intdescion（char*str）

{

stacks;

inti;

s.top=0;

for（i=0;str[i];i++）

{

switch（str[i]）

{

case'I':

s.data[s.top++]=str[i];break;//若为I，则如栈

case'O':

if（s.top==0）return0;s.top--;//若为O，则从栈中弹出一个I

}

}

if（s.top==0）return1;

elsereturn0;

}

第四章串

一．选择题

1.若串S='software',其子串的数目是（B）

A.8B.37C.36D.9

2.设有两个串p和q,求q在p中首次出现的位置的运算称作（B）

A.连接B.模式匹配C.求串长D.求子串

3．设字符串S1=“ABCDEFG”，S2=“PQRST”，则运算：

S=CONCAT（SUBSTR（S1，2，LEN（S2））；SUBSTR（S1，LEN（S2），2））；后的串值为（D）

A．ABCDEFB．BCDEFGC．BCDPQRSTD．BCDEFEF

4.下面的说法中，只有（A）是正确的

A.串是一种特殊的线性表B.串的长度必须大于零

C.串中元素只能是字母D.空串就是空白串

5.两个字符串相等的条件是（D）

A.两串的长度相等

B.两串包含的字符相同

C.两串的长度相等，并且两串包含的字符相同

D.两串的长度相等，并且对应位置上的字符相同

二、填空题

1.令t1=“aaab”,t2=“abcabaa”,t3=“abcaabbabcabaacba”，试分别求出他们的nex函数值0123,0111232,01112231234532211。

2.空格串的长度为．空格数，空串的长度为0。

3.设串S=’Howareyou’，则串的长度为11。

三、问答题

回文是指正读反读均相同的字符序列，如"abba"和"abdba"均是回文，但"good"不是回文。

试写一个算法判定给定的字符变量是否为回文。

StatusIsHuiwen（char*S）

{i=0;

while（s[i]!

=’\0’）i++;

i=i-1;j=0;

while（j

if（s[j]!

=s[i]）return0;

else{j++;i--;}

return1;

}

第五章数组和广义表

一．选择题

1.设有数组A[i,j]，数组的每个元素长度为3字节，i的值为1到8，j的值为1到10，数组从内存首地址BA开始顺序存放，当用以列为主存放时，元素A[5，8]的存储首地址为（B）

A.BA+141B.BA+180C.BA+222D.BA+225

2.假设以行序为主序存储二维数组A=array[1..100，1..100]，设每个数据元素占2个存储单元，基地址为10，则LOC[5，5]=（B）

A.808B.818C.1010D.10203对稀疏矩阵进行压缩存储目的是（C）

A．便于进行矩阵运算B．便于输入和输出C．节省存储空间D．降低运算的时间复杂度

4.广义表A=（a,b,（c,d）,（e,（f,g）））,则下面式子的值为（D）。

Head（Tail（Head（Tail（Tail（A）））））

A.（g）B.（d）C.cD.d

5.设广义表L=（（a,b,c）），则L的长度和深度分别为（B）。

A.1和1B.1和3C.1和2D.2和36.假设以三元组表表示稀疏矩阵，则与如图所示三元组表对应的4×5的稀疏矩阵是（注：

矩阵的行列下标均从1开始）（B）

⎛0-8

07

A.

00

-50⎝

⎛0-