数据结构导论作业一.docx

数据结构导论作业一.docx

《数据结构导论作业一.docx》由会员分享，可在线阅读，更多相关《数据结构导论作业一.docx（16页珍藏版）》请在冰豆网上搜索。

数据结构导论作业一

1、章节作业

第一章概论

1．设计算法在整型数组A[n]中查找值为K的元素，若找到，则输出其位置i（0≤i≤n-1），否则输出-1作为标志，并分析算法的时间复杂度。

intsearch（intA[],intn,intk）

{inti;

i=0;

while（i<=n-1）

if（A[i]!

=k）i++;

elsebreak;

if（i<=n-1）returnI;

elsereturn-1；

}

当查找成功时，A[i]与k比较次数≤n；当查找不成功时，A[i]与k比较n次，所以，算法时间复杂度T（n）=O（n）。

2．写出计算方阵A[n][n]与B[n][n]乘积C[n][n]的算法，分析算法的时间复杂度。

voidmatrixmultiply（intA[][n],intB[][n],intC[][n],intn）

{intI,j;

for（i=0;i

for（j=0;j

{C[i][j]=0;

for（k=0;k

C[i][j]+=A[i][j]*B[k][j];

}

}

以方阵阶数n作为输出规模。

可知第二层循环中的第一条赋值语句共执行n2次，第三层循环体中的乘法和赋值语句共执行n3次，所以此算法的计算量为n3+n2，算法时间复杂T（n）=O（n3）

第二章线性表

1．设带头结点的单链表的结点结构如下：

structnode{DataTypedata；

structnode*next；

}Node，*LinkList；

试编写一个函数intcount（LinkListhead，DataTypex）统计单链表中数据域为x的结点个数。

intcount（LinkListhead,DataTypex）

{

LinkListp=head->next;

Intm=0;

while（p!

=NULL）

{if（p->data==x）m++;

p=p->next;

}

returnm;

}

2．试分别以顺序表和带头结点的单链表作存储结构，各写一个实现线性表的就地（即使用尽可能少的附加空间）逆置的算法，在原表的存储空间内将线性表（a1，a2，…，an）逆置为（an，an-1，…，a1）。

顺序表逆置算法

voidinverse_sqlist（SeqlistL）

{

intm,n,k;

DataTypetemp;

m=0;n=L.length-1;

while（m

{temp=L.data[m];

L.data[m]=L.data[n];

L.data[n]=temp;

m++;

n--;

}

}

带头结点的单链表的逆置算法

reverse_2（LinkListhead）

{

LinkListp,q;

p=head->next;

head->next=NULL;

while（p!

=NULL）

{

q=p->next;

p->next=head->next;

head->next=p;

p=q;

}

}

第三章栈、队列和数组

1．有一个整数序列，其输入顺序为20，30，90，-10，45，78，试利用栈将其输出序列改变为30，-10，45，90，78，20，试给出该整数序列进栈和出栈的操作步骤。

（用push（x）表示x进栈，pop（x）表示x出栈）

push（20）,push（30）,pop（30）,push（90）,push（-10）,pop（-10）,push（45）,pop（45）,pop（90）,push（78）,pop（78）,pop（20）

2．设有编号为1，2，3，4的四辆列车，顺序进入一个栈式结构的站台，试写出这四辆列车开出车站的所有可能的顺序。

一号列车先出站：

1234,1243,1324,1342,1432;

二号列车先出站：

2134,2143,2314,2341,2431；

三好列车先出站：

3214,3241,3421；

四号列车先出站：

4321；

但是这里的4123、4132、4213、4231都不是正解,所以共有14种可能

3．假设以带头结点的循环链表表示队列，并且只设一个指针指向队列尾结点（注意不设头指针），试编写相应的初始化队列、入队列和出队列算法。

类型定义：

typedefstructlinksd_queue

{

DataTypedata;

structlinked_queue*next;

}LqueueTp;

队列的初始化

voidInitQueue（LqueueTp*rear）

{LqueueTp*p;

p=（LqueueTp*）malloc（sizeof（LqueueTp））;

rear=p;

rear->next=rear;

}

入队列

voidEnQueue（LqueueTp*rear;DataTypex）

{LqueueTp*p;

p=（LqueueTp*）malloc（sizeof（LqueueTp））;

p->data=x;

p->next=rear->next;

rear->next=p;

rear=p

}

出队列

OutQueue（LqueueTp*rear,DataType*x）

{LqueueTp*h,*p;

if（rear==rear->next）

{error;return0;}

else{

h=rear->next;

p=h->next;

*x=p->data;

h->next=p->next;

if（p==rear）rear=h;

free（p）;

return1;

}

}

4．假设以数组cycque[m]存放循环队列的元素，同时设变量rear和quelen分别指示循环队列中队列尾元素位置和内含元素的个数。

试给出此循环队列的队列满和队列空的条件，并写出相应的入队列和出队列的算法。

类型定义：

typedefstructcycqueue

{

DataTypedata[m];

intrear;

intquelen;

}CycqueueTp;

CycqueueTp*cq

队列满条件是：

（cq->quelen==m）。

队列空条件是：

（cq->quelen==0）

入队列：

intEnCycQueue（CycqueueTp*cq;DataTypex）

{

if（cq->quelen==m）

{error;return0;}

else{

cq->rear=（cq->rear+1）%m;

cq->data[cq->rear]=x;

cq->quelen=cq->quelen+1;

return1;

}

}

出队列：

intOutCyQueue（CycqueueTp*cq）

{

if（cq->quelen==0）

{error;return0;}

else{

cq->quelen=cq->quelen-1;

*x=cq->data[（cq->rear+m-cq->quelen）%m];

return1;

}

}

取队列首元素：

DataTypeGetHead（CycqueueTp*cq）

{DataTypex;

x=cq->data[cq->rear=m-cq->quelen]%m];

returnx;

}

第四章树和二叉树

1．算法设计题

（1）以二叉链表作存储结构，试编写求二叉树叶子结点个数的算法。

typedefstructbtnode

{DataTypedata;

structbtnode*lchild,*rchild;

}*BinTree;

intleafnode_num（BinTreebt）

{

if（bt==NULL）return0;

else

if（bt->lchild==NULL）&&（bt->rchild==NULL）

return1;

else

returnleafnode_num（bt->lchild）+leafnode_num（bt->rchild）;

}

（2）设计算法求二叉树的结点的个数。

typedefstructbtnode

{DataTypedata;

structbtnode*lchild,*rchild;

}*BinTree;

intnode_num（BinTreebt）

{

if（bt==NULL）return0;

else

returnnode_num（bt->lchild）+node_num（bt->rchild）+1;

}

（3）设计算法按先序次序打印二叉树T中叶子结点的值。

typedefstructbtnode

{intdata;

structbtnode*lchild,*rchild;

}*BinTree;

voidpreorder（BinTreebt）

{if（bt!

=NULL）

{if（（bt->lchild==NULL）&&（bt->rchild==NULL））

printf（“%d”,bt->dta）;

preorder（bt->lchild）;

preorder（bt->rchild）;

}

}

2．树的存储结构采用孩子兄弟链表，试编写树的按层次遍历算法

typedefstructtnode

{intdata;

structtnode*son,*brother;

}*Tree;

voidtree_travel（Treeroot）

{InitQueue（Q）;

if（root1=NULL）

{EnQueue（q,root）;

while（!

EmptyQueue（Q））

{p=GetHead（Q）;

OutQueue（Q）;

prinf（“%d”,p->data）;

p=p->son;

while（p!

=NULL）

{Enqueue（Q,p）;

p=p->brother;

}

}

}

}

第五章图

1．求下列有向图中从顶点vo到其余各顶点的最短路径及长度（给出求解的过程）。

步骤

S

u

dist[1]

dist[2]

dist[3]

dist[4]

dist[5]

dist[6]

第1步

{v0}

1

2

3

Max_int

Max_int

Max_int

第2步

{v0,v1}

V1

1

2

3

2

Max_int

Max_int

第3步

{v0,v1,v4}

V4

1

2

3

2

Max_int

3

第4步

{v0,v1,v4,v2}

V2

1

2

3

2

Max_int

3

第5步

{v0,v1,v4,v2,v3}

V3

1

2

3

2

6

3

第6步

{v0,v1,v4,v2,v3,v6}

V6

1

2

3

2

6

3

第7步

{v0,v1,v4,v2,v3,v6,v5}

V5

1

2

3

2

6

3

2．写出将一个无向图的邻接矩阵转换成邻接表的算法。

#definevnum20

typedefstructgraph

{VertexTypevexs[vnum];

intarcs[vnum][vnum];

intvexnum,arcnum;

}GraphTp_Mat;

typedefstructarcnode

{intadjvex;

structarcnode*nextarc;

}ArcNodeTp;

typedefstructvexnode

{intvertex;

ArcNodeTp*firstarc;

AdjLis[vnum];

typedefstructgraph

{AdjLisadjlist;

intvexnum,arcnum;

}GraphTp_Adj;

voidMatrix_to_Adjlis（GraphTp_Mat*ga,GraphTp_Adj*gp）

{intI,j;

ArcNodeTp*p;

gp->vexnum=ga->vexnum;

gp->arcnum=ga->arcnum;

for（i=0;Ivexnum;i++）

{gp->adjlis[i].vertex=I;

gp->adjlis[i].firstarc=NULL;

}

for（i=0;Ivexnum;i++）

for（j=0;jvesnum;j++）

if（ga->arcs[i][j]==1）

}

p=（ArcNodeTp*）malloc（sizeof（ArcNodeTp））;

p->adjvex=j;

p->nextarc=ga->adjlis[i].firstarc;

ga->adjlis[i].firstarc=p;

}

}

第六章查找

1．假设线性表中结点是按键值递增的顺序排列，试写一顺序查找算法，将岗哨设在高下标端。

然后分别求出等概率情况下查找成功和不成功时的平均查找长度。

intsearch_sqtable（SqtableR,KeyTypek）

{

inti=0;

R.elem[R.n].key=k;

while（R.elem[i].key

if（R.elem[i].key>k‖i==R.n）return-1;

elsereturni;

}

2．试编写算法求键值为k结点在给定的二叉排序树中所在的层数。

intlevel_count（BinTreebst,KeyTypek）

{

intlev=0;

BSTNode*p=bst;

while（p!

=NULL）

{

lev++;

if（p->data==k）returnlev;

if（p->data

p=p->rchild;

else

p=p->lchild;

}

return0;

}

3．试写出从大到小输出二叉排序树中所有不小于x的元素的算法。

voidPrint_NLT（BinTreeT,intx）

{

if（T!

=NULL）

{

Print_NLT（T->rchild,x）;

If（T->data>=x）

printf（“%d\n”,T->data）;

Print_NLT（T->lchild,x）;

}

}

第七章排序

1．对于给定的一组键值：

83，40，63，13，84，35，96，57，39，79，6l，15，分别画出应用直接插入排序、直接选择排序、冒泡排序、归并排序对上述序列进行排序过程。

直接插入排序序：

[83]4063138435965739796115

[4083]63138435965739796115

[406383]138435965739796115

[13406383]8435965739796115

[1340638384]35965739796115

[133540638384]965739796115

[13354063838496]5739796115

[1335405763838496]39796115

[133539405763838496]796115

[13353940576379838496]6115

[1335394057616379838496]15

[131535394057616379838496]

直接选择排序:

[844063138435965739796115]

13[4063838435965739796115]

1315[63838435965739796140]

131535[838463965739796140]

13153539[8463965783796140]

1315353940[63965783796184]

131535394057[966383796184]

131535394057[616383799684]

13153539405761[6383799684]

1315353940576163[83799684]

131535394057616379[839684]

13153539405761637983[9684]

1315353940576163798384[96]

冒泡排序：

初始数据：

251122345447661100314120

第1趟结果：

[112225534446176314100]120

第2趟结果：

[112252534446131476]100120

第3趟结果：

[552225344431461]76100120

第4趟结果：

[51122253431444]6176100120

第5趟结果：

[511222531434]446176100120

第6趟结果：

[5112231425]34446176100120

第7趟结果：

[51131422]2534446176100120

第8趟结果：

[531114]222534446176100120

第9趟结果：

[3511]14222534446176100120

第10趟结果：

351114222534446176100120

归并排序：

[83][40][63][13][84][35][96][57][39][79][61][15]

[4083][1363][3584][5796][3979][1561]

[13406383][35578496][15396179]

[1335405763838496][15396179]

[131535394057616379838469]

2．若对序列（tang，deng，an，wan，shi，bai，fang，liu）按字典顺序进行排序，分别写出：

①冒泡排序第一趟的结果；

dengantangshibaifangliuwan

②以第一个元素为分界的快速排序第一趟的结果；

liudenganliubaifangtangwan

③堆排序时的初始堆。

3．对如下关键字序列（3，8，85，12，37，50）按堆排序算法进行从小到大排序，要求画出排序全过程的示意图。

建初始堆

输出3，85与3交换重建堆

重建堆

输出8，37与8交换

输出12，12与85交换重建堆

输出37,37与50交换重建堆

输出85

输出50,50与85交换

排序结果：

3812375085

4．举例说明排序章介绍的各排序方法中哪些是不稳定的?

不稳定排序：

快速排序直接选择排序堆排序

例：

快速排序

初始状态4065384997651360

排序后1338404960656597

堆排序

初始状态6538759780132765

排序后1327386565758097

直接排序

初始状态4065384997651360

排序后1338404960656597