数据结构C++模拟卷子2.docx
《数据结构C++模拟卷子2.docx》由会员分享，可在线阅读，更多相关《数据结构C++模拟卷子2.docx（17页珍藏版）》请在冰点文库上搜索。
数据结构C++模拟卷子2
第1题.（复合题共计20分）简答题
第1.1题.（主观题5分）已知用二元组表示的数据结构如下，请画图表示其数据关系，并说明该数据结构属于哪种逻辑结构？
（本小题4分）
B=（K,R）;
K={A,B,C,D,E};
R={,,,,,,};
参考答案
逻辑结构：
图
图示结构：
略（课本p158图5.2a）
第1.2题.（主观题5分）
设一个有序顺序表中存放以下整数：
16，87，154，170，275，426，503，509，512，612，653，677，703，765，897，908。
运用二分（折半）法检索元素，请问：
（1）检索612，需要经过多少次比较？
每次比较的元素是什么？
（2）检索900，需要经过多少次比较才能确定其不存在？
每次比较的元素是什么？
参考答案
检索元素612
第一次：
m=（0+16）/2=8，与512比较；
第二次：
m=（9+16）/2=12，与703比较；
第三次：
m=（9+12）/2=10，与653比较；
第四次：
m=（9+10）/2=9，与612比较；检索成功。
检索元素900
第一次：
m=（0+16）/2=8，与512比较；
第二次：
m=（9+16）/2=12，与703比较；
第三次：
m=（13+16）/2=14，与897比较；
第四次：
m=（15+16）/2=15，与908比较；
此时，low=15，high=15，因为900<908，high=mid-1为14，使得low>high，检索停止，900不存在。
第1.3题.（主观题5分）设有编号为1，2，3，4的4辆列车，依次顺序开进一个栈式结构的站台，问是否有3，2，4，1和4，1，3，2两种开出车站的可能？
如有，该如何操作？
参考答案
顺序3，2，4，1是可能的，操作方法：
1、2、3号车依次开进车站，3、2号车依次出站，4号车进站然后出站，最后1号车出站。
顺序4，1，3，2是不可能的。
第1.4题.（主观题5分）
假设一棵二叉树的中序遍历为DCBGEAHFIJK，后序遍历为DCEGBFHKJIA，请问：
（1）该二叉树每层各有多少个结点？
（2）该二叉树的形态是怎样的？
请画图表示。
参考答案
（1）每一层：
1个结点；第二层：
2个结点；第三层：
4个结点；第四层：
4个结点。
二叉树：
图略（课本P155习题）
第2题.（复合题共计25分）算法分析题
第2.1题.（主观题5分）
顺序表定义如课本。
顺序表初始设置的参数size为10，存储的数据为｛12，3，8，41，63，25，16，36，23｝。
第1次调用下列函数的实参是（100，1），第2次调用的实参是（10，11）。
请问：
（1）第1次调用后，存储的数据是什么？
参数size是多少？
（2）第2次调用后，存储的数据是什么？
参数size是多少？
template
boolSqList:
:
Insert（constElemType&e,inti）
{
if（i<1||i>len+1）
returnfalse;
if（len>=size）{
ElemType*newbase;
newbase=newElemType[size+10];
if（!
newbase）
returnfalse;
for（intj=0;jnewbase[j]=elem[j];
delete[]elem;
elem=newbase;
size+=10;
}
ElemType*p,*q;
q=&elem[i-1];
for（p=&elem[len-1];p>=q;--p）
*（p+1）=*p;
*q=e;
++len;
returntrue;
}
参考答案
（1）｛100，12，3，8，41，63，25，16，36，23｝。
size是10。
（2）｛100，12，3，8，41，63，25，16，36，23，10｝。
size是20。
第2.2题.（主观题5分）
带头结点的单链表定义如课本。
下列算法对序列｛12，6，1，25，41，36，21，15，19，7｝连续进行操作，请问：
（1）第1次调用时实参表是（e，4），则操作完成后的序列是什么？
变量e存储的值是什么？
（2）第2次调用时实参表是（e，9），则操作完成后的序列是什么？
变量e存储的值是什么？
template
boolLinkList:
:
Delete（ElemType&e,inti）
{
if（i<1||i>len）
returnfalse;
LinkNode*p,*q;
intk=1;
p=head;
while（kp=p->next;
k++;
}
q=p->next;
p->next=q->next;
if（q==tail）
tail=p;
e=q->data;
deleteq;
--len;
returntrue;
}
参考答案
（1）｛12，6，1，41，36，21，15，19，7｝。
25
（2）｛12，6，1，41，36，21，15，19｝。
7
第2.3题.（主观题5分）
阅读下列程序，请问：
（1）以下程序执行后，输出是什么？
（2）外循环执行了多少次？
（3）在程序运行中，发生了数据交换，那些数据之间发生了交换？
这些交换的数据都有什么特点？
#include
template
voidpartition（Tv[],intlow,inthigh）{
Ttemp;
while（low<=high）
{
while（v[low]<=0&&lowlow++;
while（v[high]>0&&lowhigh--;
if（low{
temp=v[low];
v[low]=v[high];
v[high]=temp;
low++;high--;
}
}
}
voidmain（）
{
inta[10]={12,-3,26,12,-4,0,-6,11,24};
inti;
partition（a,0,8）;
for（i=0;i<9;i++）
cout<cout<}
参考答案
（1）-6-30-41226121124
（2）3次
（3）12与-6，26与0，12与-4。
一个小于等于0的数据与一个大于0的数据交换。
第2.4题.（主观题5分）
对于序列{15，88，36，9，2，95，5}，请问：
（1）在执行下列算法的过程中，外循环每次完成后的数据序列是怎样的？
请完整写出来。
（2）这是什么算法？
请写出名称，并写出其时间复杂度。
（3）该算法的外循环执行了多少次？
template
voidprocess（ElemTypedata[],intn）
{
intlastSwapIndex=n-1;
inti,j;
for（i=lastSwapIndex;i>0;i=lastSwapIndex）{
lastSwapIndex=0;
for（j=0;jif（data[j]>data[j+1]）{
Swap（data[j],data[j+1]）;
lastSwapIndex=j;
}
}
}
参考答案
（1）
{15，36，9，2，88，5，95}
{15，9，2，36，5，88，95}
{9，2，15，5，36，88，95}
{2，9，5，15，36，88，95}
{2，5，9，15，36，88，95}
{2，5，9，15，36，88，95}
（2）冒泡排序算法，O（n2）
（3）6次
第2.5题.（主观题5分）
下列程序中要运用队列进行数据处理，链式队列的定义如课本。
参数v中存储整数：
1，2，3，4，5，6，7，8，9，10。
请问处理结果的数据序列是怎样的？
template
voidfunc（Tv[],intn）
{
LinkQueuequ;
qu.Clear（）;
for（inti=0;iqu.Append（v[i]）;
for（i=0;!
qu.Empty（）;i++）{
v[i]=qu.GetHead（）;
qu.Remove（）;
v[n-i-1]=qu.GetHead（）;
qu.Remove（）;
}
}
参考答案
把数据送进队列，然后按先两侧后中间的次序放回数组中，结果是：
13579108642
第3题.（复合题共计30分）算法填空题
第3.1题.（主观题5分）
下列算法对两组顺序表的数据进行处理，顺序表的定义如课本。
请问：
（1）La存储的数据是｛2，5，12，24｝，Lb存储的数据是｛1，3，6，7，8，9，11｝，处理结束时，Lc存储的数据是什么？
（2）程序中有三个循环，分别用“语句1”。
。
。
表示。
对于
（1）给出的数据，执行的循环语句有哪些？
循环开始时的变量i,j分别是多少？
template
voidmergelist（SqList1&La,SqList1&Lb,SqList1&Lc）
{
intk,i,j,La_len,Lb_len;
Tai,bj;
k=1;i=j=1;
La_len=La.Length（）;
Lb_len=Lb.Length（）;
while（i<=La_len&&j<=Lb_len）//语句1
{
La.GetElem（ai,i）;Lb.GetElem（bj,j）;
if（ai{Lc.Insert（ai,k）;i++;}
else
{Lc.Insert（bj,k）;j++;}
k++;
}
while（i<=La_len）//语句2
{La.GetElem（ai,i）;Lc.Insert（ai,k）;
k++;i++;}
while（j<=Lb_len）//语句3
{Lb.GetElem（bj,j）;Lc.Insert（bj,k）;
k++;j++;}
}
参考答案
（1）Lc存储的数据是｛1，2，3，5，6，7，8，9，11，12，24｝
（2）执行了循环语句1和语句2。
执行语句1时i是0，j是0；执行语句2时，i是3，j是8
第3.2题.（主观题5分）
二叉树的表定义如课本。
下列算法是运用栈对二叉树进行中序遍历的算法。
请把算法补充完整。
如果用a1表示结点a入栈操作，a0表示出栈操作，n1表示空结点指针进栈，n0表示出栈。
对于课本P114图4.9的二叉树，写出结点入栈出栈的过程。
//中序遍历二叉树的非递归算法（利用栈）
template
voidBinaryTree:
:
InorderTraverseNonRecursive（void（*visit）（constElemType&e））
{
stack*>S;
S.push（
（1））;
while（!
S.empty（））{
BTNode*p;
p=S.top（）;
while（p）{
（2）;
（3）;
}
S.pop（）;
if（（4））{
p=S.top（）;
S.pop（）;
visit（p->data）;
（5）;
}
}
}
参考答案
补充完整算法：
（1）m_root
（2）p=p->lchild
（3）S.push（p）
（4）!
S.empty（）
（5）S.push（p->rchild）
结点进出栈过程：
按照0的次序取字母，得到中序序列dbgheafc
a1b1d1n1n0d0n1n0b0e1g1n1n0g0h1n1n0h0n1n0e0n1n0a0c1f1n1n0f0n1n0c0n1n0
第3.3题.（主观题5分）
二叉树定义如课本。
（1）请说明下列算法的功能；
（2）说明该处理结果可以得到的信息有哪些？
template
BTNode*BinaryTree:
:
Process（BTNode*bt,constElemType&e）
{
if（!
bt||bt->data==e）
returnbt;
BTNode*q;
q=_Locate（bt->lchild,e）;
if（q）
returnq;
q=_Locate（bt->rchild,e）;
returnq;
}
参考答案
（1）该算法能够在二叉树中查找结点值为e的结点指针；
（2）算法处理结果得到的信息有两个可能，一是没有找到值为e的结点，返回值为NULL（空指针）；二是查到该结点，则返回指向该结点的指针。
第3.4题.（主观题5分）
以下是二分法检索算法，请补充完整算法，并说明，该算法处理结束时能够返回什么信息？
//折半查找
template
intBinarySearch（StaticTable&R,constKeyTypekey）
{
//low表示所查区间的下界，high表示所查区间的上界
intlow=0,high=R.m_size-1;
while（low<=high）{
intmid=
（1）;
if（
（2））
returnmid;
elseif（R.m_datas[mid]>key）
（3）;
else
（4）;
}
（5）-1;
}
参考答案
补充完整算法：
（1）（low+high）/2
（2）R.m_datas[mid]==key
（3）high=mid-1
（4）low=mid+1
（5）return
该算法结束时，返回的信息有两种可能：
一是查找成功，返回关键码所在位置，二是查找失败，返回-1。
第3.5题.（主观题5分）
二叉树定义如课本，下列算法实现二叉树非递归前序遍历。
用a1表示结点a进栈，a0表示出栈。
对于课本P110图4.7，写出结点进出栈的过程。
template
voidBinaryTree:
:
PreorderTraverseNonRecursive（void（*visit）（constElemType&e））
{
stack*>S;
BTNode*p;
S.push（m_root）;
while（!
S.empty（））{
p=S.top（）;S.pop（）;visit（p->data）;
if（p->rchild）
S.push（p->rchild）;
if（p->lchild）
S.push（p->lchild）;
}
}
参考答案
a1a0c1b1b0e1d1d0e0f1f0c0
第3.6题.（主观题5分）
二叉排序树的定义如课本，下列算法在二叉排序树查找结点，如果查找成功，则获得该结点的指针p和父结点的指针f，并返回true，否则返回false。
请把算法补充完整。
template
boolBST:
:
_Search（KeyTypekey,BSTNode*&f,BSTNode*&p）const
{
f=NULL;
p=
（1）;
while（p&&p->data!
=key）{
f=p;
if（keydata）
（2）;
else
（3）;
}
return（4）;
}
参考答案
（1）m_root
（2）p=p->lchild
（3）p=p->rchild
（4）p!
=NULL
第4题.（复合题共计15分）算法设计题
第4.1题.（主观题5分）
在二叉排序树中查找给定关键字结点的算法如下，请对下列算法稍作修改，在查找结点的同时，确定其所在层次，若查找成功，返回该结点所在层数，否则，返回－１。
template
boolBST:
:
_Search（KeyTypekey,BSTNode*&f,BSTNode*&p）const
{
f=NULL;
p=m_root;
while（p&&p->data!
=key）{
f=p;
if（keydata）
p=p->lchild;
else
p=p->rchild;
}
returnp!
=NULL;
}
参考答案
template
intBST:
:
_Search（KeyTypekey,BSTNode*&f,BSTNode*&p）const
{
f=NULL;
p=m_root;
inti=1;
while（p&&p->data!
=key）{
f=p;i++;
if（keydata）
p=p->lchild;
else
p=p->rchild;
}
if（p!
=NULL）
returni;
else
return-1;
}
第4.2题.（主观题5分）
顺序队列的定义如下，使用循环数组，并保证留一个空的单元以区分队列满的状态。
请完成队列成员函数Clear,Empty,GetHead,Append,Remove的实现。
template//声明一个类模板
classSqQueue
{
public:
SqQueue（intm=100）;//构造函数
~SqQueue（）;//析构函数
voidClear（）;//清空队列
boolEmpty（）const;//判队列空
intLength（）const;//求长度
ElemType&GetHead（）const;//取队头元素值
ElemType&GetLast（）const;//取队尾元素值
voidAppend（constElemType&e）;//入队
voidRemove（）;//出队
private:
ElemType*m_base;//基地址指针
intm_front;//队头指针
intm_rear;//队尾指针
intm_size;//向量空间大小
};
参考答案
//清空队列
template
voidSqQueue:
:
Clear（）
{
m_front=m_rear=0;
}
//判队列是否为空，若为空，则返回true，否则返回false
template
boolSqQueue:
:
Empty（）const
{
returnm_front==m_rear;
}
//取队头元素的值。
先决条件是队列非空
template
ElemType&SqQueue:
:
GetHead（）const
{
returnm_base[m_front];
}
//入队，插入e到队尾
template
voidSqQueue:
:
Append（constElemType&e）
{
intj,k;
if（m_front==（m_rear+1）%m_size）{//队满，则扩展空间。
ElemType*newbase;
newbase=newElemType[m_size+10];//分配新空间
for（j=m_front,k=0;jnewbase[k]=m_base[j];//复制元素到新空间
delete[]m_base;//释放原空间
m_base=newbase;
m_front=0;//重置队头指针
m_rear=k;//重置队尾指针
m_size+=10;//重置向量空间大小
}
m_base[m_rear]=e;
m_rear=（m_rear+1）%m_size;
}
//出队。
先决条件是队列非空
template
voidSqQueue:
:
Remove（）
{
m_front=（m_front+1）%m_size;
升级会员 