数据结构习题(覆盖面全,难度大)

习题一绪论

一、单项选择题

① A. 计算方法 B. 排序方法

C. 解决问题的有限运算序列

D. 调度方法

② A. 可执行性、可移植性和可扩充性

B. 可行性、确定性和有穷性

C. 确定性、有穷性和稳定性

易读性、稳定性和安全性

答：① C ②B

二、简述下列概念

数据，数据元素，数据类型，数据结构，逻辑结构，存储结构，线性结构，非线性结构。

答：数据——是对客观事物的符号表示，在计算机科学中是指所有能输入到计算机中边被计算机程序处理的符号的总称。

数据元素——数据的基本单位，在计算机程序中通常做为一个整体进行考虑和处理。

数据类型——是具有相同性质的计算机数据的集合及在这个数据上的一组运算，是和数据结构密切相关的概念。

数据结构——是相互之间存在一种或多种特定关系的数据元素的集合。

逻辑结构——数据元素之间的逻辑关系的描述，称为数据的逻辑结构。

存储结构——数据结构在计算机中的表示称为数据的物理结构，又称存储结构。

线性结构——结构中的数据元素之间存在一个对一个的关系。

非线性结构——我们也可以将树形结构、集合和网状结构归纳为非线性结构。

三、填空题

1．下面程序段的时间复杂度是_______。

For (i=0;i

For (j=0;j

A[i][j]=0;

答：O(m*n)

2．下面程序段的时间复杂度是_______。

i=s=0

While(s

{

i++;

s+=i;

}

答：O(n开根号)

3．下面程序段的时间复杂度是_______。

s=0;

for (i=0;i

for (j=0;j

s+=B[i][j];

sum=s;

答：O（n^2)

4．下面程序段的时间复杂度是_______。

i=1;

While (i<=n)

i=i*3;

答：log3n

第二章线性表

一、判断题

1．线性表的逻辑顺序与存储顺序总是一致的。(ERROR)

2．顺序存储的线性表可以按序号随机存取。(OK)

3．顺序表的插入和删除一个数据元素，因为每次操作平均只有近一半的元素需要移动。（OK）

4．线性表中的元素可以是各种各样的，但同一线性表中的数据元素具有相同的特性，因此是属于同一数据对象。（OK）

5．在线性表的顺序存储结构中，逻辑上相邻的两个元素在物理位置上并不一定紧邻。（ERROR）

6．在线性表的链式存储结构中，逻辑上相邻的元素在物理位置上不一定相邻。（OK）

7．线性表的链式存储结构优于顺序存储结构。（ERROR）

8．在线性表的顺序存储结构中，插入和删除时，移动元素的个数与该元素的位置有关。（OK）

9．线性表的链式存储结构是用一组任意的存储单元来存储线性表中数据元素的。（OK）

10．在单链表中，要取得某个元素，只要知道该元素的指针即可，因此，单链表是随机存取的存储结构。（ERROR）

二、单选题、(请从下列A，B，C，D选项中选择一项)

11．线性表是( A )。

(A) 一个有限序列，可以为空； (B) 一个有限序列，不能为空；

(C) 一个无限序列，可以为空； (D) 一个无序序列，不能为空。

12．对顺序存储的线性表，设其长度为n，在任何位置上插入或删除操作都是等概率的。插入一个元素时平均要移动表中的（A）个元素。

(A)n/2 (B) (n+1)/2 (C) (n –1)/2 (D) n

13．线性表采用链式存储时，其地址(D )。

(A) 必须是连续的； (B) 部分地址必须是连续的；

(C) 一定是不连续的； (D) 连续与否均可以。

14．用链表表示线性表的优点是（C ）。

(A)便于随机存取

(B)花费的存储空间较顺序存储少

(C)便于插入和删除

(D)数据元素的物理顺序与逻辑顺序相同

15.某链表中最常用的操作是在最后一个元素之后插入一个元素和删除最后一个元素，则采用( D )存储方式最节省运算时间。

(A)单链表

(B)双链表

(C)单循环链表

(D)带头结点的双循环链表

16.循环链表的主要优点是( D ) 。

(A)不再需要头指针了

(B)已知某个结点的位置后，能够容易找到他的直接前趋

(C)在进行插入、删除运算时，能更好的保证链表不断开

(D)从表中的任意结点出发都能扫描到整个链表

17. 下面关于线性表的叙述错误的是( B)。

(A) 线性表采用顺序存储，必须占用一片地址连续的单元；

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

(C) 线性表采用链式存储，不必占用一片地址连续的单元；

(D) 线性表采用链式存储，便于进行插入和删除操作；

18. 单链表中，增加一个头结点的目的是为了（C ）。

(A) 使单链表至少有一个结点(B)标识表结点中首结点的位置

（C）方便运算的实现(D)说明单链表是线性表的链式存储

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

(A) 单链表(B)仅有头指针的单循环链表

(C)双链表(D)仅有尾指针的单循环链表

20. 若某线性表中最常用的操作是取第i个元素和找第i个元素的前趋元素，则采用（）存储方式最节省运算时间（B ）。

(A) 单链表(B)顺序表

(C)双链表(D)单循环链表

21.一个向量(一种顺序表)第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是_______。

A. 110

B. 108

C. 100

D. 120

答：B

[第5个元素的地址=100+2*(5-1)=108]

22.不带头结点的单链表head为空的判定条件是______。

A. head = = NULL;

B. head->next = = NU

LL;

C. head->next = = head;

D. head! = NULL;

答：A

23.带头结点的单链表head为空的判定条件是______。

A. head = = NULL;

B. head->next = =

NULL;

C. head->next = = head;

D. head! = NULL;

答：B

24.在循环双链表的p所指结点之后插入s所指结点的操作是_____。

A. p->right=s; s->left=p; p->right->left=s; s=->right=p->righ t;

B. p->right=s; p->right->left=s; s->left=p; s->right=p->right ;

C. s->left=p; s->right= p->right; p->right=s; p->right->left =s;

D. s->left=p; s->right=p->right; p->right->left=s; p->right=s ;

答：D

25.在一个单链表中，已知q所指结点是p所指结点的前驱结点，若在q和p 之间插入s结点，则执行______。

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

B. p->next=s->next ; s->next=p;

C. q->next=s; s->next=p;

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

答：C

26. 从一个具有n个结点的单链表中查找其值等于x结点时，在查找成功的情况下，需平均比较_____个结点。(参见网上讲义：1.4.2例1_5)

A. n;

B. n/2;

C. (n-1)/2;

D. (n+1)/2;

答：D

27. 给定有n个结点的向量，建立一个有序单链表的时间复杂度_______。

A. O(1);

B. O(n);

C. O(n);

D. O(nlog n);

答：C

三、填空题

28.在一个长度为n的向量中的第i个元素(1≤i≤n)之前插入一个元素时，需向后移动_____个元素。

答：n-i+1

29.在一个长度为n的向量中删除第i个元素(1≤i≤n)时，需向前移动_____个元素。

答：n-i

30．在一个单链表中p所指结点之前插入一个由指针s所指结点，可执行以下操作：

s->next=__p->next_____;

p->next=s;

t=p->data;

p->data=___s->data________;

s->data=___t________;

四、算法设计题：

31. 有一个单链表（不同结点的数据域值可能相同），其头指针为head，编写一个函数计算数据域为x的结点个数。

解：本题是遍历通过该链表的每个结点，每遇到一个结点，结点个数加1，结点个数存储在变量n中。实现本题功能的函数如下：

int count (head, x)

node *head;

ElemType x;

{

node *p;

int n=0;

p=head;

while (p!=NULL)

{

if (p->data= =x) n++;

p=p->next;

}

return(n);

}

32. 有一个有序单链表（从小到大排序），表头指针为head，编写一个函数向该单链表中插入一个元素为x的结点，使插入后该链表仍然有序。

解：本题算法的思想是先建立一个待插入的结点，然后依次与链表中的各结点的数据域比较大小，找出该结点的位置，最后插入该结点。实现本题功能的函数如下：

node *insertorder(head, x)

node *head;

ElemType x;

{

node *s, *p, *q;

s=(node *)malloc(sizeof(node));

s->data=x;

s->next=NULL;

if (head= =NULL ‖xdata)

{

s->next=head;

head=s;

}

else

{

q=head;

p=q->next;

while (p!=NULL &&x>p->data)

if (x > p->data)

{

q=p;

p=p->next;

}

s->next = p;

q->next=s;

}

return(head);

}

33．编写一个函数将一个头指针为a的单链表A分解成两个单链表A和B，其头指针分别为a和b，使得A链表中含有原链表A中序号为奇数的元素，而B 链表中含有原链表A中序号为偶数的元素，且保持原来的相对顺序。

解：其函数是将单链表A中的所有偶数序号的结点删除，并在删除时把这些结点链接起来构成单链表B。实现本题功能的函数如下：

void disa(a, b)

node *a, *b;

{

node *r, *p, *q;

p=a;

b=a->next;

r=b;

while (p!=NULL &&p->next!=NULL)

{

q = p->next;

p->next=q->next;

r->next=q;

r=q

p=p->next;

}

r->next=NULL;

}

34. 假设有两个已排序的单链表A和B，编写一个函数将它们合并成一个链表C而不改变其排序性。

解：这里采用链表合并的方法，设原两链表的头指针分别为p和q，每次比较p->data和q->data的值，把值较小的结点作为新链表的结点，这一过程直到一个链表为空为止。当一个链表为空而另一个链表不为空时，只要将不空的链表指针赋给新链表中最后一个结点的指针即可。实现本题功能的函数如下：

node *mergelink(p, q)

node *p, *q;

{

node *h, *r;

h=(node *)malloc(sizeof(node));

h->next=NULL;

r=h;

while (p!=NULL &&q!=NULL)

if (p->data<=q->data)

{

r->next=p;

r=p;

p=p->next;

}

else

{

r->next=q;

r=q;

q=q->next;

}

if (p= =NULL)

r->next=q;

if (q= =NULL)

r->next=p;

/*下面三句要去掉链表C的头结点，如果不想去掉，则不要这三句*/

p=h->next;

h=h->next;

free(p);

return h;

}

35．设A=（a,…,a）和B=（b,…,bn）均为顺序表，A’和B’分别为A和

B中除去最大共同前缀后的子表（例如，A=（x，y，y，z，x，z），B=（x，y，y，z，y，x，x，z），则两者中最大的共同前缀为（x,y,y,z），在A’=B’=空表，则A=B；若A’=空表，而B’<>空表，或者两者均不为空表，且A’的首元小于B’的首元，则AB。（词典次序）试写一个比较A，B大小的算法（在算法中，不要破坏原表A和B，并且不一定先求得A’和B’才进行比较）。

36. 设有一个用向量表示的线性表L，要求写出一个将该表逆置的过程，并允许在原表的存储空间外再增加一个附加的工作单元。(朱儒荣, C语言版数据结构考研例题)

解：用数据类型描述Seqlist顺序存储结构：

vold converts(seqlist L)

{ k=L.length;

m = k/2;

for(i = 0;i

x = L.element[i];

L.element[i] = L.element[k-i-1];

L.element[k-i-1] = x;

}

} // converts

讨论：这个算法过程只须进行数据元素的交换操作，其主要时间花费在for 循环上，整个算法的时间复杂度为O(k)。

37.已知两个整数集合A和B，它们的元素分别依元素值递增有序存放在两个单链表HA和HB中，编写一个函数求出这两个集合的并集C,并要求集合C 的链表的结点仍依元素值递增有序存放。(提示：求并集不是归并!)

38．已知两个顺序表A和B分别表示两个集合，其元素递增排列，编写一个函数求出A和B的交集C，要求C同样以元素递增的顺序表形式存储。

void SqList_Intersect(SqList A,SqList B,SqList &C)

//求元素递增排列的线性表A和B的元素的交集并存入C中

{

i=0;j=0;k=0;

while(A.elem[i]&&B.elem[j]){

if(A.elem[i]

if(A.elem[i]>B.elem[j]) j++;

if(A.elem[i]==B.elem[j]){

C.elem[k++]=A.elem[i];

//当发现了一个在A,B中都存在的元素,

i++;j++;

//就添加到C中

}

}//while

}//SqList_Intersect

算法设计题：

27．假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点(注意不设头指针)，试编写相应的队列初始化、入队列和出队列的算法。

解：void InitCiQueue(CiQueue &Q)//初始化循环链表表示的队列Q

{

Q=(CiLNode*)malloc(sizeof(CiLNode));

Q->next=Q;

}//InitCiQueue

void EnCiQueue(CiQueue &Q,int x)//把元素x插入循环链表表示的队列Q，Q指向队尾元素，Q->next指向头结点，Q->next->next指向队头元素

{

p=(CiLNode*)malloc(sizeof(CiLNode));

p->data=x;

p->next=Q->next;//直接把p加在Q的后面

Q->next=p;

Q=p;//修改尾指针

}

Status DeCiQueue(CiQueue &Q,int x) //从循环链表表示的队列Q头部删除元素x {

if(Q==Q->next) return INFEASIBLE;//队列已空

p=Q->next->next;

x=p->data;

Q->next->next=p->next;

free(p);

return OK;

}//DeCiQueue

28．利用两个栈s1，s2模拟一个队列时，如何用栈的运算来实现该队列的运算：enqueue:插入一个元素；

dequeue:删除一个元素；

queue_empty:判定队列为空。

解：由于栈的特点是先进后出，为了模拟先进先出的队列，必须用两个栈，一个栈s1用于插入元素，另下栈s2用于删除元素，每次删除元素时应将前一个栈的所有元素读出然后进入第二个栈中，这样才能达到模拟队列的效果，这里使用栈的一些基本操作如下：

push(ST,x):栈的压入

ptop(ST,x):退出栈顶元素赋给x

sempty(ST):判定栈是否为空

void enqueue(s1,x)

stack s1;

int x;

{

if(s1->top== m0) printf(“队列上溢出！\n”);

else push(s1,x);

}

void dequeue(s1,s2,x)

stack s1,s2;

int x;

{

s2->top=0;

while(!sempty(s1))

push(s2,ptop(s1));

ptop(s2,x);

while(!sempty(s2))

push(s1,ptop(s2));

}

int queue_empty(s1)

stack s1;

{

if sempty(s1) return(1);

else return(0);

}

29．假设称正读和反读都相同的字符序列为“回文”(即回文是指一个字符序列以中间字符为基准两边字符完全相同)，例如，‘abba’和‘abcba’是回文，‘ababab’则不是回文。试

编写一个判断读入的一个以‘@’为结束符的字符序列是否“回文”的算法。

解：[解题思路：判断回文算法Palindrome_Test()的思想是：把字符串中的字符逐个分别存入队列和堆栈，然后逐个出队列和退栈并比较出队列的数据元素和退栈的数据元素是否相等，若全部相等则该字符序列是回文，否则就不是回文。]

实现本题功能的函数如下(类C编写)：

int Palindrome_Test() //判别输入的字符串是否是回文序列，是则返回1，否则返回0 {

Initstack(S); InitQueue(Q);

while ( (c =getchar()) !=‘@’)

{

Push(S,c); EnQueue(Q,c); //同时使用栈和队列两种结构

}

while(!StackEmpty(S))

{

Pop(S,a); DeQueue(Q,b);

if(a!=b) return ERROR;

}

return OK;

}//Palindrome_Test

数据结构-串（上）

(2010-07-02 02:05:15)

标签：

校园

判断题：

1．空串是由空白字符组成的串（ FALSE ）

2. 串的定长顺序结构是用一组地址连续的存储单元存储串值的字符序列，按照预定义的大小，为每个定义

的串变量分配一个固定长度的存储区。(TRUE )

3．串的堆分配存储表示是用一组地址连续的存储单元存储串值的字符序列，但它们的存储空间是在程序执

行过程中动态分配得到的。（TRUE ）

4．串中StrInsert(&S,pos,T)基本操作是最小的操作子集（FALSE）

5.串是由有限个字符构成的连续序列，串长度为串中字符的个数，子串是主串中字符构成的有限序列。

(FALSE)

(错：子串是主串中连续的字符构成的有限序列)

(题源：胡元义，C版数据结构课程辅导与习题解析，p80，4.2.1(判断题)_1)

6.如果一个串中的所有字符均在另一串中出现，那么则说明前者是后者的子串。(FALSE)

( 错：是否连续是关键)

(题源：陈明，C版实用数据结构基础，p109，(判断题)_2)

7.串类型的最小操作子集不能利用其他串操作来实现，反之，其他串操作均可在最小操作子集上实现。

(TRUE)

(题源：根据教材p72自编)

单项选择题：

8．下列那些为空串（）

A）S=“” B）S=“”

C）S=“φ” D）S=“θ”

答案：B

9．S1=“ABCD”，S2=“CD”则S2在S3中的位置是（）

A）1 B）2

C）3 D）4

答案：C

10.假设S=“abcaabcaaabca”，T=“bca”，Index (S,T,3) 的结果是（）

A）2 B）6 C）11 D）0

答案：B

11.在串中，对于SubString(&Sub,S,pos,len)基本操作，pos和len的约束条件是（）

A）0

B）0

C）1<=pos<=StrLength(S) 且0<=len<=StrLength(S)-pos+1

D）1<=pos<=StrLength(S) 且1<=len<=StrLength(S)-pos-1

答案：C

12. 串是一种特殊的线性表，其特殊性体现在( )。

(题源：李春葆，C版题解，p102，4.2.1(单选)_2)

A．可以顺序存储 B. 数据元素是一个字符

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

答：B

13. 串是( )。

(题源：陈明，C版实用数据结构基础，p109，习题(单选)_1)

A．少于一个字母的序列 B. 任意个字母的序列

C．不少于一个字符的序列 D. 有限个字符的序列

答：D

14. 串的长度是( )。

(题源：陈明，C版实用数据结构基础，p109，习题(单选)_3)

A．串中不同字母的个数 B. 串中不同字符的个数

C．串中所含的字符的个数 D. 串中所含字符的个数，且大于0

答：C

15. 设有S1=‘ABCDEFG’，S2=‘PQRST’，函数con(x，y)返回x和y串的连接串，subs(I，j)返回串S的从序号I的字符开始的j个字符组成的子串，len(s)返回串s的长度，则con(subs(S1，2，len(S2))，subs(S1，

len(S2)，2))的结果是( )。

(题源：李春葆，C版题解，p102，4.2.1(单选)_4)

答：D

16. 若某串的长度小于一个常数，则采用( )存储方式最为节省空间。

(题源：胡元义，C版数据结构课程辅导与习题解析，p90，4.3.1习题(4.3))

A．链式 B. 堆结构 C. 顺序表

答：C

填空题：

17．串是每个结点仅由一个字符组成的（）。

答：线性表

18．在串中，SubString (“student”,5,0) 的结果是（）

答：“”

19．假设S=“abcaabcaaabca”，T=“bca”，V=“x”，Replace (S,T,V)结果是（）

答：“axaxaax”

20．在串中，对于StrCompare(S,T)基本操作，若S

答：<0

21．在串顺序存储结构中，实现串操作的原操作为（）

答：字符序列的复制

22. 串与线性表在逻辑结构上极为相似，区别仅在于；在基本操作上差别很大，线性表的基本操作大多数以作为操作对象，而串的基本操作通常以作为操作对象。

(题源：根据教材p71页自编)

答：串的数据对象约束为字符集“单个元素”“串的整体”

23．两个串相等的充分必要条件是且。

(题源：根据教材p70页自编)

答：两个串的串长相等各个对应位置的字符都相等

24.空串是指____________________，空格串是指_______________________。

(题源：：宁正元C版题解p40(4.1(填空)_5 ))

答：不含任何字符的串仅含空格字符的串

简答题：

25．已知串s=‘(xyz)*’，t=‘(x+z)*y’，试利用串的基本运算将s串转化为t串，t串转化为s串。

(题源：宁正元，C版题解，p40，4.2_3)

答：concat ( replace (substring (sub,s,1,5),‘y’,‘+’), replace (substring (sub,s,6,1),‘*’，‘*y’)) concat(replace(substring(sub,t,1,5),‘+’,‘y’),replace(substring(sub,t,6,2),‘*y’,‘*’))

26．串是字符组成的，长度为1的串和字符是否概念相同？为什么？

(题源：朱战立，C版题解，p86，4.2.1(典型题解)_2)

答：由于字符的长度固定为1，长度概念可以隐含，所以存储时只需存储该字符即可；而长度为1的串其长度概念不能隐含，必须显示地表示出来，所以存储时要同时存储该字符和值为1的长度值。

算法设计题：

27．设串s和串t采用顺序存储结构，编写函数实现串s和串t的比较操作，要求比较结果包括大于、小于和等于三种情况。

解：int StrCompare(SStrType s,SStrType t)

{

int n=s.length, m=t.length, i,j,tag;

i=0; j=0;

while(i

{

if(s.str[i]==t.str[j])

{

i++;j++;

}

else if(s.str[i]>t.str[j])

{

tag=1;

return tag;

}

else

{

tag=-1;

return tag;

}

}

if(n==m) tag=0;

else if(n>m) tag=1;

else if(n

return tag;

}

28．输入一个由若干单词组成的文本行，每个单词之间用若干个空格隔开，统计此文本中单

解：int count(r)

char r[80];

{

char prec,nowc;

int num,j;

prec=‘ ’; num=0;

for(j=0;j<80;j++)

{

nowc=r[j];

if((nowc!=‘ ’)&&(prec==‘ ’))

num++;

prec=nowc;

}

return num;

}

29．编写算法，求串s所含不同字符的总数和每种字符的个数。(题源：严蔚敏，C版习题集，p29，4.18)

解：typedef struct{

char ch;

int num;

}mytype;

void StrAnalyze(Stringtype S) //统计串S中字符的种类和个数{

mytype T[MAXSIZE]; //用结构数组T存储统计结果for(i=1;i<=S[0];i++)

{

c=S[i];j=0;

while(T[j].ch && T[j].ch!=c) j++;

//在结构数组T中逐元素查找当前字符c是否已记录过.

//当循环停止时，再看是什么原因造成的停止。

if(T[j].ch) T[j].num++;

//循环停止时T[j].ch不等于NULL,说明是由于T[j].ch=c所致

//若是T[j].ch =c所致则说明字符c在串s中已经出现过

//故将其个数加1.

else T[j]={c,1}; //否则为首次出现，将其出现次数记为1. }//for

for(j=0;T[j].ch;j++) //打印每个字符在串s中的出现次数。

printf(“%c: %d\n”,T[j].num);

数据结构-二叉树

判断题：

1.二叉树中每个结点有两个子女结点，而对一般的树则无此限制，因此二叉树是树的特殊情形。( ╳)

2.二叉树就是结点度为2的树。( ╳)( (哈工大2000年研究生试题)

3.二叉树中不存在度大于2的结点，当某个结点只有一棵子树时无所谓左、右子树之分。( ╳) (陕西省1998年自考试题)

4.当k≥1时，高度为k的二叉树至多有个结点。( ╳)

5.完全二叉树的某结点若无左孩子，则它必是叶结点。(√)(中科院软件所1997年研究生试题)

6.用一维数组存放二叉树时，总是以前序遍历顺序存储结点。( ╳)

7.若有一个结点是某二叉树子树的中序遍历序列中的最后一个结点，则它必是该子树的前序遍历序列中的最后一个结点。( ╳)

8.存在这样的二叉树，对它采用任何次序的遍历，结果相同。(√)

(哈工大2000年研究生试题)

9.中序线索二叉树的优点之一是便于在中序下查找前驱结点和后继结点。(√)

10.将一棵树转换成二叉树后，根结点没有左子树，( ╳)

(北邮1999年研究生试题。)

11.由树转换成二叉树，其根结点的右子树总是空的。(√)

12.前序遍历森林和前序遍历与该森林对应的二叉树其结果不同。( ╳)

13.在叶子数目和权值相同的所有二叉树中，最优二叉树一定是完全二叉树。( ╳)

14.在哈夫曼编码中，当两个字符出现的频率相同时，其编码也相同，对于这种情况应作特殊处理。( ╳)

15.霍夫曼树一定是满二叉树。( ╳)

16.树的度是树内各结点的度之和。( ╳)

17.由二叉树的结点构成的集合可以是空集合。(√)

18.一棵树中的叶子结点数一定等于与其对应的二叉树中的叶子结点数。( ╳)

选择题：

19.树最适合用来表示( C )。

A．有序数据元素 B. 无序数据元素

C．元素之间具有分支层次关系的数据 D. 元素之间无联系的数据

20.如果结点A有3个兄弟，而且B是A的双亲，则B的度是( A)。

A. 4

B. 5

C. 1

D. 3

21.下列有关二叉树的说法正确的是( B )。

(南京理工大学2000年研究生试题。)

A．二叉树的度为2 B. 一棵二叉树度可以小于2

C．二叉树中至少有一个结点的度为2 D. 二叉树中任一个结点的度都为2

22.以下说法错误的是( B )。

A．二叉树可以是空集 B. 二叉树的任一结点都可以有两棵子树

C．二叉树与树具有相同的树形结构 D. 二叉树中任一结点的两棵子树有次序之分23.假定在一棵二叉树中，双分支结点数为15，单分支结点数为30个，则叶子结点数为( B )个。

A．15 B. 16 C. 17 D.47

24. 用顺序存储的方法将完全二叉树中的所有结点逐层存放在数组R[1..n]中，结点R[i]若有左子女，则左子女是结点( B )。

A．R[2i+1] B. R[2i] C. R[i/2] D. R[2i-1]

(参见严蔚敏《(c语言版)数据结构》P.124 ~ 125,二叉树的性质,性质5)

25.设a、b为一棵二叉树上的两个结点。在中序遍历时，a在b前面的条件是( B )。

A．a在b的右方 B. a在b的左方 C. a是b的祖先 D. a是b的子孙

26.以下说法正确的是( C )。

A．若一个树叶是某二叉树前序遍历序列中的最后一个结点，则它必是该子树后序遍历序列中的最后一个结点。

B．若一个树叶是某二叉树前序遍历序列中的最后一个结点，则它必是该子树中序遍历序列中的最后一个结点。

C．在二叉树中，具有两个子女的父结点，在中序遍历序列中，它的后继结点最多只能有一个子女结点。(提示：后继结点应为遍历右子树时访问的第一个结点，该后继结点或为叶子结点，则其无子女；或为仅有右子树，则其也是最多只能有一个子女；若有两个子女，则它本身已不是后继。)

D．在二叉树中，具有一个子女的父结点，在中序遍历序列中，它没有后继子女结点。27.以下说法错误的是( B )。

A．存在这样的二叉树，对它采用任何次序遍历其结点访问序列均相同。

B. 二叉树是树的特殊情形。

C. 由树转换成二叉树，其根结点的右子树总是空的。

D. 在二叉树只有一棵子树的情况与也要明确指出该子树是左子树还是右子树。

28.将下图的二叉树按中序线索化，结点X的右指针和Y的左指针分别指向( C )。

A．A，D B. B，C C. D，A D. C，A

29.在N个结点的线索二叉树中，线索的数目为( C )。

A．N-1 B. N C. N+1

D. 2N

(参见严蔚敏《(c语言版)数据结构》P.126 & P.132)

30.设有13个值，用它们组成一棵赫夫曼树，则该赫夫曼树共有( D )个结点。(全国2001年自考题)

A．13 B. 12 C. 26

D. 25

(参见严蔚敏《(c语言版)数据结构》P.147)

31.下面几个符号串编码集合中，不是前缀编码的是( B )。

栈和队列

习题3栈和队列

判断题

1.栈和队列都是限制存取点的线性结构（TRUE）

2.栈和队列是两种重要的线性结构。（TRUE ）

3.带头结点的单链表形式的队列，头指针F指向队列的头结点，尾指针R指向队列的最后一个结点（TRUE）

4.在对不带头结点的链队列作出队操作时，不会改变头指针的值。（FALSE）

单项选择题：

5.若已知一个栈的入栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，…，pn，若p1=n，则pi为( C )。

A．i B．n=i C．n-i+1 D．不确定

6．栈和队列的共同点是( C )。

A．都是先进后出B．都是先进先出

C．只允许在端点处插入和删除元素D．没有共同点

7．若依次输入数据元素序列{a，b，c，d，e，f，g}进栈，出栈操作可以和入栈操作间隔进行，则下列哪个元素序列可以由出栈序列得到？(A )

A．{d，e，c，f，b，g，a} B．{ f，e，g，d，a，c，b}

C．{e，f，d，g，b，c，a} D．{ c，d，b，e，g，a，f}

8.一个栈的入栈序列是1,2,3,4,5，则下列序列中不可能的出栈序列是( B )

A. 2,3,4,1,5

B. 5,4,1,3,2

C. 2,3,1,4,5

D. 1,5,4,3,2

9. 队列操作的原则是( A )

A. 先进先出

B. 后进先出

C. 只能进行插入

D. 只能进行删除

10. 栈的插入与删除是在( A )进行。

A. 栈顶

B. 栈底

C. 任意位置

D. 指定位置

11.假设顺序栈的定义为：

typedef struct {

selemtype *base; /* 栈底指针*/

selemtype *top; /* 栈顶指针*/

int stacksize; /* 当前已分配的存储空间,以元素为单位*/

}sqstack;

变量st为sqstack型，则栈st为空的判断条件为（ D ）。

A．st.base == NULL B．st.top == st.stacksize

C．st.top-st.base>= st.stacksize D．st.top == st.base

12.假设顺序栈的定义同上题，变量st为sqstack型，则栈st为满的判断条件为（C ）。A．st.base == NULL B．st.top == st.stacksize

C．st.top-st.base>= st.stacksize D．st.top == st.base