经典数据结构上机题复习资料.docx

《经典数据结构上机题复习资料.docx》由会员分享，可在线阅读，更多相关《经典数据结构上机题复习资料.docx（26页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、数据结构上机实验题目实验一 线性表的顺序存储结构 实验学时 2学时 背景知识:顺序表的插入、删除及应用。 目的要求： 1掌握顺序存储结构的特点。 2掌握顺序存储结构的常见算法。 实验内容 1输入一组整型元素序列，建立顺序表。 2实现该顺序表的遍历。 3在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0。 4判断该顺序表中元素是否对称,对称返回1,否则返回0。 5实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。 6输入整型元素序列利用有序表插入算法建立一个有序表。 7利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。 8. 利用该顺序结构实现循环队列的入队、

2、出队操作。8编写一个主函数,调试上述算法。 #include #include #define OVERFLOW 0#define MAXSIZE 100typedef int ElemType;typedef struct listElemType elemMAXSIZE; int length;Sqlist;void Creatlist(Sqlist &L)int i; printf(请输入顺序表的长度：);/输入一组整型元素序列，建立一个顺序表。 scanf(%d,&L.length); for(i=0;iL.length;i+) scanf(%d,&L.elemi);void prin

3、tlist(Sqlist &L)/以输出的形式实现对该顺序表的遍历int i; for(i=0;iL.length;i+) printf(%d ,L.elemi); printf(n);void Searchlist(Sqlist &L,int x)/在顺序表中进行顺序查找某一元素x，查找成功则返回其存储位置i，否则返回错误信息int i,k=-1; for(i=0;i=i;j-)L.elemj=L.elemj-1; L.elemj=x; L.length+;void Delete(Sqlist &L,int i)/删除顺序表中第i个元素int j;for(j=i;jL.length;j+)L

4、.elemj-1=L.elemj;L.length-;void Insert(Sqlist &L,int x)/输入一个元素x，把它插入到有序表中，使顺序表依然有序。int i,j; if(L.length=MAXSIZE) exit(OVERFLOW);/表满，不能插入 for(i=1;i=L.length&L.elemi-1=i;j-) L.elemj=L.elemj-1; L.elemi-1=x; L.length+;void Creatlist_sorted(Sqlist &L)/利用有序表插入算法建立一个有序表int i,num; ElemType x; L.length=0; pr

5、intf(请输入顺序表的长度：); scanf(%d,&num); for(i=1;i=num;i+) scanf(%d,&x); Insert(L,x); void Merger(Sqlist &p,Sqlist &r,Sqlist &c) /建立两个非递减有序表，并把它们合并成一个非递减有序表 ElemType *a,*b,i=0,j=0,k=0; a=&p.elem0; b=&r.elem0; c.length=p.length+r.length; while(ip.length&j=*b) c.elemk=*b;b+;k+;j+; else c.elemk=*a;a+;k+;i+; i

6、f(j=r.length) for(;kc.length;k+) c.elemk=*a;a+; else if(i=p.length) for(;kc.length;k+)c.elemk=*b;b+;void main()Sqlist L,M,N; int x,i,n; printf(1.建立一个顺序表.n); printf(2.以输出的形式对该顺序表遍历.n); printf(3.在顺序表中进行顺序查找某一元素x.n); printf(4.在顺序表的第i个位置上插入一个元素x.n); printf(5.删除顺序表中第i个元素.n); printf(6.利用有序表插入算法建立一个有序表.n);

7、 printf(7.建立两个非递减有序表，并把它们合并成一个非递减有序表.n); printf(8.输入一个元素x，把它插入到有序表中，使顺序表依然有序.n); while(1) printf(请选择：); scanf(%d,&n); switch(n) case 1:Creatlist(L);break; case 2:printlist(L);break; case 3:printf(请输入要查找的元素x:); scanf(%d,&x); Searchlist(L,x);break; case 4:printf(请输入要插入的位置i:); scanf(%d,&i); if(iL.lengt

8、h+1) printf(error!n);break; printf(请输入要插入的值x:); scanf(%d,&x); Inseri(L,i,x); printlist(L);break; case 5:printf(请输入要删去的元素的位置i:); scanf(%d,&i); if(iL.length) printf(error!n);break; Delete(L,i); printlist(L);break; case 6:Creatlist_sorted(L); printlist(L);break; case 7:Creatlist_sorted(L); Creatlist_so

9、rted(M); Merger(L,M,N); printlist(N);break; case 8:Creatlist_sorted(L); printf(请输入要插入的元素x:); scanf(%d,&x); Insert(L,x); printlist(L);break; 实验二 链式存储结构（一）-单向链表的有关操作 实验学时 3学时 背景知识：单向链表的插入、删除及应用。 目的要求 1掌握单向链表的存储特点及其实现。 2掌握单向链表的插入、删除算法及其应用算法的程序实现。 实验内容 1随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序）。 2遍历单向链表。 3把单向链表中元

10、素逆置（不允许申请新的结点空间）。 4在单向链表中删除所有的偶数元素结点。 5编写在非递减有序链表中插入一个元素使链表元素仍有序的函数，并利用该函数建立一个非递减有序单向链表。 6利用算法5建立两个非递减有序单向链表，然后合并成一个非递增链表。 7利用算法5建立两个非递减有序单向链表，然后合并成一个非递减链表。 8利用算法1建立的链表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数（尽量利用已知的存储空间）。* 9采用单向链表实现一元多项式的存储并实现两个多项式相加并输出结果。10在主函数中设计一个简单的菜单，分别调试上述算法。 *11综合训练：利用链表实现一个班级学生信息管理（

11、数据录入、插入、删除、排序、查找等，并能够实现将数据存储到文件中）/*单向链表的有关操作示例*/*类型定义及头文件部分,文件名为sllink.h*/ #include #include typedef int ElemType;/元素实际类型 typedef struct LNode ElemType data; struct LNode *next; LNode,*LinkList; /定义结点、指针类型名 /头插法建立无序链表 void CreateList(LinkList &L) LinkList p; ElemType e; L=(LinkList)malloc(sizeof(LNo

12、de); L-next=NULL; printf(头插法建立链表，以0结束n); scanf(%d,&e); while(e) p=(LinkList)malloc(sizeof(LNode); p-data=e; p-next=L-next; L-next=p; scanf(%d,&e); /*非递减有序单向链表L插入元素e序列仍有序*/ void Insert_Sort(LinkList &L,ElemType e) LinkList p,s; s=(LinkList)malloc(sizeof(LNode); s-data=e; p=L; while(p-next&p-next-data

13、next;/*查找插入位置*/ s-next=p-next; /*插入语句*p结点后插入*s结点*/ p-next=s; /*建立递增有序的单向链表*/ void Create_Sort(LinkList &L) ElemType e; L=(LinkList)malloc(sizeof(LNode); L-next=NULL; printf(建立有序表，输入任意个整型数据以0结束n); scanf(%d,&e); while(e) Insert_Sort(L,e); scanf(%d,&e); /*单向链表的遍历*/ void Traverse(LinkList L) LinkList p;

14、 printf(遍历链表); for(p=L-next;p;p=p-next) printf(%5d,p-data); printf(n); /*在单向链表删除元素e*/ void Delete(LinkList &L,ElemType e) LinkList p,q; p=L; q=L-next; while(q& q-data!=e)/查找元素的删除位置 p=q; q=q-next; if(!q) printf(nnot deleted);/*未找到元素e*/ else p-next=q-next;/*找到删除*/ free(q); /*单向链表的逆置*/ void exch(LinkLi

15、st &L) LinkList p,s; p=L-next; L-next=NULL; while(p) s=p; p=p-next; s-next=L-next; L-next=s; /*两个非递减有序单向链表合并后仍为非递减序列*/ void MergeIncrease(LinkList La,LinkList Lb,LinkList &Lc) LinkList p,q,s,rear; p=La-next; q=Lb-next; Lc=rear=La; free(Lb); while(p&q) if (p-datadata) s=p;p=p-next; else s=q;q=q-next;

16、 rear-next=s;/*较小元素插入表尾*/ rear=rear-next; if (p) rear-next=p; else rear-next=q实验三 迷宫问题求解实验学时 3学时 背景知识：栈的操作。 目的要求 1掌握栈的存储特点及其实现。 2掌握栈的出栈与入栈操作。实验内容： 以一个mxn的长方阵表示迷宫，0与1分别表示迷宫中的通路与障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。要求：首先实现一个顺序或链表做存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组(i, j, d)的形式输出，其中：(i, j)表示迷宫的坐

17、标，d表示走到下一坐标的方向。如对下面的迷宫，输出的一条通路为：（1，1，1），（1，2，2），（2，2，2），（3，2，3），（3，1，2），.迷宫约定， x方向为行方向，y方向为列方向，迷宫开始坐标(左上角)为（1,1）。 #include #include #include struct node int sign;/标识,0什么都不在,1在open中,2在closed中 int flag;/标志位 0/1,0可以走,1不可以走 int f,g,h;/判断函数 int x,y;/坐标 int old;/是否old节点,0非,1是;struct link node fnode; link

18、*next; link *pri;link *open,*closed,*bestnode,*successor,*p,*q,*r,*s;int maze_flag77= 0,1,0,0,0,0,0, 0,1,0,1,0,1,0, 0,1,0,0,0,1,0, 0,1,0,1,0,1,0, 0,0,0,1,0,0,0, 1,1,0,1,0,1,0, 0,0,0,0,0,1,0;/表示迷宫的数组,0可以走,1不可以走node maze77;int judge(node n)/判断函数,判断n节点是否可以走 if(n.flag=1) return(1); else return(0);void i

19、n_open(node n)/将n节点放入open表 p=open; while(p-next!=open) if(n.f=p-fnode.f) p-next-pri=(link *)malloc(sizeof(link); p-next-pri-pri=p; p=p-next; p-pri-next=p; p-pri-pri-next=p-pri; p=p-pri; p-fnode.flag=n.flag; p-fnode.f=n.f; p-fnode.g=n.g; p-fnode.h=n.h; p-fnode.x=n.x; p-fnode.y=n.y; p-fnode.old=n.old;

20、 p-fnode.sign=n.sign=1; else p=p-next; open-pri=(link *)malloc(sizeof(link); open-pri-pri=p; open-pri-next=open; p-next=open-pri; p=p-next; p-fnode.flag=n.flag; p-fnode.f=n.f; p-fnode.g=n.g; p-fnode.h=n.h; p-fnode.x=n.x; p-fnode.y=n.y; p-fnode.old=n.old; p-fnode.sign=n.sign=1;void out_open(node n)/将

21、n节点从open表中移出 p=open; while(p-next!=open) if(n.f=p-fnode.f) link *p1; p1=p-next; p-next=p-next-next; p-next-pri=p; free(p1); n.sign=0; else p=p-next; void in_closed(node n)/将n节点放入closed表 while(q-next!=closed) if(n.f=q-fnode.f) q-next-pri=(link *)malloc(sizeof(link); q-next-pri-pri=q; q=q-next; q-pri-

22、next=p; q-pri-pri-next=q-pri; q=q-pri; q-fnode.flag=n.flag; q-fnode.f=n.f; q-fnode.g=n.g; q-fnode.h=n.h; q-fnode.x=n.x; q-fnode.y=n.y; q-fnode.old=n.old; q-fnode.sign=n.sign=2; else q=q-next; closed-pri=(link *)malloc(sizeof(link); closed-pri-pri=q; closed-pri-next=closed; q-next=closed-pri; q=q-nex

23、t; q-fnode.flag=n.flag; q-fnode.f=n.f; q-fnode.g=n.g; q-fnode.h=n.h; q-fnode.x=n.x; q-fnode.y=n.y; q-fnode.old=n.old; q-fnode.sign=n.sign=2;void out_closed(node n)/将n节点从closed表中移出 q=closed; while(q-next!=closed) if(n.f=q-fnode.f) link *q1; q1=q-next; q-next=q-next-next; q-next-pri=q; free(q1); n.sig

24、n=0; else q=q-next; void in_bestnode(node n)/将n节点设为bestnode节点 while(r-next!=bestnode) if(n.f=r-fnode.f) r-next-pri=(link *)malloc(sizeof(link); r-next-pri-pri=r; r=r-next; r-pri-next=r; r-pri-pri-next=r-pri; r=r-pri; r-fnode.flag=n.flag; r-fnode.f=n.f; r-fnode.g=n.g; r-fnode.h=n.h; r-fnode.x=n.x; r-

25、fnode.y=n.y; r-fnode.old=n.old; else r=r-next; bestnode-pri=(link *)malloc(sizeof(link); bestnode-pri-pri=r; bestnode-pri-next=bestnode; r-next=bestnode-pri; r=r-next; r-fnode.flag=n.flag; r-fnode.f=n.f; r-fnode.g=n.g; r-fnode.h=n.h; r-fnode.x=n.x; r-fnode.y=n.y; r-fnode.old=n.old;void out_bestnode(

26、node n)/将n节点的bestnode去掉 r=bestnode; while(r-next!=bestnode) if(n.f=p-fnode.f) link *r1; r1=r-next; r-next=r-next-next; r-next-pri=r; free(r1); else r=r-next; void in_successor(node n)/将n节点设置为successor节点 s=successor; while(s-next!=successor) if(n.f=s-fnode.f) s-next-pri=(link *)malloc(sizeof(link); s

27、-next-pri-pri=s; s=p-next; s-pri-next=s; s-pri-pri-next=s-pri; s=s-pri; s-fnode.flag=n.flag; s-fnode.f=n.f; s-fnode.g=n.g; s-fnode.h=n.h; s-fnode.x=n.x; s-fnode.y=n.y; s-fnode.old=n.old; else s=s-next; successor-pri=(link *)malloc(sizeof(link); successor-pri-pri=s; successor-pri-next=successor; s-ne

28、xt=successor-pri; s=s-next; s-fnode.flag=n.flag; s-fnode.f=n.f; s-fnode.g=n.g; s-fnode.h=n.h; s-fnode.x=n.x; s-fnode.y=n.y; s-fnode.old=n.old;void out_successor(node n)/将n节点的successor去掉 s=successor; while(s-next!=successor) if(n.f=p-fnode.f) link *s1; s1=s-next; s-next=s-next-next; s-next-pri=s; fre

29、e(s1); else s=s-next; void print(link *n)/输出link类型的表n link *forprint; forprint=n; printf(the key is ); while(forprint-next!=n) printf(%d,%d)n,forprint-fnode.x,forprint-fnode.y);int main()/初始化部分/这部分的功能是将二维的整形数组赋值给node型的二维数组 int i=0,j=0; for(i=0;i7;i+) for(j=0;j7;j+) mazeij.x=i; mazeij.y=j; mazeij.fla

30、g=maze_flagij; if(mazeij.flag=0) mazeij.h=6-i+6-j; mazeij.sign=mazeij.f=mazeij.g=mazeij.old=0; else mazeij.h=-1; for(i=0;i7;i+)/输出迷宫示意图 for(j=0;jnext=open; open-pri=open; q=closed=(link *)malloc(sizeof(link); closed-next=closed; closed-pri=closed; r=bestnode=(link *)malloc(sizeof(link); bestnode-nex

31、t=bestnode; bestnode-pri=bestnode;/将第一个元素即(0,0)节点放入open表,开始算法 in_open(maze00); maze00.f=maze00.h; link *s2; s2=successor; if(open-next!=open)/open表为空时则失败退出 while(1) in_bestnode(open-fnode);/将open表的第一个元素放入bestnode中 in_closed(mazeopen-fnode.xopen-fnode.y);/将open表的第一个元素放入closed中 mazeopen-fnode.xopen-fn

32、ode.y.g+;/将open表的第一个元素的g值加一,表示已经走了一步 out_open(mazeopen-fnode.xopen-fnode.y);/将open表的第一个元素删除 if(bestnode-fnode.x=6&bestnode-fnode.y=6)/若bestnode是目标节点,则成功退出 printf(succes!nthen print the key:n); print(closed); break; else/若bestnode不是目标节点,则扩展其临近可以走的节点为successor if(i=0|j=0|i=6|j=6) if(i=0&j=0)/若为(0,0),则

33、判断右边与下边的元素 if(judge(mazeij+1)=0) in_successor(mazeij+1); if(judge(mazei+1j)=0) in_successor(mazei+1j); else if(i=0&j=6)/若为(0,6),则判断左边与下边的元素 if(judge(mazei-1j)=0) in_successor(mazei-1j); if(judge(mazei+1j)=0) in_successor(mazei+1j); else if(i=6&j=0)/若为(6,0),则判断左边与上边的元素 if(judge(mazei-1j)=0) in_succes

34、sor(mazei-1j); if(judge(mazeij-1)=0) in_successor(mazeij-1); else if(i=6&j=6)/若为(6,6),则判断左边与上边的元素 if(judge(mazei-1j)=0) in_successor(mazei-1j); if(judge(mazeij-1)=0) in_successor(mazeij-1); else if(i=0)/若为第一行的元素(不在角上),则判断左边,下边与右边 if(judge(mazeij+1)=0) in_successor(mazeij+1); if(judge(mazeij-1)=0) in

35、_successor(mazeij-1); if(judge(mazei+1j)=0) in_successor(mazei+1j); else if(i=6)/若为第七行的元素(不在角上),则判断左边,上边与右边 if(judge(mazeij+1)=0) in_successor(mazeij+1); if(judge(mazeij-1)=0) in_successor(mazeij-1); if(judge(mazei-1j)=0) in_successor(mazei-1j); else if(j=0)/若为第一列的元素(不在角上),则判断右边,下边与上边 if(judge(mazei

36、+1j)=0) in_successor(mazei+1j); if(judge(mazei-1j)=0) in_successor(mazei-1j); if(judge(mazeij+1)=0) in_successor(mazeij+1); else if(j=6)/若为第七列的元素(不在角上),则判断左边,上边与上边 if(judge(mazei+1j)=0) in_successor(mazei+1j); if(judge(mazei-1j)=0) in_successor(mazei-1j); if(judge(mazeij-1)=0) in_successor(mazeij-1); else/若为中将的元素,则判断四个方向的节点 if(judge(mazeij-1)=0) in_successor(mazeij-1); if(judge(mazeij+1)=0) in_successor(mazeij+1); if(judge(mazei-1j)=0) in_successor(mazei-1j