数据结构上机题Word文档下载推荐.docx
- 文档编号:19459164
- 上传时间:2023-01-06
- 格式:DOCX
- 页数:31
- 大小:157.16KB
数据结构上机题Word文档下载推荐.docx
《数据结构上机题Word文档下载推荐.docx》由会员分享,可在线阅读,更多相关《数据结构上机题Word文档下载推荐.docx(31页珍藏版)》请在冰豆网上搜索。
if(L.length>
=L.listsize)//如果所建链表长度超过当前分配的空间,则增加大小为初始增量的空间。
printf("
\n所建链表长度超过当前分配的空间,将增加大小为初始增量的空间!
\n"
);
L.elem=(int*)realloc(L.elem,(L.listsize+ADD_SIZE)*sizeof(int));
L.listsize+=ADD_SIZE;
}
请输入整数元素:
"
scanf("
%d"
&
L.elem[L.length]);
//输入结点。
L.length++;
\n继续创建操作请输入1,退出创建请输入0:
go);
}
//2遍历链表
voidprint(SqListL)
inti;
for(i=0;
i<
L.length;
i++)
%d"
L.elem[i]);
//3查找链表中某一元素
voidfind(SqListL,inte)
inti=0,flag=0,k=0;
while(i<
L.length)
if(L.elem[i]==e)
if(k==0)
\n在顺序表中找到该元素,位于第"
k=1;
flag=1;
//所有符合查找条件的元素都设置其标志为flag=1;
if(flag==1)printf("
%d,"
i+1);
//输出所有符合查找条件的元素的位置序号。
i++;
号位置!
elseprintf("
\n在该顺序表中找不到该元素!
//4判断所建链表是否对称。
voidsymmetry(SqListL)
inti,ave;
if(L.length==1)printf("
\n该顺序表中仅有一个元素!
else
ave=L.length/2;
//使ave的值为链表的中间变量,作为循环结束条件。
ave;
if(L.elem[i]!
=L.elem[L.length-i-1])//判断链表中前后交替结点是否相等,
\n该顺序表为非对称表!
//如果在循环过程中出现不相等的情况,
break;
//即可判断此链表是一非对称表。
if(i=ave-1)printf("
\n该顺序表为对称表!
//否则如果一直到最后都相等,则是对称链表。
//奇数排在偶数之前
voidsplit(SqList&
inttemp,i,m=0,n,c,b,JShu=0,OShu=0;
//i代表各元素所在位置的序号
for(i=L.length-1;
i>
=0;
)//从后向前寻找奇数在偶数前的情况,如果一个奇数或偶数之后还是一个奇数和偶数,
OShu=0;
//就让代表奇数和偶数的变量自增,在每次所有符合连续情况的奇偶数交换完成后,偶数要从新计数。
while((L.elem[i]%2)!
=0&
&
(i>
=0))
JShu++;
i--;
}//此循环从后往前查找奇数,直到遇到一个偶数结束,
while((L.elem[i]%2)==0&
m=i+1;
OShu++;
}//此循环从后往前查找偶数,直到遇到一个奇数结束
if((L.elem[i]%2)!
=0)//如果一器奇数在偶数之前,交换它们,使这一串奇数位于偶数之前。
n=i+1;
//此处的n值是根据实例推测出来就等于序号加1.
if(JShu<
=OShu)//如果这一串奇数的数量于位于其前面的一串偶数个数,就只交换奇数数量的数据。
for(b=0;
b<
JShu;
b++)
temp=L.elem[n];
L.elem[n]=L.elem[n+OShu];
//n+OShu也是根据实例推出来的。
L.elem[n+OShu]=temp;
n++;
else//否则就交换偶数数量的元素,即以最少操作达到所有奇数排在所有偶数之前的目的。
OShu;
c=i+OShu+JShu;
temp=L.elem[c];
L.elem[c]=L.elem[n];
L.elem[n]=temp;
c--;
//插入函数
voidinsert(SqList&
inte,i,j,go=1;
if(L.length==0)//长度为0即是顺序表未创建任何元素,应首先创建。
\n顺序表中尚未有任何元素,请输入元素创建顺序表。
Creat(L);
\n请输入要插入的元素:
scanf("
e);
i=0;
//i值初始化为0使对比从顺序表第一个元素开始。
while(L.elem[i]<
e&
L.length-1)//L.length即是顺序表的位置序号,在循环到最后一个元素时应退出
if(L.elem[i]>
=e)//使最后一个元素参与此处的对比判断
for(j=L.length;
j>
i;
j--)//如果符合条件,则第i个元素及其以后的元素的值顺序后移,以腾出第i个位置
L.elem[j]=L.elem[j-1];
L.elem[i]=e;
//以便能成功插入新的元素。
L.elem[i+1]=e;
//假如顺序表中没有元素比新元素大,就把新元素插入到表尾。
\n继续插入操作请输入1,中止请输入0。
//合并顺序表(非递减合并到非递减)
voidunite(SqListL1,SqListL2,SqList&
L3)
inti=0,j=0,k=0;
L3.length=0;
L3.elem=(int*)malloc(L1.length+L2.length*sizeof(int));
L3.listsize=L1.length+L2.length;
L1.length&
j<
L2.length)
if(L1.elem[i]<
=L2.elem[j])
L3.elem[k]=L1.elem[i];
L3.length++;
k++;
L3.elem[k]=L2.elem[j];
j++;
L1.length)
while(j<
//主函数
voidmain()
SqListL,L1,L2,L3;
L.listsize=0;
L1.length=L1.listsize=0;
L2.length=L2.listsize=0;
intnumber,e;
\n实验一:
顺序表\n"
\n******************************************************************"
\n1.创建顺序表"
\n2.遍历顺序表"
\n3.在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0"
\n4.判断该顺序表中元素是否对称,对称返回1,否则返回0"
\n5.把顺序表中所有奇数排在偶数之前"
\n6.输入整型元素序列利用有序表插入算法建立一个有序表"
\n7.利用算法6建立两个非递减表,并合并成非递减表"
\n8.退出"
\n******************************************************************\n"
\n请输入选择序号:
number);
while(number!
=8)
switch(number)
case1:
Creat(L);
case2:
print(L);
case3:
printf("
\n请输入要查找的元素:
find(L,e);
case4:
symmetry(L);
case5:
split(L);
\n调换奇偶数元素的位置后的顺序表如下:
print(L);
case6:
insert(L);
case7:
\n利用算法6创建表L1.\n"
insert(L1);
\n利用算法6创建的表L1如下:
print(L1);
\n利用算法6创建表L2.\n"
insert(L2);
\n利用算法6创建的表L2如下:
print(L2);
\n正在合并表L1和表L2……\n"
unite(L1,L2,L3);
\n表L1和表L2合并后的表L3如下:
print(L3);
case8:
\n继续操作请输入1~8之间的数字,退出请输入8:
实验二链式存储结构
(一)----单向链表的有关操作
实验学时2学时
背景知识:
单向链表的插入、删除及应用。
目的要求
1.掌握单向链表的存储特点及其实现。
2.掌握单向链表的插入、删除算法及其应用算法的程序实现。
1.随机产生或键盘输入一组元素,建立一个带头结点的单向链表(无序)。
2.遍历单向链表。
3.把单向链表中元素逆置(不允许申请新的结点空间)。
4.在单向链表中删除所有的偶数元素结点。
5.编写在非递减有序链表中插入一个元素使链表元素仍有序的函数,并利用该函数建立一个非递减有序单向链表。
6.利用算法5建立两个非递减有序单向链表,然后合并成一个非递增链表。
7.利用算法5建立两个非递减有序单向链表,然后合并成一个非递减链表。
8.利用算法1建立的链表,实现将其分解成两个链表,其中一个全部为奇数,另一个全部为偶数(尽量利用已知的存储空间)。
#include"
stdio.h"
stdlib.h"
conio.h"
malloc.h"
#defineerror0
#defineok1
#defineoverflow-1
typedefstructlnode
{
intdata;
structlnode*next;
}lnode,*linklist;
linklistinitlinklist(linklistl)//初始化链表
l=(linklist)malloc(sizeof(lnode));
//分配空间
l->
data=0;
next=NULL;
returnl;
}
linklistcreatelist(linklistl,intn){/*创建单链表(头插法)*/
linklistp,t;
inti;
t=l;
for(i=n;
0;
i--){
p=(linklist)malloc(sizeof(lnode));
Pleaseinputthe%dnumber:
n-i+1);
p->
data);
t->
next=p;
t=p;
voidprintlist(linklistl){//打印链表
linklistp;
p=l->
next;
while(p){
%d->
p->
p=p->
null\n"
linklistinverselist(linklistl){/*在单链表实现逆置*/
linklists,p,q;
s=l->
if(s==NULL)returnl;
q=NULL;
p=s;
while(p!
=NULL){
s->
next=q;
q=s;
s=p;
linklistdeleteeven(linklistl){/*删除第i个元素结点*/
linklistp,q;
p=l;
while(p->
next){if(p->
next->
data%2==0){q=p->
next=q->
free(q);
elsep=p->
returnl;
intinsertsortedlist(linklistl,inte)/*在非递减单链表插入e,是的单链表仍然非递减*/
linklistp,s,q;
s=(linklist)malloc(sizeof(lnode));
if(l->
next==NULL)
next=s;
data=e;
else
q=l->
while(p->
next)p=p->
if(e<
data){s->
next=l->
elseif(e>
data)
while(q->
next&
e>
q->
q=q->
returnok;
voidcreatesortedlist(linklistl,intn,inta[])/*利用上面insertsorted算法,创建一个单调非递减单链表*/
for(i=0;
n;
i++){
a[i]);
insertsortedlist(l,a[i]);
voidmergelist(linklistla,linklistlb,linklistlc)/*将两个单调有序链表合并成一个单调有序链表*/
linklistpa,pb,pc;
pa=la->
pb=lb->
(*lc)=(*la);
pc=lc;
while(pa&
pb){
if(pa->
data<
=pb->
data){
pc->
next=pa;
pc=pa;
pa=pa->
else{pc->
next=pb;
pc=pb;
pb=pb->
next=pa?
pa:
pb;
free(lb);
intmain()
linklistl,la,lb,lc;
lnode*L,*LA,*LB,*LC;
inti=0,n,a[100],b[100],cout=0,lena,lenb;
l=L;
la=LA;
lb=LB;
lc=LC;
inputalengthofthelist:
n);
l=initlinklist(l);
//初始化表l
createlist(l,n);
//创建l
printthelist:
//打印l
printlist(l);
inverselist(l);
//逆置表l
afterinverse,thelistislike:
//还原表l,即再逆置
now,deletetheevenelem:
deleteeven(l);
//删除表l的偶数元素结点
la=initlinklist(la);
//初始化表la
lb=initlinklist(lb);
lc=initlinklist(lc);
now,inputthelengthoflista:
lena);
createsortedlist(la,lena,a);
//创建有序链表la
printlist(la);
now,inputthelengthoflistb:
lenb);
createsortedlist(lb,lenb,b);
//创建有序链表lb
printlist(lb);
mergelist(la,lb,lc);
//合并la,lb
printlist(lc);
return0;
实验三迷宫问题求解
栈的操作。
1.掌握栈的存储特点及其实现。
2.掌握栈的出栈和入栈操作。
实验内容:
以一个mxn的长方阵表示迷宫,0和1分别表示迷宫中的通路和障碍。
设计一个程序,对任意设定的迷宫,求出一条从入口到出口的通路,或得出没有通路的结论。
要求:
首先实现一个顺序或链表做存储结构的栈类型,然后编写一个求解迷宫的非递归程序。
求得的通路以三元组(i,j,d)的形式输出,其中:
(i,j)表示迷宫的坐标,d表示走到下一坐标的方向。
如对下面的迷宫,输出的一条通路为:
(1,1,1),(1,2,2),(2,2,2),(3,2,3),(3,1,2),…...
迷宫约定,x方向为行方向,y方向为列方向,迷宫开始坐标(左上角)为(1,1)。
stdlib.h>
#defineM20
#defineN20
#defineSIZE50
inta[M][N];
typedefstructnodetype
{introw,cn;
//当前位置坐标
intdr;
//下一步的方向
structnodetype*next;
//指向下一结点指针
structnodetype*pre;
//指向上一节点指针
}node;
//栈结点类型
voidmg(intm,intn)//创建迷宫并在四周设障碍
inti,j;
for(i=0,j=0;
m+2;
i++)
a[i][j]=1;
for(i=0,j=n+1;
for(j=0,i=0;
n+2;
j++)
for(j=0,i=m+1;
n+1;
a[i][j]
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 数据结构 上机