当前位置：文档库 › 实用数据结构基础(第三版)参考答案

实用数据结构基础(第三版)参考答案

单元练习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+3nlog

n，则算法的时间复杂

n）。

度为 O（nlog

（19）若一个算法中的语句频度之和为T（n）=3n+nlog

n+n2，则算法的时间复

杂度为 O（n2）。

（20）数据结构是一门研究非数值计算的程序设计问题中计算机的操作对象，以及它们之间的关系和运算的学科。

三．选择题

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

A. 存储结构和逻辑结构

B. 存储和抽象

C. 联系和抽象

联系与逻辑

（2）在逻辑上可以把数据结构分成：（ C ）。

A. 动态结构和静态结构

B. 紧凑结构和非紧凑结构

C. 线性结构和非线性结构

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

A. 存储结构

B. 逻辑结构

C. 顺序存储结构

链式存储结构

（4）非线性结构中的每个结点（ D ）。

A.无直接前趋结点

B.无直接后继结点

C.只有一个直接前趋结点和一个直接后继结点

D.可能有多个直接前趋结点和多个直接后继结点

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

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

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

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

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

A. 现实性

B. 难度

C. 时间复杂性

效率

（7）数据的基本单位是（ B ）。

A. 数据结构

B. 数据元素

C. 数据项

文件

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

A. 顺序存储

B. 链式存储

C. 索引存储

散列存储

（9）每一个存储结点不仅含有一个数据元素，还包含一组指针，该存储方式是（ B ）存储方式。

A. 顺序

B. 链式

C. 索引

D. 散列（10）以下任何两个结点之间都没有逻辑关系的是（ D ）。

A. 图形结构

B. 线性结构

C. 树形结构

集合

（11）在数据结构中，与所使用的计算机无关的是（ C ）。

A. 物理结构

B. 存储结构

C. 逻辑结构

D. 逻辑和存储结构

（12）下列四种基本逻辑结构中，数据元素之间关系最弱的是（ A ）。

A. 集合

B. 线性结构

C. 树形结构

图形结构

（13）与数据元素本身的形式、内容、相对位置、个数无关的是数据的（ A ）。

A. 逻辑结构

B. 存储结构

C. 逻辑实现

存储实现

（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

for (j=0;i

c[i][j]=i+j;

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 (j=0;j

A[i][j]

解： O(n*m)

（2） s=0;

for (i=0;i

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++; 解：O(n 2

)

五．根据二元组关系，画出对应逻辑图形的草图，指出它们属于何种数据结构。（1）A=（D ，R ），其中：

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

解：

d e

属于集合

（2）B=（D,R ），其中：

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

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

属于线性结构。

（3）F=（D,R ），其中：

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

R={<50,25>,<50,64>,<25,36>,<64,57>,<64,82>,<57,55>,<57,75>} 解：

（4）C=（R={(1,2),(2,3),(2,4),(3,4),(3,5),(3,6),(4,5),(4,6)}（园括号表示结点之间关系是有向的）解：

属于图结构

（5）E=（D,R ），其中：

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

R={,,,,,,} 解：

属于树结构。

单元练习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;来实现该操作。

三．选择题

（1）在具有n 个结点的单链表中，实现（ A ）的操作，其算法的时间复杂度都是O （n ）。 A ．遍历链表或求链表的第i 个结点 B ．在地址为P 的结点之后插入一个结点

C ．删除开始结点

D ．删除地址为P 的结点的后继结点

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

A ．循环链表

B ．单链表

C ．双向循环链表

D ．双向链表（3）单链表的存储密度（ C ）。 A ．大于1 B ．等于1 C ．小于1 D ．不能确定（4）已知一个顺序存储的线性表，设每个结点占m 个存储单元，若第一个结点的地址为B ，则第i 个结点的地址为（ A ）。

A ． B+(i-1)*m

B ．B+i*m

C ． B-i*m

D ． B+(i+1)*m （5）在有n 个结点的顺序表上做插入、删除结点运算的时间复杂度为（ B ）。 A ．O （1） B ．O （n ） C ．O （n 2

） D ．O

（log 2n ）

（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==

（8）用链表存储的线性表，其优点是（ C ）。

A．便于随机存取B．花费的存储空间比顺序表少

C．便于插入和删除D．数据元素的物理顺序与逻

辑顺序相同

（9）在单链表中，增加头结点的目的是（ C ）。

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

C．方便运算的实现D．说明该单链表是线性表的

链式存储结构

（10）下面关于线性表的叙述中，错误的是（ D ）关系。

A．顺序表必须占一片地址连续的存储单元B．顺序表可以随机存取任

一元素

C．链表不必占用一片地址连续的存储单元D．链表可以随机存取任一

元素

（11）L是线性表，已知LengthList（L）的值是5，经DelList（L，2）运算后，LengthList（L）的值是（ C ）。

A．2 B．3 C．4 D．5

（12）单链表的示意图如下：

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

A．L B．P C．Q D．R

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

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

C．查找时间复杂度为O（n） D．查找结点的次数约为n

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

点的数目为（ C ）。

A．n 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（n2） D．O（log

n）（18）链表不具备的特点是（ A ）。

A．随机访问B．不必事先估计存储空间

C．插入删除时不需移动元素D．所需空间与线性表成正比（19）以下关于线性表的论述，不正确的为（ C ）。

A．线性表中的元素可以是数字、字符、记录等不同类型

B．线性顺序表中包含的元素个数不是任意的

C．线性表中的每个结点都有且仅有一个直接前趋和一个直接后继

D．存在这样的线性表，即表中没有任何结点

（20）在（ B ）的运算中，使用顺序表比链表好。

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

四．分析下述算法的功能

（1）（2）ListNode *Demo1(LinkList L,ListNode *p) { // L是有头结点的单链表

ListNode *q=L->next;

While (q && q->next!=p)

q=q->next;

if (q)

return q;

else

Error(“*p not in L”);

}

void Demo2(ListNode *p,ListNode *q) { // p,*q是链表中的两个结点

DataType temp;

temp=p->data;

p->data=q->data;

q->data=temp;

}

解：

（1）返回结点*p的直接前趋结点地址。

（2）交换结点*p和结点*q（p和q的值不变）。

五．程序填空

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

V oid 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）写一个对单循环链表进行遍历（打印每个结点的值）的算法，已知链表中任意结点的地址为P 。

解：

void Show(ListNode *P)

{ ListNode *t=P;

{ printf("%c",t->data);

t=t->rear;

}

while (t!=P);

}

（2）对给定的带头结点的单链表L，编写一个删除L中值为x的结点的直接前趋结点的算法。

解：

void delete(ListNode *L)

{ ListNode *p=L,*q;

if(L->next->data==X)

{

printf(“值为x的结点是第一个结点，没有直接前趋结点可以删除”);

return;

}

For(p->next->data!=X;q=p;p=p->next);// 删除指针p所指向的结点

q->next=p->next;

delete p;

}

（3）已知一个单向链表，编写一个函数从单链表中删除自第i个结点起的k个结点。

解：

void Del(node *head,int i,int k)

{

node *p,*q;

int j;

if(i==1)

for(j=1;j<=k;j++) // 删除前k个元素

{

p=head; // p指向要删除的结点

head=head->next;

delete p;

}

else

{

p=head;

for(j=1;j<=i-2;j++)

p=p->next; // p指向要删除的结点的前一个结点for(j=1;j<=k;j++)

{

q=p->next; // q 指向要删除的结点

p->next=q->next;

delete q;

}

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

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

int counter(head)

node *head；

{ node *p;

int n=0;

p=head；

while(p!=NULL)

{ if(p->data==x)

n++；

p=p->next;

}

return(n);

}

（5）有两个循环单向链表，链头指针分别为head1和head2，编写一个函数将链表head1链接到链表head2，链接后的链表仍是循环链表。

解：//本题的算法思想是：先找到两链表的尾指针，将第一个链表的尾指针与第二个链表的头结点链接起来，使之成为循环的。函数如下：

node *link (node *head1, *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 ）

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; 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．动态变化（19）一个栈的入栈次序ABCDE，则栈的不可能的输出序列是 ( C )。 A．EDCBA B．DECBA C．DCEAB D．ABCDE （20）设有一个顺序栈S，元素A,B,C,D,E,F,依次进栈，如果六个元素出栈的顺序是B，D，C，F，E，A，则栈的容量至少应是 ( A )。

A．3 B．4 C．5 D． 6

四．应用题

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

①C，B，A，D，E ②A，C，B，E，D

解：①IIIOOOIOIO

②IOIIOOIIOO

（2）求后缀表达式

①A^B^C/D

解：A B ^ C ^ D /

②-A+B*C+D/E

解：0 A – B C * + D E / +

③A*(B+C)*D-E

解：A B C + * D * E -

④(A+B)*C-E/(F+G/H)-D

解：A B + C * E F G H / + / - D -

⑤8/(5+2)-6

解：852+/6-

六．算法设计题

（1）设用一维数组stack[n]表示一个堆栈，若堆栈中每个元素需占用M个数组单元（M>1）。

①试写出其入栈操作的算法。

②试写出其出栈操作的算法。

解：//用一整型变量top表示栈顶指针，top为0时表示栈为空。栈中元素从S [1]开始存放元素。

//①入栈算法：

void push (char x)

{

if ((top+M)>MAXLEN-1)

printf (“堆栈溢出！”);

else

{

if (top= =0)

{

top++;

S [top]=x;

}

else

{

top=top+M;

S [top]=x;

}

//②出栈算法：

void pop (char x)

{

if (top= =0)

pri ntf (“堆栈为空栈！”);

else

{

if (top= =1)

{

x= S [top];

top––;

}

else

{

x= S [top];

top=top–M;

}

（2）设计一个算法，要求判别一个算术表达式中的圆括号配对是否正确。解：//设表达式在字符数组a[ ]中，使用一堆栈S来帮助判断。

int correct (char a[ ])

{

stack s ;

InitStack (s); //调用初始化栈函数

for (i=0; i

if (a[i]= =’(’)

Push (s,’(’);

else

if (a[i]= =’)’)

{

if StackEmpty (s) //调用判栈空函数return 0; //若栈为空返回0；否则出栈

else

Pop(s);

}

if (StackEmpty (s) ) //调用判栈空函数

printf (“配对正确！”); //若栈空，说明配对正确，并返回1 else

printf (“配对错误！”); //配对错误返回0

}

（3）设计一个将十进正整数转换为十进制数的算法，并要求上机调试通过。解：#include

#include

typedef struct stacknode //定义栈的存储结构

{

int data;

struct stacknode*next;

}stacknode;

typedef struct

{

stacknode *top; //定义栈顶的指针

}linkstack;

void Conversion(int n) //栈的应用：十——十六进制转换

{ l inkstack s;

int x;

s.top=NULL; //置栈空

{ x=n%16; //取余数

n= n/16; //取新的商

stacknode *p=new stacknode; //申请新结点

p->next=s.top ; //修改栈顶指针

s.top=p;

s.top->data=x; //余数入栈

}

while(n);

printf("\n\t\t转换后的十六进制数值为：";

while (s.top) //出栈处理

{ if(s.top->data<10);

printf("%d",s.top->data);

else

switch(s.top->data)

{

case 10:printf("%c",'A');break;

case 11:printf("%c",'B');break;

case 12:printf("%c",'C');break;

case 13:printf("%c",'D');break;

case 14:printf("%c",'E');break;

case 15:printf("%c",'F');break;

}

stacknode *p=s.top;

s.top=s.top->next;

free(p); //出栈一个余数，收回一个结}

printf("\n\n");

}

void main()

{

int n;

printf("\n\t\t请输入一个十进制正整数："); scanf("%d",&n);

Conversion(n);

}

单元练习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 。