数据结构导论作业一.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;ifor(j=0;j{C[i][j]=0;for(k=0;kC[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;elseif(bt->lchild==NULL)&&(bt->rchild==NULL)return1;elsereturnleafnode_num(bt->lchild)+leafnode_num(bt->rchild);}(2)设计算法求二叉树的结点的个数。typedefstructbtnode{DataTypedata;structbtnode*lchild,*rchild;}*BinTree;intnode_num(BinTreebt){if(bt==NULL)return0;elsereturnnode_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到其余各顶点的最短路径及长度(给出求解的过程)。步骤Sudist[1]dist[2]dist[3]dist[4]dist[5]dist[6]第1步{v0}123Max_intMax_intMax_int第2步{v0,v1}V11232Max_intMax_int第3步{v0,v1,v4}V41232Max_int3第4步{v0,v1,v4,v2}V21232Max_int3第5步{v0,v1,v4,v2,v3}V3123263第6步{v0,v1,v4,v2,v3,v6}V6123263第7步{v0,v1,v4,v2,v3,v6,v5}V51232632.写出将一个无向图的邻接矩阵转换成邻接表的算法。#definevnum20typedefstructgraph{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].keyif(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->datap=p->rchild;elsep=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交换 排序结果:38123750854.举例说明排序章介绍的各排序方法中哪些是不稳定的?不稳定排序:快速排序直接选择排序堆排序例:快速排序初始状态4065384997651360排序后1338404960656597堆排序初始状态6538759780132765排序后1327386565758097直接排序初始状态4065384997651360排序后1338404960656597
for(j=0;j{C[i][j]=0;for(k=0;kC[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;elseif(bt->lchild==NULL)&&(bt->rchild==NULL)return1;elsereturnleafnode_num(bt->lchild)+leafnode_num(bt->rchild);}(2)设计算法求二叉树的结点的个数。typedefstructbtnode{DataTypedata;structbtnode*lchild,*rchild;}*BinTree;intnode_num(BinTreebt){if(bt==NULL)return0;elsereturnnode_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到其余各顶点的最短路径及长度(给出求解的过程)。步骤Sudist[1]dist[2]dist[3]dist[4]dist[5]dist[6]第1步{v0}123Max_intMax_intMax_int第2步{v0,v1}V11232Max_intMax_int第3步{v0,v1,v4}V41232Max_int3第4步{v0,v1,v4,v2}V21232Max_int3第5步{v0,v1,v4,v2,v3}V3123263第6步{v0,v1,v4,v2,v3,v6}V6123263第7步{v0,v1,v4,v2,v3,v6,v5}V51232632.写出将一个无向图的邻接矩阵转换成邻接表的算法。#definevnum20typedefstructgraph{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].keyif(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->datap=p->rchild;elsep=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交换 排序结果:38123750854.举例说明排序章介绍的各排序方法中哪些是不稳定的?不稳定排序:快速排序直接选择排序堆排序例:快速排序初始状态4065384997651360排序后1338404960656597堆排序初始状态6538759780132765排序后1327386565758097直接排序初始状态4065384997651360排序后1338404960656597
{C[i][j]=0;
for(k=0;kC[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;elseif(bt->lchild==NULL)&&(bt->rchild==NULL)return1;elsereturnleafnode_num(bt->lchild)+leafnode_num(bt->rchild);}(2)设计算法求二叉树的结点的个数。typedefstructbtnode{DataTypedata;structbtnode*lchild,*rchild;}*BinTree;intnode_num(BinTreebt){if(bt==NULL)return0;elsereturnnode_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到其余各顶点的最短路径及长度(给出求解的过程)。步骤Sudist[1]dist[2]dist[3]dist[4]dist[5]dist[6]第1步{v0}123Max_intMax_intMax_int第2步{v0,v1}V11232Max_intMax_int第3步{v0,v1,v4}V41232Max_int3第4步{v0,v1,v4,v2}V21232Max_int3第5步{v0,v1,v4,v2,v3}V3123263第6步{v0,v1,v4,v2,v3,v6}V6123263第7步{v0,v1,v4,v2,v3,v6,v5}V51232632.写出将一个无向图的邻接矩阵转换成邻接表的算法。#definevnum20typedefstructgraph{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].keyif(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->datap=p->rchild;elsep=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交换 排序结果:38123750854.举例说明排序章介绍的各排序方法中哪些是不稳定的?不稳定排序:快速排序直接选择排序堆排序例:快速排序初始状态4065384997651360排序后1338404960656597堆排序初始状态6538759780132765排序后1327386565758097直接排序初始状态4065384997651360排序后1338404960656597
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;elseif(bt->lchild==NULL)&&(bt->rchild==NULL)return1;elsereturnleafnode_num(bt->lchild)+leafnode_num(bt->rchild);}(2)设计算法求二叉树的结点的个数。typedefstructbtnode{DataTypedata;structbtnode*lchild,*rchild;}*BinTree;intnode_num(BinTreebt){if(bt==NULL)return0;elsereturnnode_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到其余各顶点的最短路径及长度(给出求解的过程)。步骤Sudist[1]dist[2]dist[3]dist[4]dist[5]dist[6]第1步{v0}123Max_intMax_intMax_int第2步{v0,v1}V11232Max_intMax_int第3步{v0,v1,v4}V41232Max_int3第4步{v0,v1,v4,v2}V21232Max_int3第5步{v0,v1,v4,v2,v3}V3123263第6步{v0,v1,v4,v2,v3,v6}V6123263第7步{v0,v1,v4,v2,v3,v6,v5}V51232632.写出将一个无向图的邻接矩阵转换成邻接表的算法。#definevnum20typedefstructgraph{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].keyif(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->datap=p->rchild;elsep=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交换 排序结果:38123750854.举例说明排序章介绍的各排序方法中哪些是不稳定的?不稳定排序:快速排序直接选择排序堆排序例:快速排序初始状态4065384997651360排序后1338404960656597堆排序初始状态6538759780132765排序后1327386565758097直接排序初始状态4065384997651360排序后1338404960656597
{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;
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)
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)
cq->rear=(cq->rear+1)%m;
cq->data[cq->rear]=x;
cq->quelen=cq->quelen+1;
出队列:
intOutCyQueue(CycqueueTp*cq)
if(cq->quelen==0)
cq->quelen=cq->quelen-1;
*x=cq->data[(cq->rear+m-cq->quelen)%m];
取队列首元素:
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)
returnleafnode_num(bt->lchild)+leafnode_num(bt->rchild);
(2)设计算法求二叉树的结点的个数。
intnode_num(BinTreebt)
returnnode_num(bt->lchild)+node_num(bt->rchild)+1;
(3)设计算法按先序次序打印二叉树T中叶子结点的值。
{intdata;
voidpreorder(BinTreebt)
{if(bt!
{if((bt->lchild==NULL)&&(bt->rchild==NULL))
printf(“%d”,bt->dta);
preorder(bt->lchild);
preorder(bt->rchild);
2.树的存储结构采用孩子兄弟链表,试编写树的按层次遍历算法
typedefstructtnode
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;
{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
第2步
{v0,v1}
V1
第3步
{v0,v1,v4}
V4
第4步
{v0,v1,v4,v2}
V2
第5步
{v0,v1,v4,v2,v3}
V3
6
第6步
{v0,v1,v4,v2,v3,v6}
V6
第7步
{v0,v1,v4,v2,v3,v6,v5}
V5
2.写出将一个无向图的邻接矩阵转换成邻接表的算法。
#definevnum20
typedefstructgraph
{VertexTypevexs[vnum];
intarcs[vnum][vnum];
intvexnum,arcnum;
}GraphTp_Mat;
typedefstructarcnode
{intadjvex;
structarcnode*nextarc;
}ArcNodeTp;
typedefstructvexnode
{intvertex;
ArcNodeTp*firstarc;
AdjLis[vnum];
{AdjLisadjlist;
}GraphTp_Adj;
voidMatrix_to_Adjlis(GraphTp_Mat*ga,GraphTp_Adj*gp)
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(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].keyif(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->datap=p->rchild;elsep=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交换 排序结果:38123750854.举例说明排序章介绍的各排序方法中哪些是不稳定的?不稳定排序:快速排序直接选择排序堆排序例:快速排序初始状态4065384997651360排序后1338404960656597堆排序初始状态6538759780132765排序后1327386565758097直接排序初始状态4065384997651360排序后1338404960656597
if(R.elem[i].key>k‖i==R.n)return-1;
elsereturni;
2.试编写算法求键值为k结点在给定的二叉排序树中所在的层数。
intlevel_count(BinTreebst,KeyTypek)
intlev=0;
BSTNode*p=bst;
lev++;
if(p->data==k)returnlev;
if(p->datap=p->rchild;elsep=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交换 排序结果:38123750854.举例说明排序章介绍的各排序方法中哪些是不稳定的?不稳定排序:快速排序直接选择排序堆排序例:快速排序初始状态4065384997651360排序后1338404960656597堆排序初始状态6538759780132765排序后1327386565758097直接排序初始状态4065384997651360排序后1338404960656597
p=p->rchild;
p=p->lchild;
return0;
3.试写出从大到小输出二叉排序树中所有不小于x的元素的算法。
voidPrint_NLT(BinTreeT,intx)
if(T!
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
直接排序
copyright@ 2008-2022 冰豆网网站版权所有
经营许可证编号:鄂ICP备2022015515号-1