选择填空判断

一、判断题

1。顺序表和一维数组一样，都可以按下标随机（或直接）访问。( √）

2. 数据的逻辑结构是指各数据元素之间的逻辑关系,是用户根据应用需要建立的.（√）

3。只有用面向对象的计算机语言才能描述数据结构算法。（×）

4。在对双向循环链表做删除一个结点操作时,应先将被删除结点的前驱结点和后继结点链接好再执行删除结点操作.（√）

5。数据元素是数据的最小单位.（×）

6. 算法和程序都应具有下面一些特征：输入,输出,确定性，有穷性,可行性.（√）

7. 插入与删除操作是数据结构中最基本的两种操作,因此这两种操作在数组中也经常被使用。（× ) 8。线性表若采用链式存储表示, 在删除时不需要移动元素.( √ )

9. 用一组地址连续的存储单元存放的元素一定构成线性表。（× )

10. 线性表的逻辑顺序与物理顺序总是一致的.（×）

11. 线性表的顺序存储表示优于链式存储表示。( ×）

12.链表的每个结点中都恰好包含一个指针.（×）

二、填空题

1. 若经常需要对线性表进行查找操作，则最好采用（顺序）存储结构.

2.(循环)链表从任何一个结点出发，都能访问到所有结点.

3.若经常需要对线性表进行插入与删除操作，该线性表最好采用(链式)存储结构。

4.通常用时间复杂度和(空间复杂度)两种方法衡量算法的效率

5.已知一顺序存储的线性表，每个元素占用k个存储单元,若第一个元素的地址为Loc1，则第i个元素

的地址为（ Loc1+（i-1)*k )。

6.在以L为头指针的带头结点的单链表和单循环链表中,判断链表是否为空的条件分别为

（L->next==NULL和_L—〉next==L）。

7.顺序表中逻辑上相邻的元素的物理位置(相邻），单链表中逻辑上相邻的元素的物理位置(不一定相邻）.

8.数据的逻辑结构包括集合、(线性结构）、树形结构和图状结构四种类型。

9.已知有实现同一功能的两个算法，其时间复杂度分别为O(log2n)和O(n），哪个算法的效率更高？( O

（log2n））

10.在一个单链表L中，若要在指针q所指结点的后面插入一个由指针p所指向的结点,则应进行的操作序

列为：（ p-〉next=q—>next），q一〉next=p。

11.在单链表设置表头结点的作用是插入和删除表中第一个元素时不必对(头指针）进行特殊处理.

12.在双向链表中，每个结点含有两个指针域，一个指向(直接前驱）结点,另一个指向（直接后继)结点。

13.在非空线性表中除第一个元素外，集合中每个数据元素只有一个(直接前驱）；除最后一个元素之外，

集合中每个数据元素均只有一个(直接后继)。

14.一个算法一该具有有穷性，(确定性）,可行性，输入和输出这五种特性。

三、选择题

1. 计算机识别、存储和加工处理的对象被统称为_____A___.

A。数据 B。数据元素 C。数据结构 D。数据类型

2.线性表若采用链式存储结构时,要求内存中可用存储单元的地址__D______。

A. 必须是连续的

B. 部分地址必须是连续的

C。一定是不连续的 D. 连续，不连续都可以

3.线性表若采用顺序存储结构时，要求内存中可用存储单元的地址__A______.

A。必须是连续的 B。部分地址必须是连续的

C. 一定是不连续的 D。连续，不连续都可以

4.在一个长度为n的顺序存储的线性表中，向第i个元素(1≤i≤n+1)位置之前插入一个新元素时,需要

移动___B_____个元素。

A. n—i B。 n-i+1 C。 n-i-1 D. i

5.在长度为n的顺序存储的线性表中，删除第i个元素（1≤i≤n）时，需要从前向后依次前移____A____

个元素。

A.n—i B。n-i+1

C。n—i-1 D。i

6.链表不具有的特点是____A____.

A. 随机访问

B. 不必事先估计所需存储空间大小

C. 插入与删除时不必移动元素 D。所需空间与线性表长度成正比

7.在一个单链表L中,若要删除由指针q所指向结点的后继结点,则执行____D____.

A. q=q—>next； B。 q—>next=p-〉next；

C. p=q-〉next；

D. q->next=q-〉next—>next;

8.在一个单链表HL中，若要删除由指针q所指向结点的后继结点，则执行__B___。

A.p = q->next ; p-〉next = q->next； B。p = q—〉next ； q->next = p-〉next；

C。p = q—〉next ; q—>next = p； D.q—〉next = q->next—〉next; q—>next = q;

9.在一个长度为n的顺序存储线性表中，删除第i个元素(1≤i≤n)时，需要移动____A____个元素.

A. n—i

B. n—i+1

C. n—i-1 D。 i

10.下面算法的时间复杂度为______B______。

int f（ unsigned int n ) ｛

if （ n==0 ｜｜ n==1 ) return 1; else return n*f（n-1)；

｝

A。 O(1) B。 O（n)

C。 O（n2） D. O(n！）

11.下面程序段的时间复杂度为_______C_____。

for（int i=0； i

for（int j=0; j

A［i］［j]=i*j;

A. O（m2） B。 O(n2) C. O（m＊n） D。 O(m+n)

12.数据结构通常是研究数据的 A 及它们之间的联系。

A存储和逻辑结构B存储和抽象

C理想和抽象D理想与逻辑

13.算法分析的目的是___B______

A、找出数据结构的合理性

B、分析算法的效率以求改进、研究算法中的

C、输入和输出的关系

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

14.算法分析的两个主要方面是：A

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

B 正确性和简明性

C 可读性和文档性

D 数据复杂性和程序复杂

15.线性表Ｌ在 B 情况下适用于使用链式结构实现.

A 需经常修改Ｌ中的结点值

B 需不断对Ｌ进行删除插入

C Ｌ中含有大量的结点

D Ｌ中结点结构复杂

四、程序题

typedef struct LNode {

int data;

struct LNode ＊next；

｝LNode, ＊LinkList；

1.将下面算法填完整。

void ListInsert_L(node L,int i,elementtype x）

｛ LinkList p=L,s； int k=0;

while （＆& )

｛；k++;}

if （!p ｜|j〉i—1) return ERROR;

s=（LinkList） malloc （sizeof(node））;

s->data=x；

；

；}

1．P

k〈i-1

p=p—〉next

s—〉next=p—〉next；

p->next=s;

2. 简述下面算法的功能

void AC （LinkList &L） {

// L为一个无头结点的单链表

if （L&&L-〉next) ｛

q=L; L=L—>next; p=L;

while (p->next） p=p-〉next;

p—>next=q； q—>next=NULL；

｝

｝

将该单链表的表头元素移到表尾

3. 简述下面算法的功能

void AE (LNode ＊s， LNode *q） {

p=s；

while （p->next!=q) p=p->next；

p—>next=s；

}

void AD （LNode *pa, LNode ＊pb）｛

// pa和pb分别指向单循环链表中的两个结点

AE (pa, pb）;

AE (pb, pa);

｝

将一个单循环链表拆分成两个单循环链表(指针pa和pb分别指向这两个单循环链表中的某两个节点) 4.下列算法为删除带头结点的单链表head中值为x的算法，将程序填完整（每空2分)

已知结构体：typedef struct LNode {

ElemType data；

struct LNode *next；

｝LNode，＊LinkList；

void del(LinkList head）

{ q=head；

;

while（p ＆＆ ))

{ q=p；

_________;｝

if(p= = null) printf（“error”）;

else

｛______________；

free(p);printf（“success!"）；}

｝

p=q—>next

p—〉data!=x

p=p-〉next

q—>next=p-〉next

5。下列算法为删除单链表中值为X的算法，将程序填完整（4分，每空2分)已知结构体： struct node {

ElemType data；

struct LNode ＊next;

｝；

void del（struct node *head)

{ q=head;

p=q—〉next;

while(（p ）＆＆(p-〉data！=x )）

{ q=p；

___ ___；}

if（p= = null) printf（“error”)；

else{__ ____;

free(p）；printf(“success！"）；}}

p=q->next

q—>nex=p—>next

6。下列算法为利用尾插法，建立一个单链表，将程序填完整程序

void CreateList (LinkList ＆L,int n）{

LinkList r,p;int i;

L=（LinkList）malloc(sizeof(node）)；

L—〉next=NULL；

;

for(i=n;i>0；——i)｛

p=(LinkList)malloc（sizeof（node));

scanf(“%c”,&p-〉data）;

；

r—>next=p；

；

｝｝

r=L;

p—〉next=NULL；

r=p;

队栈串数组广义表

一、判断题：

1.递归的算法简单、易懂、容易编写,而且执行效率也高.（ f ）

2.链式栈与顺序栈相比, 一个明显的优点是通常不会出现栈满的情况。( t ）

3.堆栈、队列和数组的逻辑结构都是线性表结构。（ t ）

4.单链表形式的队列,头指针F指向队列的第一个结点，尾指针R指向队列的最后一个结点（f )

5.若某堆栈的输入序列为1,2,3，4，则4,3，1,2不可能是堆栈的输出序列之一。（t ）

6.栈和队列都是限制取点的线性结构( t )

7.栈和队列都是顺序存取的线性表，但它们对存取位置的限制不同.（ t ）

8.稀疏矩阵压缩存储后，必会失去随机存取功能.（ t ）

9.如果两个串中含有相同的字符，则这两个串相等（ f ）

10.广义表的表头和表尾既可以是单元素,也可以是广义表。（ f ）

二、填空题:

1.在初始为空的队列中插入元素A,B,C,D以后，紧接着做了两次删除操作，此时的队尾元素是

__d__。

2.已知循环队列的存储空间为数组a[21]，且头指针（指向队头元素）和尾指针（队尾元素的下一

位置）分别为8和3，则该队列的当前长度为__16__。

3.栈结构允许进行删除操作的一端为__栈顶__。

4.队列又称为__先进先出__的线性表

5.对于顺序存储的队列,存储空间大小为n，头指针为F,尾指针为R。若在逻辑上看一个环,则队列

中元素的个数为__(r+n）—f__。

6.队列的特点是__先进先出_。

7.栈又称为先进后出的线性表，队列又称为先进先出的线性表。

8.设数组A[m］为循环队列Q的存储空间，font为头指针,rear为尾指针，判定Q为空队列的条件

__front==rear___。

9.设元素1，2，3，4，5依次进栈S，若要在输出端得到序列34251，则应进行的操作序列为:push

（S，1)，push（S，2），push（S,3），pop(S），push(S，4)，pop（S)，pop（S），push（S，5）,pop

（S),pop(S）。

10.一个串的任意个连续的字符组成的子序列称为该串的子串，包含该子序列的串称为主串，该子

序列在串中的位置用子串的第一个字符在主串中的位置来表示.

11.在串的链式存储方式中，结点越大，运算处理越不方便（方便/不方便),存储占用量越小(大/小）。

12.求串T在主串S中首次出现的位置的操作是__模式匹配__。

13.广义表(A,(a,b),d,e，（(i，j),k）),则广义表的长度为5,深度为3,表头为A，表尾为

((a,b）,d,e,(（i，j),k)）。

14.已知广义表ls=（a，(b,c，d），e),运用head和tail函数取出ls中的原子b的运算是_head

（head（tail（ls))）_。

15.设有二维数组A[5]［6］,其每个元素占两个存储单元，第一个元素的存储地址为1100，若按行

优先顺序存储，则元素A［2][3]的存储地址为1130,按列优先顺序存储，元素A[2]［3］的存储

地址为1134。

16.设有二维数组A[9][19］(下标从0开始)，其每个元素占两个字节，第一个元素的存储地址为

100，若按行优先顺序存储,按列优顺序存储，元素A［6,6]的存储地址为__220__。

17.设二维数组A[m]［n]按列优先存储，每个元素占1个存储单元，元素A00的存储地址loc(A00），

则A ij的存储地址loc(A ij）= __ loc(a00）+（j*m+i）*1__.

18.

三、选择题：

1.判定一个栈ST(最多元素为m0）为空的条件是___b__

2.A．ST-〉top〈〉0 B．ST—〉top=0

C．ST->top<〉m0 D．ST->top=m0

3.链式栈与顺序栈相比，一个比较明显的优点是___b_____。

A。插入操作更加方便 B. 通常不会出现栈满的情况

C. 不会出现栈空的情况

D. 删除操作更加方便

4.假定一个顺序队列的队首和队尾指针分别为front和rear，则判断队空的条件是__d______。

A。 front+1= =rear B。 rear+1= =front C. front= =0 D. front= =rea

5.队和栈的主要区别是__d______

A。逻辑结构不同 B。存储结构不同

C.所包含的运算个数不同 D。限定插入和删除的位置不同

6.假定利用数组a［N]循环顺序存储一个队列，用front(指向队首元素）和rear（指向队尾元素的下一

位置)分别表示队首和队尾指针,并已知队列未空，当出队并返回队首元素时所执行的操作为__d____. A。 return a[++rear%N]； B. return a[-—rear%N];

C. return a［++front％N]；

D. return a[front++%N]；

7.入栈次序是a,b,c,d,e，则出栈次序不可能是___c_____。

A．e，d，c,b，a B．d，e，c,b,a C．d,c,e，a,b D．a,b，c，d,e

8.由两个栈共享一个向量空间的好处是___b___。

A减少存取时间,降低下溢发生的机率B节省存储空间，降低上溢发生的机率

C减少存取时间,降低上溢发生的机率D节省存储空间，降低下溢发生的机率

9.假定利用数组a［N]顺序存储一个栈，用top表示栈顶指针,top = = 0表示栈空，并已知栈未满，当

元素x进栈时所执行的操作为___D___。

A. a［--top] = x； B。 a[top—-］ = x; C. a[++top］ = x； D。 B。 a[top++］ = x；

10.假定利用数组a［N］顺序存储一个栈,用top表示栈顶指针，top = = 0表示栈空，并已知栈未空，

当出栈并返回栈顶元素时所执行的操作为___A___。

A。 return a［--top］； B。 return a[top——]； C. return a［++top］； D。 return a［top++];

11.假定一个循环顺序队列的队首和队尾指针分别为f和r，则判断队空的条件是__D___。

A。f+1==r B.r+1==f

C.f==0 D。f==r

12.若让元素1，2,3依次进栈，则出栈次序不可能出现___C___种情况.

A。 3,2,1 B. 2,1，3 C。 3,1,2 D。 1，3，2

13.当利用大小为N的一维数组存储一个循环队列时，则该队列的最大长度为___B___。

A. N—2

B. N-1

C. N

D. N+1

14.假定利用数组a［N]循环顺序存储一个队列，用front和rear分别表示队首和队尾指针，并已知队列

未满,当元素x入队时所执行的操作为___B___.

A。 a［++rear%N］=x； B. a[rear++％N]=x； C. a［-—rear％N]=x； D。 a［rear—-％N]=x；

15.如下陈述中正确的是___A___.

A. 串是一种特殊的线性表

B. 串的长度必须大于零

C. 串中元素只能是字母 D。两个串s1和s2若长度相同，则这两个串相等

16.如下陈述中正确的是___A___。

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

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

17.在以下的叙述中,正确的是___A___。

A. 二维数组可以看做它的每个数据元素为一个线性表的线性表

B。栈的操作方式是先进先出

C。线性表的线性存储结构优于链表存储结构

D. 队列的操作方式是先进后出。

18.一个非空广义表的表头___D___。

A．不可能是子表B．只能是子表

C．只能是原子D．可以是子表或原子

19.在目标串T［0…n—1]="xwxxyxy"中,对模式串p［0…m—1］=”yy”进行子串定位操作的结果____A___

A。0 B.2 C。3 D。5

20.数组A中，每个元素的长度为3字节，行下标从1到8,列下标从1到10，从首地址SA开始连续存放

在存储器中,按行存放时，元素a［8][5]地址为（ C )

A SA+141

B SA+180

C SA+222

D SA+225

21.串是一种特殊的线性表，其特殊性体现在：B

A．可以顺序存储 B．数据元素只能来自字符集

C．可以链式存储 D．数据元素可以是多个字符

五、算法

1.Q 是一个循环队列，请分别写出插入和删除一个元素的算法

#define MAXSIZE 100//最大队列长度

typedef struct{

QElemType *base;

int front，rear ;

｝SqQueue;

(以下算法3分:）

int EnQueue( SqQueue &Q，QElemType x )

｛

//Q是一个循环队列，若队列不满，则将x插入并返回1；否则返回0

if （（Q。rear +1)％MAXSIZE = = Q。front)

return 0; // 队列满

Q。base［Q。rear]=x；

Q.rear= (Q。rear +1）% MAXSIZE;

return 1;

｝

（以下算法3分:）

int DeQueue( SqQueue＆ Q， QElemType &x )

｛

//Q 是一个循环队列，若队列不空，则删除队头元素并由x带回,

//且返回1；否则返回0

if (Q.front = = Q。rear)

return 0;

else

{ x=Q。base［Q.front]；

Q。front= (Q。front + 1 ）％ MAXSIZE；

return 1；}

)

1.已知：Q 是一个循环队列，并且已知下列定义：

＃define MAXSIZE 100

typedef struct{

QElemType base［MAXSIZE];

int front，rear ；

｝SqQueue；

约定：顺序队中，非空队中，头指针始终指向队列头元素的前一个元素，而尾指针始终指向队列尾元素。

请写出插入一个元素的算法（6分，每空2分）

int EnQueue（ SqQueue &Q,QElemType x ）

{

if （）

return 0;

Q．rear= ；

Q．base［]=x;

return 1；

}

四．算法分析

简述下列算法的功能（栈和队列的元素类型为int)

1.Status AA (Stack S) ｛

int i, n， A[255];

n=0；

while （！StackEmpty （S）) {n++; Pop （S,A［n])；｝

for (i=1; i〈=n; i++) Push （S， A[i]）;

｝

栈S就地逆置。

2.Status AB （Stack S， int e） {

Stack T； int d;

InitStack (T）;

while (!StackEmpty (S）) {

Pop （S， d）;

if （d！=e) Push （T， d)；

}

while （！StackEmpty (T)) {

Pop (T， d）；

Push (S， d);

}

｝

删除栈S中值等于e的元素。

3.void AC (Queue ＆Q) {

Stack S； int d;

InitStack （S）；

while （！QueueEmpty(Q）） {

DeQueue （Q, d）; Push (S， d);

}

while (!StackEmpty（S)) ｛

Pop （S， d）； EnQueue （Q， d）;

}

}

队列Q就地逆置。

4.简述下面算法的功能。（2分）

void conversion( ）

｛ initstack(s）；//初始化栈

scanf （“%d”，n);

while(n）

｛ push（s,n％8);