实用数据结构基础参考答案.doc

单元练习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<n;i++)
for (j=0;i<n;j++)
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<n;i++)
for (j=0;j<m;j++)
A[i][j]
解： O(n*m)
（2） s=0;
for (i=0;i<n;i++)
for (j=0;j<n;j++)
s+=B[i][j];
sum=s;
解： O(n2)
（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++;
解：O(n2)

五． 根据二元组关系，画出对应逻辑图形的草图，指出它们属于何种数据结构。
（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,b>,<b,c>,<c,d>,<d,e>,<e,f>} （尖括号表示结点之间关系是有向的）
解：
b
a
e
d
f
c

属于线性结构。

（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>}
25
50
75
57
36
82
64
55
解：

属于树结构

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

属于图结构

（5）E=（D,R），其中：
D={a,b,c,d,e,f,g,h}，R={r}
R={<d,b>,<d,g>,<d,a>,<b,c>,<g,e>,<g,h>,<e,f>}
解：
b
d
f
e
a
h
g

c

属于树结构。单元练习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

b

S

三．选择题
（1）在具有n个结点的单链表中，实现（ A ）的操作，其算法的时间复杂度都是O（n）。
A．遍历链表或求链表的第i个结点 B．在地址为P的结点之后插入一个结点
C．删除开始结点 D．删除地址为P的结点的后继结点
（2）设a、b、c为三个结点，p、10、20分别代表它们的地址，则如下的存储结构称为（ B ）。
a 10
c ^
b 20
P

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（n2） 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．链表可以随机存取任一元素
（11）L是线性表，已知LengthList（L）的值是5，经DelList（L，2）运算后，LengthList（L）的值是（ C ）。
A．2 B．3 C．4 D．5
（12）单链表的示意图如下：
L

A

B

C

D
Λ
Q
R
P

指向链表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（log2n）
（18）链表不具备的特点是（ A ）。
A．随机访问 B．不必事先估计存储空间
C．插入删除时不需移动元素 D．所需空间与线性表成正比
（19）以下关于线性表的论述，不正确的为（ C ）。
A．线性表中的元素可以是数字、字符、记录等不同类型
B．线性顺序表中包含的元素个数不是任意的
C．线性表中的每个结点都有且仅有一个直接前趋和一个直接后继
D．存在这样的线性表，即表中没有任何结点
（20）在（ B ）的运算中，使用顺序表比链表好。
A．插入 B．根据序号查找 C． 删除 D．根据元素查找

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”);
}
四．分析下述算法的功能
（1）

void Demo2(ListNode *p,ListNode *q)
{ // p,*q是链表中的两个结点
DataType temp;
temp=p->data;
p->data=q->data;
q->data=temp;
}

（2）

解：
（1）返回结点*p的直接前趋结点地址。
（2）交换结点*p和结点*q（p和q的值不变）。

五． 程序填空
（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）写一个对单循环链表进行遍历（打印每个结点的值）的算法，已知链表中任意结点的地址为P 。
解：
void Show(ListNode *P)
{ ListNode *t=P;
do
{ 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 ）
LS

H

A

B

C

D
Λ

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
解：8 5 2 + / 6 -

六．算法设计题
（1）设用一维数组stack[n]表示一个堆栈，若堆栈中每个元素需占用M个数组单元（M>1）。
①试写出其入栈操作的算法。
②试写出其出栈操作的算法。
解：//用一整型变量top表示栈顶指针，top为0时表示栈为空。栈中元素从S [1]开始存放元素。
//①入栈算