数据结构与算法1-5单元练习题及答案

单元练习1

一．判断题（下列各题，正确的请在前面的括号内打√；错误的打╳ ）

（√）（1）数据的逻辑结构与数据元素本身的内容和形式无关。

（√）（2）一个数据结构是由一个逻辑结构和这个逻辑结构上的一个基本运算集构成的整体。 （ㄨ）（3）数据元素是数据的最小单位。

（ㄨ）（4）数据的逻辑结构和数据的存储结构是相同的。

（ㄨ）（5）程序和算法原则上没有区别，所以在讨论数据结构时可以通用。 （√）（6）从逻辑关系上讲，数据结构主要分为线性结构和非线性结构两类。 （√）（7）数据的存储结构是数据的逻辑结构的存储映像。 （√）（8）数据的物理结构是指数据在计算机内实际的存储形式。 （ㄨ）（9）数据的逻辑结构是依赖于计算机的。 （√）（10）算法是对解题方法和步骤的描述。

二．填空题

（1） 数据有逻辑结构和 存储结构 两种结构。

（2） 数据逻辑结构除了集合以外，还包括：线性结构、树形结构和 图形结构 。 （3） 数据结构按逻辑结构可分为两大类，它们是线性结构和 非线性结构 。 （4） 树形结构 和 图形结构 合称为非线性结构。

（5） 在树形结构中，除了树根结点以外，其余每个结点只有 1 个前趋结点。 （6） 在图形结构中，每个结点的前趋结点数和后续结点数可以 任意多个 。 （7） 数据的存储结构又叫 物理结构 。

（8） 数据的存储结构形式包括：顺序存储、链式存储、索引存储和 散列存储 。 （9） 线性结构中的元素之间存在 一对一 的关系。 （10） 树形结构结构中的元素之间存在 一对多 的关系， （11） 图形结构的元素之间存在 多对多 的关系。

（12） 数据结构主要研究数据的逻辑结构、存储结构和 算法（或运算） 三个方面的内容。 （13） 数据结构被定义为(D，R)，其中D是数据的有限集合，R是D上的 关系 的有限集合。 （14） 算法是一个 有穷指令 的集合。

（15） 算法效率的度量可以分为事先估算法和 事后统计法 。 （16） 一个算法的时间复杂性是算法 输入规模 的函数。

（17） 算法的空间复杂度是指该算法所耗费的 存储空间 ，它是该算法求解问题规模n的函数。 （18） 若一个算法中的语句频度之和为T（n）=6n+3nlog2n，则算法的时间复杂度为 O（nlog2n） 。 （19） 若一个算法中的语句频度之和为T（n）=3n+nlog2n+n2，则算法的时间复杂度为 O（n2） 。 （20） 数据结构是一门研究非数值计算的程序设计问题中计算机的 操作对象 ，以及它们之间的关系和运算的学科。

三．选择题

（1）数据结构通常是研究数据的（ A ）及它们之间的相互联系。

A. 存储结构和逻辑结构 B. 存储和抽象 C. 联系和抽象 D. 联系与逻辑 （2）在逻辑上可以把数据结构分成：（ C ）。

A. 动态结构和静态结构 B. 紧凑结构和非紧凑结构 C. 线性结构和非线性结构 D. 内部结构和外部结构

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

A. 存储结构 B. 逻辑结构 C. 顺序存储结构 D. 链式存储结构 （4）非线性结构中的每个结点（ D ）。

A. 无直接前趋结点 B. 无直接后继结点

C. 只有一个直接前趋结点和一个直接后继结点 D. 可能有多个直接前趋结点和多个直接后继结点 （5）链式存储的存储结构所占存储空间（ A ）。

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

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

D． 分两部分，一部分存放结点的值，另一部分存放结点所占单元素 （6）算法的计算量大小称为算法的（ C ）。

A. 现实性 B. 难度 C. 时间复杂性 D. 效率 （7）数据的基本单位是（ B ）。

A. 数据结构 B. 数据元素 C. 数据项 D. 文件 （8）每个结点只含有一个数据元素，所有存储结点相继存放在一个连续的存储区里，这种存储结构称为（ A ）结构。

A. 顺序存储 B. 链式存储 C. 索引存储 D. 散列存储

（9）每一个存储结点不仅含有一个数据元素，还包含一组指针，该存储方式是（ B ）存储方式。 A. 顺序 B. 链式 C. 索引 D. 散列 （10）以下任何两个结点之间都没有逻辑关系的是（ D ）。

A. 图形结构 B. 线性结构 C. 树形结构 D. 集合 （11）在数据结构中，与所使用的计算机无关的是（ C ）。

A. 物理结构 B. 存储结构 C. 逻辑结构 D. 逻辑和存储结构 （12）下列四种基本逻辑结构中，数据元素之间关系最弱的是（ A ）。

A. 集合 B. 线性结构 C. 树形结构 D. 图形结构 （13）与数据元素本身的形式、内容、相对位置、个数无关的是数据的（ A ）。

A. 逻辑结构 B. 存储结构 C. 逻辑实现 D. 存储实现

（14）每一个存储结点只含有一个数据元素，存储结点存放在连续的存储空间，另外有一组指明结点存储位置的表，该存储方式是（ C ）存储方式。

A. 顺序 B. 链式 C. 索引 D. 散列 （15）算法能正确的实现预定功能的特性称为算法的（ A ）。

A. 正确性 B. 易读性 C. 健壮性 D. 高效性 （16）算法在发生非法操作时可以作出处理的特性称为算法的（ C ）。

A. 正确性 B. 易读性 C. 健壮性 D. 高效性 （17）下列时间复杂度中最坏的是（ D ）。

A. O（1） B. O（ n） C. O（log2n） D. O（n2） （18）下列算法的时间复杂度是（ D ）。 for (i=0;i

A. O（1） B. O（ n） C. O（log2n） D. O（n2） （19）算法分析的两个主要方面是（ A ）。

A. 空间复杂性和时间复杂性 B. 正确性和简明性 C. 可读性和文档性 D. 数据复杂性和程序复杂性 （20）计算机算法必须具备输入、输出和（ C ）。

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

C. 解决问题的有限运算步骤 D. 程序设计方法

四．分析下面各程序段的时间复杂度

（1） for (i=0;i

for (i=0;i

2

解： O(n) （3） T=A；

A=B； B=T； 解：O(1)

（4） s1(int n)

{ int p=1,s=0;

for (i=1;i<=n;i++) { p*=i;s+=p; } return(s); } O(n)

（5） s2(int n)

x=0; y=0;

for (k=1;k<=n;k++)

x++;

for (i=1;i<=n;i++)

for (j=1;j<=n;j++)

y++; 2

解：O(n)

五． 根据二元组关系，画出对应逻辑图形的草图，指出它们属于何种数据结构。

1． A=（D，R），其中：

D={a，b，c，d，e}， R={ }

解： a b

c d e 属于集合 2． B=（D，R），其中：

D={a，b，c，d，e，f}， R={r}

R={，，，，} （尖括号表示结点之间关系是有向的） 解：

a d

b c e f 属于线性结构。

3．根据二元组关系画出逻辑图形，并指出它们属于何种数据结构。

F=（D，R），其中：

D={50，25，64，57，82，36，75，55}， R={<50,25>,<50,64>,<25,36>,<64,57>, <64,82>,<57,55>,<57,75>}

解：

50 25 64 36 57 82

55 75 属于树结构

4． 根据二元组关系画出逻辑图形，并指出它们属于何种数据结构。

C=（D，R），其中：

D={1，2，3，4，5，6}，

R={（1,2）,（2,3）,（2,4）,（3,4）,（3,5）,（3,6）,（4,5）,（4,6）}

（园括号表示结点之间关系是有向的） 解：

1

2 3 4

5

6 属于图结构

5．根据二元组关系画出逻辑图形，并指出它们属于何种数据结构。

E=（D，R），其中：

D={a，b，c，d，e，f，g，h}，

R={，，，，，，} 解：

d

b g a

c e h

f

属于树结构。

模拟考题

1． 根据二元组关系画出逻辑图形，并指出它们属于何种数据结构。

A=（D，R），其中： D={1，2，3，4，5，6}，

R={（1,2）,（1,6）,（2,3）,（2,4）, （3,4）,（3,5）,（3,6）,（4,5）,（5,6）} 解：

1 2 6 3 4 5 属于图结构

2． 根据二元组关系画出逻辑图形，并指出它们属于何种数据结构。

B=（D，R），其中：

D={40，30，20，60，50，80，70，10}， R={<30,20>,<30,60>,<20,40>,<60,50>, <60,70>,<60,80>,<70,10>}

解：

30 20

60 40 50 70 80

10 属于树结构

3． 根据二元组关系画出逻辑图形，并指出它们属于何种数据结构。

C=（D，R），其中：

D={1，2，3，4，5，6}，

R={（1,2）,（2,3）,（2,4）,（3,4）, （3,5）,（3,6）,（4,5）,（4,6）}

解：

1

2

3 4 5 6

属于图结构

4． 根据二元组关系画出逻辑图形，并指出它们属于何种数据结构。

E=（D，R），其中：

D={a，b，c，d，e，f，g，h}， R={,,,, ,,}

解：

d

b c e g h a f 属于树结构

单元练习2

一．判断题（下列各题，正确的请在前面的括号内打√；错误的打╳ ）

（×）（1）线性表的链式存储结构优于顺序存储。 （×）（2）链表的每个结点都恰好包含一个指针域。

（√）（3）在线性表的链式存储结构中，逻辑上相邻的两个元素在物理位置上并不一定紧邻。 （×）（4）顺序存储方式的优点是存储密度大，插入、删除效率高。

（×）（5）线性链表的删除算法简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。

（×）（6）顺序表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。 （√）（7）线性表链式存储的特点是可以用一组任意的存储单元存储表中的数据元素。 （√）（8）线性表采用顺序存储，必须占用一片连续的存储单元。

（×）（9）顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。

（ㄨ）（10）插入和删除操作是数据结构中最基本的两种操作，所以这两种操作在数组中也经常使用。

二．填空题

（1） 顺序表中逻辑上相邻的元素在物理位置上 必须 相连。 （2） 线性表中结点的集合是有限的，结点间的关系是 一对一 关系。 （3） 顺序表相对于链表的优点是： 节省存储 和随机存取。 （4） 链表相对于顺序表的优点是： 插入、删除 方便。 （5） 采用 顺序 存储结构的线性表叫顺序表。

（6） 顺序表中访问任意一个结点的时间复杂度均为 O(1) 。

（7） 链表相对于顺序表的优点是插入、删除方便；缺点是存储密度 小 。 （8） 在双链表中要删除已知结点*P，其时间复杂度为 O(1) 。

（9） 在单链表中要在已知结点*P之前插入一个新结点，需找到*P的直接前趋结点的地址，其查找的时间复杂度为 O(n) 。

（10） 单链表中需知道 头指针 才能遍历整个链表。

（11） 性表中第一个结点没有直接前趋，称为 开始 结点。

（12） 在一个长度为n的顺序表中删除第i个元素，要移动 n-i 个元素。

（13） 在一个长度为n的顺序表中，如果要在第i个元素前插入一个元素，要后移 n- i +1 个元素。 （14） 在无头结点的单链表中，第一个结点的地址存放在头指针中，而其它结点的存储地址存放在前趋 结

点的指针域中。

（15） 当线性表的元素总数基本稳定，且很少进行插入和删除操作，但要求以最快速度存取线性表中的元素

时，应采用 顺序 存储结构。

（16） 在线性表的链式存储中，元素之间的逻辑关系是通过 指针 决定的。

（17） 在双向链表中，每个结点都有两个指针域，它们一个指向其 前趋 结点，另一个指向其 后继结

点。

（18） 对一个需要经常进行插入和删除操作的线性表，采用 链式 存储结构为宜。

（19） 双链表中，设p是指向其中待删除的结点，则需要执行的操作为： p->prior->next=p->next 。 （20） 在如图所示的链表中，若在指针P所在的结点之后插入数据域值为a和b的两个结点，则可用

下列两个语句： S->next->next=P->next; 和P->next=S;来实现该操作。

P

a S b

Λ

三．选择题

（1）在具有n个结点的单链表中，实现（ A ）的操作，其算法的时间复杂度都是O（n）。

A．遍历链表或求链表的第i个结点 C．删除开始结点

B．在地址为P的结点之后插入一个结点 D．删除地址为P的结点的后继结点

（2）设a、b、c为三个结点，p、10、20分别代表它们的地址，则如下的存储结构称为（ B ）。

P A． 循环链表

a 10 B． 单链表

b 20 c ^ D． 双向链表 D． 不能确定

C．双向循环链表

（3）单链表的存储密度（ C ）。

A． 大于1 B． 等于1 C．小于1 地址为（ A ）。

A． B+(i-1)*m

B．B+i*m C． B-i*m

2

（4）已知一个顺序存储的线性表，设每个结点占m个存储单元，若第一个结点的地址为B，则第i个结点的

D． B+(i+1)*m

（5）在有n个结点的顺序表上做插入、删除结点运算的时间复杂度为（ B ）。

A．O（1） B．O（n） C．O（n） D．O（log2n）

（6）设Llink、Rlink分别为循环双链表结点的左指针和右指针，则指针P所指的元素是双循环链表L的尾元素的条件是（ D ）。

A．P== L

B．P->Llink== L C．P== NULL D．P->Rlink==L

（7） 两个指针P和Q，分别指向单链表的两个元素，P所指元素是Q所指元素前驱的条件是（ B ）。

A．P->next==Q->next B．P->next== Q C．Q->next== P D．P== Q （8）用链表存储的线性表，其优点是（ C ）。

A． 便于随机存取 B． 花费的存储空间比顺序表少 C． 便于插入和删除 D． 数据元素的物理顺序与逻辑顺序相同 （9）在单链表中，增加头结点的目的是（ C ）。

A． 使单链表至少有一个结点 B． 标志表中首结点的位置

C． 方便运算的实现 D． 说明该单链表是线性表的链式存储结构 （10）下面关于线性表的叙述中，错误的是（ D ）关系。

A．顺序表必须占一片地址连续的存储单元 B．顺序表可以随机存取任一元素 C．链表不必占用一片地址连续的存储单元 D．链表可以随机存取任一元素 A．2 L

A B C R D Λ

B．3

C．4 D．5

（11）L是线性表，已知LengthList（L）的值是5，经DelList（L，2）运算后，LengthList（L）的值是（ C ）。 （12）单链表的示意图如下：

Q P 指向链表Q结点的前趋的指针是（ B ）。

A．L

B．P C．Q D．R

（13）设p为指向单循环链表上某结点的指针，则*p的直接前驱（ C ）。

A．找不到

B．查找时间复杂度为O（1）

D．查找结点的次数约为n

C．查找时间复杂度为O（n） A．n

（14）等概率情况下，在有n个结点的顺序表上做插入结点运算，需平均移动结点的数目为（ C ）。

B．(n-1)/2 C． n/2 D．(n+1)/2

（15）在下列链表中不能从当前结点出发访问到其余各结点的是（ C ）。

A．双向链表 B．单循环链表 C．单链表 D．双向循环链表

（16）在顺序表中，只要知道（ D ），就可以求出任一结点的存储地址。

A．基地址 B．结点大小 C． 向量大小 D．基地址和结点大小 （17）在双链表中做插入运算的时间复杂度为（ A ）。

A．O（1） B．O（n） C．O（n） D．O（log2n） （18）链表不具备的特点是（ A ）。

A．随机访问 B．不必事先估计存储空间 C．插入删除时不需移动元素 D．所需空间与线性表成正比 （19）以下关于线性表的论述，不正确的为（ C ）。

A．线性表中的元素可以是数字、字符、记录等不同类型 B．线性顺序表中包含的元素个数不是任意的

C．线性表中的每个结点都有且仅有一个直接前趋和一个直接后继 D．存在这样的线性表，即表中没有任何结点 （20）在（ B ）的运算中，使用顺序表比链表好。

A．插入 B．根据序号查找 C． 删除 D．根据元素查找

2

四．程序填空

1．已知线性表中的元素是无序的，并以带表头结点的单链表作存储。试写一算法，删除表中所有大于min，小于max的元素，试完成下列程序填空。

Void delete (lklist head; datatype min, max) { q=head->next; while (p!=NULL)

{ if ((p->data<=min ) | | ( p->data>=max ) {q=p; p= p->next ; }

else

{ q->next= p->next ;

delete (p) ; p= q->next ; } } }

2． 在带头结点head的单链表的结点a之后插入新元素x，试完成下列程序填空。

struct node { elemtype data; node *next;

};

void lkinsert (node *head, elemtype x) { node *s, *p;

s= new node ; s->data= x ; p=head->next;

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

____p=p->next ; if (p==NULL)

cout<< \不存在结点a! \else {_____s->next=p->next______;

___ p->next=s __________; }

}

模拟考题

1．在顺序存储的线性表第i个位置插入新结点x，试完成下列程序填空。

typedef struct // 将data和last封装在一个结构体 { datatype data[MAXLEN]; // MAXLEN为线性表的最大长度 int last; }SeqList;

int InsList(SeqList *L,int i,datatype x) // 插入结点函数 { int j;

if (L->last= =MAXLEN-1)

{ cout<< \顺序表已满！\

if( i<1 || i>L->last+2 ) // 检查插入位置的正确性 { cout<< \位置出错！\

for (j=L->last; j>=i-1 ; j--) // 结点移动 L->data[j+1]=L->data[j] ;

L->Lata[i-1]= x ; // 新结点插入

L->last ++ ; （或L->last= L->last +1） return(1); }

2．一个带头指针的单链表，写出在值为x的结点之后插入m个结点的算法。 void insertm (lklist head; int m) { p=head->next;

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

{ q=p->next;

for ( i=0; i< m ; i++ ) // 找到x，在其后插入m个结点 { s=new (node);

cin<< a ; // 输入待插入的值 s->data= a ; p->next=s; p=s; }

p->next=q;

} }

3． 有两个循环单链表，头指针分别为head1和head2，下列函数是将链表head1链接到链表head2，链接后的链表仍然是循环链表，试完成下列程序填空。

（提示：先找到两链表的尾指针，再将第一个链表的尾指针与第二个链表的头结点链接起来）

node *link (node *head1, node *head2) { node *p, *q; p=head1;

while (p->next!=head1)

p= p->next ;

q= head2 ;

while (q->next !=head2 )

q=q->next;

p->next= head2 ; q->next= head1 ; return (head1); }

单元练习3

一．判断题（下列各题，正确的请在前面的括号内打√；错误的打╳ ）

（√）（1）栈是运算受限制的线性表。

（√）（2）在栈空的情况下，不能作出栈操作，否则产生下溢出。 （ㄨ）（3）栈一定是顺序存储的线性结构。 （√）（4）栈的特点是“后进先出”。 （ㄨ）（5）空栈就是所有元素都为0的栈。

（ㄨ）（6）在C或C++语言中设顺序栈的长度为MAXLEN，则top=MAXLEN时表示队满。 （√）（7）链栈与顺序栈相比，其特点之一是通常不会出现栈满的情况。 （ㄨ）（8）一个栈的输入序列为：A，B，C，D，可以得到输出序列：C，A，B，D。 （ㄨ）（9）递归定义就是循环定义。

（√）（10）将十进制数转换为二进制数是栈的典型应用之一。

二．填空题

（1）在栈结构中，允许插入、删除的一端称为 栈顶 。 （2）在顺序栈中，当栈顶指针top=-1时，表示 栈空 。 （3）在有n个元素的栈中，进栈操作的时间复杂度为 O（1）。 （4）在栈中，出栈操作的时间复杂度为： O(1) 。 （5）已知表达式，求它的后缀表达式是 栈 的典型应用。 （6）在一个链栈中，若栈顶指针等于NULL，则表示 栈空 。

（7）向一个栈顶指针为top的链栈插入一个新结点*p时，应执行 p->next=top； 和top=p； 操作。

（8）顺序栈S存储在数组 S->data[0..MAXLEN-1]中，进栈操作时要执行的语句有：

S->top ++ 。 （或= S->top+1） （9）链栈LS，指向栈顶元素的指针是 LS->next 。

（10）从一个栈删除元素时，首先取出 栈顶元素 ，然后再移动栈顶指针。 （11）由于链栈的操作只在链表的头部进行，所以没有必要设置 头 结点。 （12）已知顺序栈S，在对S进行进栈操作之前首先要判断 栈是否满 。 （13）已知顺序栈S，在对S进行出栈操作之前首先要判断 栈是否空 。 （14）若内存空间充足， 链 栈可以不定义栈满运算。 （15）链栈LS是空的条件是 LS->next=NULL 。 （16）链栈LS的栈顶元素是链表的 首 元素。 （17）同一栈的各元素的类型 相同 。

（18）若进栈的次序是A、B、C、D、E，执行三次出栈操作以后，栈顶元素为 B 。 （19）A+B/C-D*E的后缀表达式是： ABC/+DE*- 。

（20）四个元素按A、B、C、D顺序进S栈，执行两次Pop（S，x）运算后，x的值是 C 。

三．选择题

（1）插入和删除只能在一端进行的线性表，称为( C )。 A．队列 B．循环队列 C．栈 D．循环栈

（2）设有编号为1，2，3，4的四辆列车，顺序进入一个栈结构的站台，下列不可能的出站顺序为 ( D )

A．1234 B．1243 C．1324 D．1423 （3）如果以链表作为栈的存储结构，则出栈操作时（ B ） A．必须判别栈是否满 B．必须判别栈是否空 C．必须判别栈元素类型 D．队栈可不做任何判别 （4）元素A,B,C,D依次进栈以后，栈顶元素是（ D ） A．A B．B C．C D．D （5）顺序栈存储空间的实现使用（ B ）存储栈元素。 A．链表 B．数组 C．循环链表 D．变量

（6）在C或C++语言中，一个顺序栈一旦被声明，其占用空间的大小（ A ）。 A．已固定 B．不固定 C．可以改变 D．动态变化 （7）带头结点的链栈LS的示意图如下，栈顶元素是（ A ） LS H

A．A B．B C．C D．D （8）链栈与顺序栈相比，有一个比较明显的优点是（ B ）。

A．插入操作更加方便 B．通常不会出现栈满的情况。 C．不会出现栈空的情况 D．删除操作根加方便

（9）从一个栈顶指针为top的链栈中删除一个结点时，用x保存被删除的结点，应执行下列 ( D )命令。

A．x=top;top=top->next; B．top=top->next;x=top->data;

A B C D Λ

C．x=top->data; D．x=top->data;top=top->next;

（10）在一个栈顶指针为HS的链栈中，将一个S指针所指的结点入栈，应执行下列 ( B )命令。 A．HS->next=S; B．S->next=HS->next;HS->next=S; C．S->next=HS->next;HS=S; D．S->next=HS;HS=HS->next;

（11）四个元素按A、B、C、D顺序进S栈，执行两次Pop（S，x）运算后，栈顶元素的值是（ B ）。 A．A B．B C．C D．D （12）元素A,B,C,D依次进栈以后，栈底元素是（ A ）。 A．A B．B C．C D．D （13）经过下列栈的运算后，再执行ReadTop(s)的值是（ A ）。 InitStack(s) （初始化栈）;Push(s,a);Push(s,b); Pop(s)

A．a B．b C．1 D．0 （14）经过下列栈的运算后，x的值是（ B ）。

InitStack(s) （初始化栈）;Push(s,a);Push(s,b); ReadTop(s);Pop(s,x);

A．a B．b C．1 D．0 （15）经过下列栈的运算后，x的值是（ B ）。

InitStack(s) （初始化栈）;Push(s,a);Pop(s,x);Push(s,b);Pop(s,x);

A．a B．b C．1 D．0 （16）经过下列栈的运算后，SEmpty(s)的值是（ C ）。

InitStack(s) （初始化栈）; Push(s,a); Push(s,b);Pop(s,x); Pop(s,x);

A．a B．b C．1 D．0 （17）向顺序栈中压入元素时，（ B ）。

A． 先存入元素，后移动栈顶指针 B．先移动栈顶指针，后存入元素 C．谁先谁后无关紧要 D．同时进行

（18）初始化一个空间大小为5的顺序栈S后，S->top的值是（ B ）。 A．0

B．-1 C．不再改变 D．动态变化

C．DCEAB

D．ABCDE

（19）一个栈的入栈次序ABCDE，则栈的不可能的输出序列是 ( C )。 A．EDCBA B．DECBA

（20）设有一个顺序栈S，元素A,B,C,D,E,F,依次进栈，如果六个元素出栈的顺序是B，D，C，F，E，A，则栈的容量至少应是 ( A )。 A．3 B．4

C．5 D． 6

四．设有一个栈，元素进栈的次序为：A，B，C，D，E，用I表示进栈操作，O表示出栈操作，写出下列出栈的操作序列。

（1）C，B，A，D，E （2）A，C，B，E，D 解：（1）IIIOOOIOIO

（2）IOIIOOIIOO

五．求后缀表达式

（1） A^B^C/D （2） -A+B*C+D/E （3） A*(B+C)*D-E

（4） (A+B)*C-E/(F+G/H)-D （5） 8/(5+2)-6 解:

（1）A B ^ C ^ D /

（2）0 A – B C * + D E / + （3）A B C + * D * E -

（4）A B + C * E F G H / + / - D - （5）8 5 2 + / 6 -

模拟考题

求后缀表达式

1． 求下列表达式：A/B∧C+D*E-A*C 的后缀表达式。 解： A B C ∧ / D E * + A C * -

2． 求下列表达式：A/B-C+D*E-F 的后缀表达式。 解： A B/ C - D E * +F -

写出运行下列程序段的输出结果

void main() { Stack S; char x,y;

InitStack(S); // 初始化栈 x= \c \; y= \k \;

Push(S,x); Push(S, \a \); Push(S,y); Pop(S,x); Push(S, \t \); Push(S,x); Pop(S,x); Push(S, \s \); While (!SEmpty(S))

{ Pop(S,y);cout<

程序填空

1. 下列程序是判别一个算术表达式（存在字符数组a[ ]中）的圆括号配对是否正确？试填空完成下列程序。 int correct(char a[ ]) { stack s ;

InitStack(s); // 初始化栈 for (i=0; i

Push ( s,’(’ ); else if (a[i]= = ’)’ ) {

if SEmpty (s)

return 0; // 若栈为空返回0；否则出栈 else

Pop(s); }

if (SEmpty(s))

cout<< \配对正确！\ // printf (\配对正确！\ else

cout<< \配对错误！\配对错误！\ }

单元测验4

一．判断题（下列各题，正确的请在前面的括号内打√；错误的打╳ ）

（√）（1）队列是限制在两端进行操作的线性表。

（√）（2）判断顺序队列为空的标准是头指针和尾指针都指向同一个结点。 （×）（3）在链队列上做出队操作时，会改变front指针的值。

（√）（4）在循环队列中，若尾指针rear大于头指针front，其元素个数为rear- front。 （×）（5）在单向循环链表中，若头指针为h，那么p所指结点为尾结点的条件是p=h。 （√）（6）链队列在一定范围内不会出现队满的情况。 （×）（7）在循环链队列中无溢出现象。 （×）（8）栈和队列都是顺序存储的线性结构。 （×）（9）在队列中允许删除的一端称为队尾。

（×）（10）顺序队和循环队关于队满和队空的判断条件是一样的。

二．填空题

（1） 在队列中存取数据应遵循的原则是 先进先出 。

（2） 队列 是被限定为只能在表的一端进行插入运算，在表的另一端进行删除运算的线性表。 （3） 在队列中，允许插入的一端称为 队尾 。

（4） 在队列中，允许删除的一端称为 队首（或队头） 。 （5） 队列在进行出队操作时，首先要判断队列是否为 空 。 （6） 顺序队列在进行入队操作时，首先要判断队列是否为 满 。 （7） 顺序队列初始化后，front=rear= -1 。 （8） 解决顺序队列“假溢出”的方法是采用 循环队列 。

（9） 循环队列的队首指针为front，队尾指针为rear，则队空的条件为 front == rear 。 （10） 链队列LQ为空时，LQ->front->next= NULL 。

（11） 设长度为n的链队列用单循环链表表示，若只设头指针，则入队操作的时间复杂度为 O（n）。 （12） 设长度为n的链队列用单循环链表表示，若只设尾指针，则出队操作的时间复杂度为 0（1） 。 （13） 在一个链队列中，若队首指针与队尾指针的值相同，则表示该队列为 空 。

（14） 设循环队列的头指针front指向队首元素，尾指针rear指向队尾元素后的一个空闲元素，队列

的最大空间为MAXLEN，则队满标志为： front==(rear+1)%MAXLEN 。

（15） 在一个链队列中，若队首指针为front，队尾指针为rear，则判断该队列只有一个结点的条件

为： front==rear && front !NULL 。

( 或 front==rear && front <>NULL )

（16） 向一个循环队列中插入元素时，首先要判断 队尾指针 ，然后再向指针所指的位置写入

新的数据。

（17） 读队首元素的操作 不改变（或不影响） 队列元素的个数。

（18） 设循环队列的容量为40（序号从0到39），现经过一系列的入队和出队运算后，有 front=11，rear=19，则循环队列中还有 8 个元素。

（L= (N＋rear－front)% N=（40＋19－11）% 40=8） （19）队列

Q，经过下列运算：InitQueue(Q)(初始化队列);InQueue(Q,a);

InQueue(Q,b);OutQueue(Q,x); ReadFront(Q,x);QEmpty(Q);后的值是 0 。

（20）队列Q经过InitQueue(Q)(初始化队列);InQueue(Q,a);InQueue(Q,b); ReadFront(Q,x)后，x的值是 a 。

三．选择题

（1）队列是限定在（ D ）进行操作的线性表。 A．中间 A．不变的

B．队首 B．可变的

C．队尾 C．任意的

D．端点 D．0 D．不限制 D．非

（2）队列中的元素个数是( B )。 （3）同一队列内各元素的类型( A )。 A．必须一致

B．不能一致 C．可以不一致

（4）队列是一个( C )线性表结构。

A．不加限制的 B．推广了的 C．加了限制的 A．n-2

B．n-1

（5）当利用大小为n的数组顺序存储一个队列时，该队列的最后一个元素的下标为（ B ）。

C．n D．n+1 C．不能固定 D．动态变化

C．不能连续 D．可以不连续

（6）一个循环队列一旦说明，其占用空间的大小（ A ）。 A．已固定 B．可以变动 （7）循环队列占用的空间( A )。 A．必须连续

B．不必连续

（8）存放循环队列元素的数组data有10个元素，则data数组的下标范围是( B )。 A．0..10 B．0..9 A．B，C，D，A C．A，B，C，D A． A C． C A． A

C．1..9 D．1..10 B．A，C，B，D D．C，B，D，A

B． B

D． D

D． D

（9）若进队的序列为：A，B，C，D，则出队的序列是（ C ）。

（10）四个元素按：A，B，C，D顺序连续进队Q，则队尾元素是（ D ）。

（11）四个元素按：A，B，C，D顺序连续进队Q，执行一次OutQueue(Q)操作后，队头元素是（ B ）。

B． B C． C

（12）四个元素按：A，B，C，D顺序连续进队Q，执行四次OutQueue(Q)操作后，再执行QEmpty(Q);后的值是（ B ）。 A． 0

B． 1 C． 2

D． 3

（13）队列Q，经过下列运算后，x 的值是（ B ）。

InitQueue(Q)(初始化队列);InQueue(Q,a); InQueue(Q,b);OutQueue(Q,x); ReadFront (Q,x);

A．a B．b C．0 D．1 （14）循环队列SQ队满的条件是( B )。 A．SQ->rear==SQ->front

B．(SQ->rear+1)% MAXLEN ==SQ->front

D．SQ->front==0

C．SQ->rear==0

（15）设链栈中结点的结构：data为数据域，next为指针域，且top是栈顶指针。若想在链栈的栈顶插入一个由指针s所指的结点，则应执行下列（ A ）操作。 A．s->next=top->next；top->next=s； B．top->next=s； C．s->next=top；top=top->next；

LQ->front H A B C D Λ D．s->next=top；top=s；

（16）带头结点的链队列LQ示意图如下，链队列的队头元素是（ A ）

LQ->rear A．A B．B C．C D．D

（17）带头结点的链队列LQ示意图如下，指向链队列的队头指针是（ C ）

LQ->front H A B C D Λ LQ->rear A．LQ->front B．LQ->rear C．LQ->front->next D．LQ->rear->next

（18）带头结点的链队列LQ示意图如下，在进行进队运算时指针LQ->front（ A ） LQ->front H A B C D Λ LQ->rear A．始终不改变 B．有时改变 C．进队时改变 D．出队时改变 （19）队列Q，经过下列运算后，再执行QEmpty(Q) 的值是（ C ）。

InitQueue(Q) (初始化队列);InQueue(Q,a); InQueue(Q,b);OutQueue(Q,x); ReadQueue(Q,x); A．a

B．b C．0 D．1

（20）若用一个大小为6的数组来实现循环队列，且当前front和rear的值分别为3和0，当从队列中删除一个元素，再加入两个元素后，front和rear的值分别为( c )。 A．5和1

B．4和2

C．2和4 D．1和5

四． 写出程序运行的结果

写出下列程序段的输出结果（队列中的元素类型为char）。 void main( ) {

Queue Q; InitQueue (Q); // 初始化队列 char x=\InQueue (Q, \InQueue (Q, \InQueue (Q, y);

OutQueue (Q,x); InQueue (Q,x); OutQueue (Q,x); InQueue (Q, \while (!QEmpty(Q))

{

OutQueue (Q,y); printf(y); }; printf(x); }

答：输出为“CHAR”。

单元练习5

一．判断题（下列各题，正确的请在前面的括号内打√；错误的打╳ ）

（ㄨ）（1）串是n个字母的有限序列。 （√）（2）串的数据元素是一个字符。 （ㄨ）（3）串的长度是指串中不同字符的个数。

（ㄨ）（4）如果两个串含有相同的字符，则说明它们相等。

（ㄨ）（5）如果一个串中所有的字母均在另一个串中出现，则说明前者是后者的子串。 （√）（6）串的堆分配存储是一种动态存储结构。 （ㄨ）（7）“DT”是“DATA”的子串。

（ㄨ）（8）串中任意个字符组成的子序列称为该串的子串。 （√）（9）子串的定位运算称为模式匹配。

（√）（10）在链串中为了提高存储密度，应该增大结点的大小。

二．填空题

（1） 由零个或多个字符组成的有限序列称为 字符串（或串） 。 （2） 字符串按存储方式可以分为：顺序存储、链接存储和 堆分配存储 。 （3） 串的顺序存储结构简称为 顺序串 。

（4） 串顺序存储非紧凑格式的缺点是： 空间利用率低 。 （5） 串顺序存储紧凑格式的缺点是对串的字符处理 效率低 。 （6） 串链接存储的优点是插入、删除方便，缺点的 空间利用率低 。 （7） 在C或C++语言中，以字符 \\0 表示串值的终结。

（8） 空格串的长度等于 空格的个数 。 （9） 在空串和空格串中，长度不为0的是 空格串 。

（10） 两个串相等是指两个串相长度等，且对应位置的 字符都相同 。 （11） 设S=\，则LenStr(s)= _ 8 。

（12） 两个字符串分别为：S1=\，S2=\的结果

是： Today is 30 July,2005 。

（13） 求子串函数SubStr(\的结果是： July 。 （14） 在串的运算中，EqualStr(aaa,aab)的返回值为 <0 。 （15） 在串的运算中，EqualStr(aaa,aaa)的返回值为 0 。

（16） 在子串的定位运算中，被匹配的主串称为目标串，子串称为 模式 。 （17） 模式匹配成功的起始位置称为： 有效位移 。

（18） 设S=\，T=\， 则第 6 次匹配成功。

（19） 设S=\，T= \，则字符定位的位置为 0 。 （20） 若n为主串长度，m为子串长度，且n>>m，则模式匹配算法最坏情况下的时间复杂度为： (n-m+1)*m 。

三．选择题

（1）串是一种特殊的线性表，其特殊性体现在（ B ）。

A.可以顺序存储 B．数据元素是一个字符 C.可以链接存储 D．数据元素可以是多个字符 （2）某串的长度小于一个常数，则采用（ B ）存储方式最节省空间。 A．链式 B．顺序

C．堆结构

D．无法确定

（3）以下论述正确的是（ C ）。 A．空串与空格串是相同的 C．空串是零个字符的串

B．\是\的子串 D. 空串的长度等于1

B．\是\的子串 D. 空串的长度等于1

B．\是\的子串 D．\ B．模式匹配 D．串比较

C．找某字符在主串中第一次出现的位置

D．找某子串在主串中第一次出现的第一个字符位置

（4）以下论述正确的是（ B ）。 A．空串与空格串是相同的 C．空格串是有空格的串

（5）以下论断正确的是( A )。 A．\是空串，\ \空格串 C．\ A. 串连接

（6）设有两个串S1和S2，则EqualStr(S1,S2)运算称作( D )。 C. 求子串 （7）串的模式匹配是指（ D ）。

A．判断两个串是否相等 B．对两个串比较大小 字符串的存储密度为( D )。 A．20％ B．40％

C．50％ D．33．3％

（9）若字符串\采用链式存储，假设每个指针占用2个字节，若希望存储密度50％，则每

（8）若字符串\采用链式存储，假设每个字符占用1个字节，每个指针占用2个字节。则该

个结点应存储( A )个字符。 A．2 B．3 A．\

C．4

D．5

（10）设串S1=\，S2=\则ConcatStr(S1,S2)=( B )。

B．\

D. \ C．2 D．3 C．2 D．3

C．\

A．0 A．0

（11）设S=\，则LenStr（S）=（ A ）。

B．1 B．1

（12）设目标串T=\，模式P=\，则该模式匹配的有效位移为 ( A )。 （13）设目标串T=\，模式P=\，则该模式匹配的有效位移为 ( D )。

A．2

B．3 C．4 D. 5

C．4 D．5 C．0（m+n）

D．0（m*n）

（14）设目标串T=\，模式P=\朴素匹配算法的外层循环进行了( D )次。 A．1 B．9

（15）朴素模式匹配算法在最坏情况下的时间复杂度是( D )。 A．O（m） B．O（n）

A．\

（16）S=\，执行求子串函数SubStr(S,2,2)后的结果为( B )。

B．\

C．\ D．\

（17）S1=\，S2=\，执行串连接函数ConcatStr(S1,S2)后的结果为( A )。 A．\

B．\

C．\ D．\

（18）S1=\，S2=\，执行函数SubStr(S2,4,LenStr(S1))后的结果为( B )。 A．\

B．\

C．\ D．\（19）设串S1=\，S2=\

则ConcatStr(SubStr(S1,2,LenStr(S2)),SubStr(S1,LenStr(S2),2))的结果串为( D )。 A．BCDEF B．BCDEFG C．BCPQRST D. BCDEFEF

（20）若串S=\，其子串的数目最多是：（ C ） 。 A．35 B．36 C．37 D．38

（8+7+6+5+4+3+2+1+1=37）

其他

⑴ 假设在树中， 结点x是结点y的双亲时，用(x,y)来表示树边。已知一棵树的树边集合为 { (e,i), (b,e), (b,d), (a,b), (g,j), (c,g), (c,f), (h,l), (c,h), (a,c) } ，用树型表示法表示该树，并回答下列问题：

① 哪个是根结点? 哪些是叶子结点? 哪个是g的双亲? 哪些是g的祖先? 哪些是g的孩子? 那些是e的子孙? 哪些是e的兄弟? 哪些是f的兄弟?

② b和n的层次各是多少? 树的深度是多少? 以结点c为根的子树的深度是多少?

⑵ 一棵深度为h的满k叉树有如下性质： 第h层上的结点都是叶子结点，其余各层上每个结点都有k棵非空子树。 如果按层次顺序(同层自左至右)从1开始对全部结点编号，问：

① 各层的结点数是多少?

② 编号为i的结点的双亲结点(若存在)的编号是多少?

③ 编号为i的结点的第j个孩子结点(若存在)的编号是多少?

④ 编号为i的结点的有右兄弟的条件是什么? 其右兄弟的编号是多少? ⑶ 设有如图6-27所示的二叉树。

① 分别用顺序存储方法和链接存储方法画出该二叉树的存储结构。 ② 写出该二叉树的先序、中序、后序遍历序列。

⑷ 已知一棵二叉树的先序遍历序列和中序遍历序列分别为ABDGHCEFI和GDHBAECIF，请画出这棵二叉树，然后给出该树的后序遍历序列。

⑻ 设图6-27所示的二叉树是森林F所对应的二叉树，请画出森林F。 ⑼ 设有一棵树，如图6-28所示。

① 请分别用双亲表示法、孩子表示法、孩子兄弟表示法给出该树的存储结构。 ② 请给出该树的先序遍历序列和后序遍历序列。 ③ 请将这棵树转换成二叉树。

⑽ 设给定权值集合w={3,5,7,8,11,12} ，请构造关于w的一棵huffman树，并求其加权路径长度WPL 。

⑾ 假设用于通信的电文是由字符集{a, b, c, d, e, f, g, h}中的字符构成， 这8个字符在电文中出现的概率分别为{0.07, 0.19, 0.02, 0.06, 0.32, 0.03, 0.21, 0.10} 。

① 请画出对应的huffman树(按左子树根结点的权小于等于右子树根结点的权的次序构造)。 ② 求出每个字符的huffman编码。

⑴ 分析并回答下列问题：

① 图中顶点的度之和与边数之和的关系?

② 有向图中顶点的入度之和与出度之和的关系?

③ 具有n个顶点的无向图，至少应有多少条边才能确保是一个连通图? 若采用邻接矩阵表示，则该矩阵的大小是多少?

④ 具有n个顶点的有向图，至少应有多少条弧才能确保是强连通图的? 为什么?

⑵ 设一有向图G=(V,E)，其中V={a,b,c,d,e} ， E={, , , , , ,, , }

① 请画出该有向图，并求各顶点的入度和出度。 ② 分别画出有向图的正邻接链表和逆邻接链表。 ⑶ 对图7-27所示的带权无向图。

① 写出相应的邻接矩阵表示。 ② 写出相应的边表表示。 ③ 求出各顶点的度。

⑷ 已知有向图的逆邻接链表如图7-28所示。

① 画出该有向图。

② 写出相应的邻接矩阵表示。

③ 写出从顶点a开始的深度优先和广度优先遍历序列。 ④ 画出从顶点a开始的深度优先和广度优先生成树。

期末考试题型

一判断题，10题，每题1分，共10分。 二选择题，20题，每题2分，共40分。 三填空题，20题，每题1分，共20分。 四分析题，4题，每题2分，共8分。 五画图题，4题，每题3分，共12分。 六程序填空题，2题，每题5分，共10分。

本文来源：https://www.bwwdw.com/article/csmv.html