数据结构答案打印版.docx
《数据结构答案打印版.docx》由会员分享，可在线阅读，更多相关《数据结构答案打印版.docx（41页珍藏版）》请在冰豆网上搜索。
数据结构答案打印版
1试卷参考答案
1.填空题
（1）N2+1
（2）2N–1（3）2
（4）队空条件：
front==rear队满条件：
（rear+1）%（m+1）==front
注：
假设牺牲数组一个单元，只存放m个元素
（6）广度优先搜索（8）14
（9）避免在插入和删除操作中将第一个结点看作是特殊结点，使程序编写简单。
2.基本思想如下：
（1）存储结构：
两个栈使用同一段内存空间，图示如下。
栈1只做PUSH操作，对应队列的进队；栈2只做POP操作，对应队列出队操作。
（2）队列定义：
typedefstruct{
intdata[M];
intTop1;//栈1指针
intTop2;//栈2指针
}SqQueue;
队列初始化：
SqQueueq;
q.Top1=－1;
q.Top2=0;
（3）进队操作：
if（q.Top1==M-1） printf（“队满！
”）;
elseq.data[++q.top1]=e;
（4）出队操作：
if（q.Top2==q.Top1+1）printf（“队空！
”）;
elsee=q.data[q.top2++];
4.拓扑排序算法如下所示：
voidTopologicalSort（Graphg）{
//有向图g采用邻接表存储结构
int indegree[MAX_VER];//定义各顶点入度数组indegree[]
int i,k,count;
SqQueue q;
node *p;
FindIndegree（indegree,g）;//求出所有顶点的入度
q=InitQueue（）;//建0入度顶点队列q
for（i=0;i if（!
indegree[i]）q=EnQueue（q,i）;//入度为0者进队列
count=0;//对输出顶点计数
while（!
QueueEmpty（q））
{ q=DeQueue（q,&k）;
printf（"%3c",g.adjlist[k].vex）;
count++;//输出k号顶点并计数
for（p=g.adjlist[k].firstarc;p;p=p->next）
{
--indegree[p->no];//对k号顶点的每个邻接点的入度减1
if（!
indegree[p->no]）
q=EnQueue（q,p->no）;//若入度为0则进队列
}//for
}//while
if（count printf（"\nThereisacircuit."）;
}//TopologicalSort
对于有n个顶点，e条边的有向图的拓扑排序算法的时间复杂性为O（n+e）
5.由于学号已经排好序，要求按学生成绩（总分）排名次，若总分相同，则学号在前的，仍排在前面，即要求选择的排序算法具有稳定性，分析具有稳定性的排序算法有如下4种：
再从时间与空间去综合考虑，选择改进的冒泡排序好。
算法如下：
voidbubble_sort（inta[],intn）{
intt=0,done=0;
inti,j;
for（i=1;i<=n-1&&!
done;i++）
{
done=1;
for（j=0;j<=n-i-1;j++）
if（a[j]>a[j+1]）
{done=0;t=a[j];a[j]=a[j+1];a[j+1]=t;}
}
}
6.归并排序算法如下：
voidMerge（intb[],inta[],inti,intm,intn）{
//将有序的b[i..m]和b[m+1..n]归并为有序的a[i..n]
intj,k;
for（j=m+1,k=i;（i<=m）&&（j<=n）;++k）
{
cmp++;
if（b[i] {a[k]=b[i++];change++;}
else{a[k]=b[j++];change++;}
}
while（i<=m）
{a[k++]=b[i++];change++;}//将剩于的b[i..m]复制到a
while（j<=n）
{a[k++]=b[j++];change++;}//将剩余的b[j..n]复制到a
}//Merge
voidMSort（inta[],intc[],ints,intt）{
//将a[s..t]归并排序为c[s..t]
intm;
intb[MAX];
if（s==t）c[s]=a[s];
else
{
m=（s+t）/2;//将a[s..t]平分为a[s..m]和a[m+1..t]
MSort（a,b,s,m）;//递归地将a[s..m]归并为有序的b[s..m]
MSort（a,b,m+1,t）;//递归地将a[m+1..t]归并为有序的b[m+1..t]
Merge（b,c,s,m,t）;//将b[s..m]和b[m+1..t]归并到c[s..t]
}
}//MSort
voidMergeSort（inta[],intn）{
//对数组a做归并排序
MSort（a,a,1,n）;
}//MergeSort
7.解：
建立二叉排序树并计算平衡因子如下图：
2试卷参考答案
1．B 2．C 3．C 4．A 5．A 6．D 7．D 8．B
二、填空题
1．O（log2N）2．（21，30，55，45，94，66，90，82）3．1014．63
5．ab+c*ef*h-qr+/+3+
6.①done:
=False ②j:
=iDIV2 ③i:
=j
④done:
=True ⑤R[i]:
=extra
三、解答：
IntRearrange（SeqLista;int n）
{ i=0;j=n-1;
t=a[0];
while（i { while（i=0） j--;∥若当前元素为大于等于零，指针前移
if（i while（i if（i }
a[i]=t;
}
四．解答：
（1） 邻接表
（2） 深度优先dfs 广度优先bfs
五：
二叉树层次遍历算法：
voidLevelorder（BTreeNode*BT）
{ BTreeNode*q[M];
intfront=0,rear=0;
BTreeNode*p;
If（BT!
=NULL）
{
rear=（rear+1）%M;
q[rear]=BT;
}
while（front!
=rear）
{
front=（front+1）%M;
p=q[front];
cout<data<<'';
if（p->left!
=NULL）
{ rear=（rear+1）%M;
q[rear]=p->left;}
if（p->right!
=NULL）
{ rear=（rear+1）%M;
q[rear]=p->right;}
}
}
六：
求广义表深度算法：
intDepth（GLNode*GL）
{
if（GL==NULL）return1;//空表深度为1
if（GL->tag==false）return0;//原子深度为0
intmax=0;
while（GL!
=NULL）
{ if（GL->tag==True）
{ intdep=Depth（GL->sublist）;
if（dep>max） max=dep;
}
GL=GL->next;
}
returnmax+1;//非空表深度为各元素的深度最大值加上1}
3试卷参考答案
一.填空题
1．待排序的原始记录按关键字有序或“基本有序”排列 O（n）
2．18.43．184．先序
5．第i列不为零的元素个数，第i行不为零的元素个数
6．AOE网中，从源点到汇点带权路径长度最长的路径。
7．P29．10010．log（n-1） O（logn）
二.根据要求解答下列问题.
3.中序线索二叉树为：
4.提供三种方法：
（1）牺牲一个单元不用
当（Q.front==Q.rear）时队列为空
当（（Q.rear+1）%MAXSIZE==Q.front）是为满
（2）标志域法
设置一个flag标志域，设（flag==0）时队列空，（flag==1）时队列满
（3）计数法
当（Q.length==MAXSIZE）时为满，当（Q.length=0）时为空
５.当插入字母Y后，Y所形成的节点应为X节点的右孩子，此时以Z为根的子树失去平衡，为满足平衡二叉树的要求，应进行LR型旋转，旋转后的结果为：
三.答：
四.程序如下：
#include
#include
intdelduplicate（inta[],intn）
{
inti,j,k,count;
i=0;
while（i {
j=i+1;
count=0;
while（j {
j++;
count++;
}
if（count!
=0）
{
for（k=j;k }
n=n-count;
i++;
}
returnn;
}
voidmain（void）
{
intn;//元素个数
inta[100];//存放表中的元素
inti;
cout<<"输入元素个数"< cin>>n;
for（i=0;i {
cin>>a[i];
cout< }
cout< n=delduplicate（a,n）;
cout<<"现在元素的个数为n="< for（i=0;i cout< cout<}
五.程序如下：
typedefstructBiThrNode
{
TElemTypedata;
structBiThrNode *lchild,*rchild;
intdegree;
}BiThrNode,*BiThrTree;
BiThrTreeDegreeOfTree（BiThrTreeT）
{
BithrNode*p;
count=0;
p=T->lchild;
if（p!
=null）
{
count++;
while（p->rchild!
=null） count++;
}
T->degree=count;
if（T->lchild） DegreeOfTree（T->lchild）;
if（T->rchild） DegreeOfTree（T->rchild）;
retrunT;
}
六.算法如下：
#defineMAX_VERTEX_NUM 20
TypedefstructArcNode
{
Intadjvex;
StructArcNode*nextarc;
InfoType *info;
}ArcNode;
TypedefstructVNode
{
VertexTypedata;
ArcNode*firstarc;
}VNode,AdjList[MAX_VERTEX_NUM];
Typedefstruct
{
AdjListverticed;
Int vexnum,arcnum;
Int kind;
}ALGraph;
Booleanvisited[MAX];
Status（*VisitFunc）（intv）;
VoidBFSTraverse（ALGraphG,Status（*Visit）（intv））
{
For（v=0;v InitQueue（Q）;
For（v=0;v If（!
visited[v]）
{
Visited[v]=TRUE; visit（v）;
EnQueue（Q,v）;
While（!
QueueEmpty（Q））
{
DeQueue（Q,u）;
For（w=FirstAdjVex（G,u）;w;w=NextAdjVex（G,u,w））
If（!
Visted[w]）
{
Visited[w]=TRUE; visit（w）;
EnQueue（Q,W）;
}
}
}
}
七.
（1）2*h
（2）a[h]=a[j]（3）a[h]=temp
（4）n/2（5）n（6）HeapAdjust（a,1,i-1）
4试卷参考答案
一.填空题
1.O（nlogn）2.18.43.EDCBA4.求解最小生成树5、2n-1
6、旋转7、p28、p!
=NULL; p=p->lchild; p=p->rchild;
二.解答：
3. 1）if（（Q.rear+1）%maxqsize==Q.front）队列满
2）if（（q.rear==q.front）and（q.flag==1）队列满
5.堆为：
（12，38，25，50，76，66，49，98）
四.解答：
intpartition（SqList&L,intlow,inthigh）
{ L.r[0]=L.r[low];
Pivotkey=L.r[low].key;
while（low {
while（low=pivotkey） --high;
L.r[low]=L.r[high];
while（low L.r[high]=L.r[low];
}
L.r[low]=L.r[0];
}
Voidqsort（sqlist&L,intlow,inthigh）
{ if（low pivotloc=partition（L,low,high）;
qsort（L,low,pivotloc-1）;
qsort（L,pivotloc+1,high）;
}
}
Voidquicksort（sqlist&L）
{
qsort（L,1,L.length）;
}
五.解答：
intcomputbal（BiTreebt）
{
inthl,hr,max;
if（bt==NULL） return（0）;
else{
hl=computbal（bt->LChild）;/*求左子树的深度*/
hr=computbal（bt->RChild）;/*求右子树的深度*/
bt->bal=hl-hr;/*求出平衡因子*/
max=hl>hr?
hl:
hr;/*得到左、右子树深度较大者*/
return（max+1）;/*返回树的深度*/
}
}
六.解答：
Statustopologicalsort（ALGraphG）
{
findInDegree（G,indegree）;
initstack（s）;
for（i=0;i if（!
indegree[i]） push（s,i）;
count=0;
while（!
srtackempty（s））
{
pop（s,i）;
printf（I,G.vertices[i].data）;
++count;
for（p=G.vertices[i].firstarc;p;p=p->nextarc）
{
k=p->adjvex;
if（!
（--indegree[k]）） push（s,k）;
}
}
if（count else returnok;
}
七.解答：
顺序栈类型定义：
Typedefstruct
{ selemtype*base;
selemtype*top;
int stacksize;
}sqstack;
循环队列的类型定义：
Typedefstruct
{
Qelemtype*base;
int front;
int rear;
}squeue;
二叉链表的类型定义
TypedfstructBitNode
{
TElemType data;
StructBitNode *lchild,*rchild;
}BitNode,*BitTree;
邻接表类型定义：
#defineMAX_VERTEX_NUM 20
Typedefstructarcnode
{
intadjvex;
structarcnode *nextarc;
infotype *info;
}arcnode;
Typedefstrcutvnode
{
vertextype data;
arcnode *firstarc;
}vnode,adjlist[MAX_VERTEX_NUM];
Typedefstruct
{
Adjlist vertices;
int vexnum,arcnum;
int kind;
}algraph;
5试卷参考答案
一、填空题
1.随机存取数据方便2.1003.EDCBA4.插入5.（rear-qulen+m+1）%（m+1）
6.m+n-17.P29.O（log10n）10.52
二、
Prim算法：
假设N=（V,{E}）是连通网，TE是N的最小生成树的边的集合。
算法从U={u0}（u0∈V），TE={}开始，重复执行下述操作：
在所有u∈U，v∈V-U的边（u,v）∈E中找一条代价最小的边（u0,v0）并入集合TE，同时v0并入U，直到U=V为止。
此时TE中有n-1条边，则T=（V,{TE}）为N的最小生成树。
时间复杂度为O（n2），与边数无关，适合于求边稠密的网的最小生成树。
Kruskal算法从另一个途径求网的最小生成树。
假设N=（V,{E}）是连通网，则令最小生成树的初始状态为只有n个顶点而无边的非连通图T=（V,{}），图中每个顶点自成一个连通分量。
在E中选择代价最小的边，若该边依附的顶点落在T中不同的连通分量上，则将该边加入到T中，否则舍去此边而选择下一条代价最小的边。
依此类推，直到T中所有顶点都在同一个连通分量上为止。
时间复杂度为O（eloge）,与边数有关，适合于求边稀疏的网的最小生成树。
三、
四．快速排序不稳定。
例如：
35531排序后结果：
13355
五．
//统计字符串s中t的个数
#include
#include
//子串定位
intFindSubString（chars[],chart[],intpos）
{
inti=pos,j=0;
intslen=strlen（s）;
inttlen=strlen（t）;
while（i{
if（s[i]==t[j]）
{
i++;
j++;
}
else
{
i=i-j+1;
j=0;
}
}
if（j==tlen）
returni-j;
elsereturn-1;
}
//主程序
voidmain（）
{
char*s="abcdbcdefgbcdabcd";
char*t="bcd";
intpos=0;
intcnt
升级会员 