数据结构上机题答案
数据结构上机实验题目
实验一线性表的顺序存储结构
实验学时 2学时
背景知识:顺序表的插入、删除及应用。
目的要求：
1．掌握顺序存储结构的特点。
2．掌握顺序存储结构的常见算法。
实验内容
1．输入一组整型元素序列，建立顺序表。
2．实现该顺序表的遍历。
3．在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0。4．判断该顺序表中元素是否对称,对称返回1,否则返回0。
5．实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。
6．输入整型元素序列利用有序表插入算法建立一个有序表。
7．利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。
8. 利用该顺序结构实现循环队列的入队、出队操作。
8．编写一个主函数,调试上述算法。
#include
#include
#define OVERFLOW 0
#define MAXSIZE 100
typedef int ElemType;
typedef struct list
{ElemType elem[MAXSIZE];
int length;
}Sqlist;
void Creatlist(Sqlist &L)
{int i;
printf("请输入顺序表的长度："); //输入一组整型元素序列，建立一个顺序表。
scanf("%d",&L.length);
for(i=0;i scanf("%d",&L.elem[i]); } void printlist(Sqlist &L) //以输出的形式实现对该顺序表的遍历 {int i; for(i=0;i printf("%d ",L.elem[i]); printf("\n"); } void Searchlist(Sqlist &L,int x) //在顺序表中进行顺序查找某一元素x，查找成功则返回其存储位置i，否则返回错误信息 {int i,k=-1; for(i=0;i if(L.elem[i]==x){ k=i+1;printf("%d ",k);} if(k==-1) printf("error!"); printf("\n"); } void Inseri(Sqlist &L,int i,int x) //在顺序表的第i个位置上插入一个元素x {int j; for(j=L.length;j>=i;j--) L.elem[j]=L.elem[j-1]; L.elem[j]=x; L.length++; } void Delete(Sqlist &L,int i) //删除顺序表中第i个元素 {int j; for(j=i;j L.elem[j-1]=L.elem[j]; 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.elem[i-1]<=x;i++); for(j=L.length;j>=i;j--) L.elem[j]=L.elem[j-1]; L.elem[i-1]=x; L.length++; } void Creatlist_sorted(Sqlist &L) //利用有序表插入算法建立一个有序表{int i,num; ElemType x; L.length=0; printf("请输入顺序表的长度："); 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.elem[0]; b=&r.elem[0]; c.length=p.length+r.length; while(i {if(*a>=*b) {c.elem[k]=*b;b++;k++;j++;} else {c.elem[k]=*a;a++;k++;i++;} } if(j==r.length) for(;k {c.elem[k]=*a;a++; } else if(i==p.length) for(;k {c.elem[k]=*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"); 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(i<1||i>L.length+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(i<1||i>L.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_sorted(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．把单向链表中元素逆置（不允许申请新的结点空间）。 4．在单向链表中删除所有的偶数元素结点。 5．编写在非递减有序链表中插入一个元素使链表元素仍有序的函数，并利用该函数建立一个非递减有序单向链表。 6．利用算法5建立两个非递减有序单向链表，然后合并成一个非递增链表。 7．利用算法5建立两个非递减有序单向链表，然后合并成一个非递减链表。 8．利用算法1建立的链表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数（尽量利用已知的存储空间）。 * 9．采用单向链表实现一元多项式的存储并实现两个多项式相加并输出结果。 10．在主函数中设计一个简单的菜单，分别调试上述算法。 *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(LNode)); 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<=e) p=p->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; 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(LinkList &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->data else {s=q;q=q->next; } 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)表示迷宫的坐标，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 *next; link *pri; }; link *open,*closed,*bestnode,*successor,*p,*q,*r,*s; int maze_flag[7][7]={ {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 maze[7][7]; int judge(node n)//判断函数,判断n节点是否可以走 { if(n.flag==1) return(1); else return(0); } void in_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; 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)//将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->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->next; 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.sign=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->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(node n)//将n节点的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->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->next=successor->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; } 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; free(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;i<7;i++) for(j=0;j<7;j++) { maze[i][j].x=i; maze[i][j].y=j; maze[i][j].flag=maze_flag[i][j]; if(maze[i][j].flag==0) { maze[i][j].h=6-i+6-j; maze[i][j].sign=maze[i][j].f=maze[i][j].g=maze[i][j].old=0; } else maze[i][j].h=-1; } for(i=0;i<7;i++)//输出迷宫示意图 { for(j=0;j<7;j++) { printf("%2d",maze_flag[i][j]); } printf("\n"); } //这部分的功能是将open,closed,bestnode表初始化,都置为空表 p=open=(link *)malloc(sizeof(link)); open->next=open; open->pri=open; q=closed=(link *)malloc(sizeof(link)); closed->next=closed; closed->pri=closed; r=bestnode=(link *)malloc(sizeof(link)); bestnode->next=bestnode; bestnode->pri=bestnode; //将第一个元素即(0,0)节点放入open表,开始算法 in_open(maze[0][0]); maze[0][0].f=maze[0][0].h; link *s2; s2=successor; if(open->next!=open)//open表为空时则失败退出 { while(1) { in_bestnode(open->fnode);//将open表的第一个元素放入bestnode中 in_closed(maze[open->fnode.x][open->fnode.y]);//将open表的第一个元素放入closed中maze[open->fnode.x][open->fnode.y].g++;//将open表的第一个元素的g值加一,表示已经 走了一步 out_open(maze[open->fnode.x][open->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),则判断右边和下边的元素 { if(judge(maze[i][j+1])==0) in_successor(maze[i][j+1]); if(judge(maze[i+1][j])==0) in_successor(maze[i+1][j]); } else if(i==0&&j==6)//若为(0,6),则判断左边和下边的元素 { if(judge(maze[i-1][j])==0) in_successor(maze[i-1][j]); if(judge(maze[i+1][j])==0) in_successor(maze[i+1][j]); } else if(i==6&&j==0)//若为(6,0),则判断左边和上边的元素 { if(judge(maze[i-1][j])==0) in_successor(maze[i-1][j]); if(judge(maze[i][j-1])==0) in_successor(maze[i][j-1]); } else if(i==6&&j==6)//若为(6,6),则判断左边和上边的元素 { if(judge(maze[i-1][j])==0) in_successor(maze[i-1][j]); if(judge(maze[i][j-1])==0) in_successor(maze[i][j-1]); } else if(i==0)//若为第一行的元素(不在角上),则判断左边,下边和右边 { if(judge(maze[i][j+1])==0) in_successor(maze[i][j+1]); if(judge(maze[i][j-1])==0) in_successor(maze[i][j-1]); if(judge(maze[i+1][j])==0) in_successor(maze[i+1][j]); } else if(i==6)//若为第七行的元素(不在角上),则判断左边,上边和右边{ if(judge(maze[i][j+1])==0) in_successor(maze[i][j+1]); if(judge(maze[i][j-1])==0) in_successor(maze[i][j-1]); if(judge(maze[i-1][j])==0) in_successor(maze[i-1][j]); } else if(j==0)//若为第一列的元素(不在角上),则判断右边,下边和上边{ if(judge(maze[i+1][j])==0) in_successor(maze[i+1][j]); if(judge(maze[i-1][j])==0) in_successor(maze[i-1][j]); if(judge(maze[i][j+1])==0) in_successor(maze[i][j+1]); } else if(j==6)//若为第七列的元素(不在角上),则判断左边,上边和上边{ if(judge(maze[i+1][j])==0) in_successor(maze[i+1][j]); if(judge(maze[i-1][j])==0) in_successor(maze[i-1][j]); if(judge(maze[i][j-1])==0) in_successor(maze[i][j-1]); } } else//若为中将的元素,则判断四个方向的节点 { if(judge(maze[i][j-1])==0) in_successor(maze[i][j-1]); if(judge(maze[i][j+1])==0) in_successor(maze[i][j+1]); if(judge(maze[i-1][j])==0) in_successor(maze[i-1][j]); if(judge(maze[i+1][j])==0) in_successor(maze[i+1][j]); } while(s2->next!=successor)//对所有的successor节点进行下列操作 { maze[s2->fnode.x][s2->fnode.y].g=bestnode->fnode.g+bestnode->fnode.h;//计算g(suc)=g(bes)+h(bes,suc) if(s2->fnode.sign==1)//若在open表中,则置为old,记下较小的g,并从open表中移出,放入closed表中 { s2->fnode.old=1; if(s2->fnode.g { maze[s2->fnode.x][s2->fnode.y].g=s2->fnode.g; maze[s2->fnode.x][s2->fnode.y].f=maze[s2->fnode.x][s2->fnode.y].g+maze[s2->fnode.x][s2->fn ode.y].h; out_open(maze[s2->fnode.x][s2->fnode.y]); in_closed(maze[s2->fnode.x][s2->fnode.y]); maze[s2->fnode.x][s2->fnode.y].old=0; } else continue; } else if(s2->fnode.sign==2)//若在closed表中,则置为old,记下较小的g,并将old从closed 表中移出,将较小的g的节点放入closed表中 { s2->fnode.old=1; if(s2->fnode.g { maze[s2->fnode.x][s2->fnode.y].g=s2->fnode.g; maze[s2->fnode.x][s2->fnode.y].f=maze[s2->fnode.x][s2->fnode.y].g+maze[s2->fnode.x][s2->fn ode.y].h; out_closed(maze[s2->fnode.x][s2->fnode.y]); in_closed(maze[s2->fnode.x][s2->fnode.y]); maze[s2->fnode.x][s2->fnode.y].old=0; } else continue; } else//若即不再open表中也不在closed表中,则将此节点放入open表中,并计算此节点的f值 { in_open(maze[s2->fnode.x][s2->fnode.y]); maze[s2->fnode.x][s2->fnode.y].f=maze[s2->fnode.x][s2->fnode.y].g+maze[s2->fnode.x][s2->fn ode.y].h; } s2=s2->next; } s2=successor; } } else printf("error!!This maze does not have the answer!"); return(0); } 实验内容： 以一个m × n的长方阵表示迷宫，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）。 基本相同；#include #include #include typedef struct QElemType { int x,y; struct QElemType *parent;//用于存储节点的前一个节点 } QElemType; typedef struct QNode//队列节点 { QElemType *data; struct QNode *next; } QNode, *QueuePtr; typedef struct 数据结构上机实验报告 学院：电子工程学院 专业：信息对抗技术 姓名： 学号： 教师：饶鲜日期： 目录 实验一线性表................................................. - 4 - 一、实验目的................................................ - 4 - 二、实验代码................................................ - 4 - 三、实验结果............................................... - 14 - 四、个人思路............................................... - 15 -实验二栈和队列.............................................. - 15 - 一、实验目的............................................... - 15 - 二、实验代码............................................... - 16 - 三、实验结果............................................... - 24 - 四、个人思路............................................... - 25 -实验三数组.................................................. - 26 - 一、实验目的............................................... - 26 - 二、实验代码............................................... - 26 - 三、实验结果............................................... - 28 - 四、个人思路............................................... - 28 -实验四树.................................................... - 29 - 一、实验目的............................................... - 29 - 二、实验代码............................................... - 29 - 华农数据结构上机实验答案 数据结构上机答案 1.1顺序线性表的基本操作 #include { newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*size of(ElemType)); L.elem=newbase; L.listsize+=LISTINCREMENT; } q=&(L.elem[i-1]); for(p=&(L.elem[L.length-1]);p>=q;--p) *(p+1)=*p; *q=e; ++L.length; return OK; } int ListDelete_Sq(SqList &L,int i,int &e) { ElemType *q,*p; if(i<1||i>L.length) return ERROR; p=&(L.elem[i-1]); e=*p; q=L.elem+L.length-1; for(++p;p<=q;p++) *(p-1)=*p; L.length--; return OK; } int main() { SqList T; int a,i; ElemType e,x; if(InitList_Sq(T)) { printf("A Sequence List Has Created.\n"); } while(1) { printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n"); scanf("%d",&a); switch(a) 数据结构能力测试集训题目 线性表 1.实现顺序表各种基本运算的算法，并基础上设计一个主程序完成如下功能： (1)初始化顺序表L； (2)采用尾插法依次插入a，b，c，d，e； （3）输出顺序表L； （4）输出顺序表L的长度； （5）判断顺序表L是否为空； （6）输出顺序表L的第3个元素； （7）输出元素a的位置； （8）在第四个元素位置上插入f元素； （9）输出顺序表L； （10）删除顺序表L的第3个元素； （11）输出顺序表L； （12）释放顺序表L。 2.实现单链表各种基本运算的算法，并基础上设计一个主程序完成如下功能： (1)初始化单链表h； (2)采用尾插法依次插入a，b，c，d，e； （3）输出单链表h； （4）输出单链表h的长度； （5）判断单链表h是否为空； （6）输出单链表h的第3个元素； （7）输出元素a的位置； （8）在第四个元素位置上插入f元素； （9）输出单链表h； （10）删除单链表h的第3个元素； （11）输出单链表h； （12）释放单链表h； 3.实现双链表各种基本运算的算法，并基础上设计一个主程序完成如下功能： (1)初始化双链表h； (2)采用尾插法依次插入a，b，c，d，e； （3）输出双链表h； （4）输出双链表h的长度； （5）判断双链表h是否为空； （6）输出双链表h的第3个元素； （7）输出元素a的位置； （8）在第四个元素位置上插入f元素； （9）输出双链表h； （10）删除双链表h的第3个元素； （11）输出双链表h； （12）释放双链表h； 4.实现循环单链表各种基本运算的算法，并基础上设计一个主程序完成如下功 能： (1)初始化循环单链表h； (2)采用尾插法依次插入a，b，c，d，e； （3）输出循环单链表h； （4）输出循环单链表h的长度； （5）判断循环单链表h是否为空； （6）输出循环单链表h的第3个元素； （7）输出元素a的位置； （8）在第四个元素位置上插入f元素； （9）输出循环单链表h； （10）删除循环单链表h的第3个元素； （11）输出循环单链表h； （12）释放循环单链表h； 5.实现循环单链表各种基本运算的算法，并基础上设计一个主程序完成如下功 能： (1)初始化循环双链表h； (2)采用尾插法依次插入a，b，c，d，e； （3）输出循环双链表h； （4）输出循环双链表h的长度； （5）判断循环双链表h是否为空； （6）输出循环双链表h的第3个元素； （7）输出元素a的位置； （8）在第四个元素位置上插入f元素； （9）输出循环双链表h； （10）删除循环双链表h的第3个元素； （11）输出循环双链表h； （12）释放循环双链表h； 6.求集合的并，交，差运算（用有序单链表表示） 栈和队列 7.实现顺序栈各种基本运算的算法，编写一个程序实现顺序栈的各种基本运 算，并在此基础上设计一个主程序完成以下各种功能： （1）初始化栈s （2）判断栈s是否非空 （3）依次进栈元素a，b，c，d，e （4）判断栈s是否非空 （5）输出栈长度 （6）输出从栈顶到栈底元素 数据结构实验报告全集 实验一线性表基本操作和简单程序 1．实验目的 （1）掌握使用Visual C++ 6.0上机调试程序的基本方法； （2）掌握线性表的基本操作：初始化、插入、删除、取数据元素等运算在顺序存储结构和链表存储结构上的程序设计方法。 2．实验要求 （1）认真阅读和掌握和本实验相关的教材内容。 （2）认真阅读和掌握本章相关内容的程序。 （3）上机运行程序。 （4）保存和打印出程序的运行结果，并结合程序进行分析。 （5）按照你对线性表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果 实验代码： 1）头文件模块 #include iostream.h>//头文件 #include nodetype *create()//建立单链表，由用户输入各结点data域之值，//以0表示输入结束 { elemtype d;//定义数据元素d nodetype *h=NULL,*s,*t;//定义结点指针 int i=1; cout<<"建立一个单链表"< 习题二 ⒉１描述以下四个概念的区别：头指针变量，头指针，头结点，首结点（第一个结点）。解：头指针变量和头指针是指向链表中第一个结点（头结点或首结点）的指针；在首结点之前附设一个结点称为头结点；首结点是指链表中存储线性表中第一个数据元素的结点。若单链表中附设头结点，则不管线性表是否为空，头指针均不为空，否则表示空表的链表的头指针为空。 2.2简述线性表的两种存储结构有哪些主要优缺点及各自使用的场合。 解：顺序存储是按索引直接存储数据元素，方便灵活，效率高，但插入、删除操作将引起元素移动，降低了效率；而链式存储的元素存储采用动态分配，利用率高，但须增设表示结点之间有序关系的指针域，存取数据元素不如顺序存储方便，但结点的插入和删除十分简单。顺序存储适用于线性表中元素数量基本稳定，且很少进行插入和删除，但要求以最快的速度存取线性表中的元素的情况；而链式存储适用于频繁进行元素动态插入或删除操作的场合。 2.3 在头结点为h的单链表中，把值为b的结点s插入到值为a的结点之前，若不存在a，就把结点s插入到表尾。 Void insert(Lnode *h,int a,int b) {Lnode *p,*q,*s; s=(Lnode*)malloc(sizeof(Lnode)); s->data=b; p=h->next; while(p->data!=a&&p->next!=NULL) {q=p; p=p->next; } if (p->data==a) {q->next=s; s->next=p;} else {p->next=s; s->next=NULL; } } 2.4 设计一个算法将一个带头结点的单链表A分解成两个带头结点的单链表A和B，使A中含有原链表中序号为奇数的元素，而B中含有原链表中序号为偶数的元素，并且保持元素原有的相对顺序。 Lnode *cf(Lnode *ha) {Lnode *p,*q,*s,*hb; int t; p=ha->next; q=ha; t=0; hb=(Lnode*)malloc(sizeof(Lnode)); s=hb; while(p->next!=NULL) {if (t==0) {q=p;p=p->next;t=1;} else {q->next=p->next; p->next=s->next; s->next=p; s=p; p=p->next; t=0; } } s->next=NULL; return (hb); } 《数据结构实验指导书》答案 实验一： 1、请编写函数int fun(int *a, int *b),函数的功能是判断两个指针a和b所指存储单 元的值的符号是否相同；若相同函数返回1，否则返回0。这两个存储单元中的值都不为0。在主函数中输入2个整数、调用函数fun、输出结果。 #include 数fun、输出结果。 #define N 10 #include 注意事项1. 考试时间2小时，13：00-15：00 2. 题目4选2 3. 所有题目均使用标准输入和标准输出3. 只提交源程序，文件后缀名只能是.C或.CPP 4. 源文件大小不能超过10K，否则会被当作恶意提交而扣分5. 严格按照题目要求输出，去掉不需要的提示信息或调试信息6. 在程序中不要使用fflush(stdin)函数，否则会导致结果错误另外注意：本次是模拟测试，上机时间是4个小时，我们考试时间从14点开始到17点30分结束。同学视自己的能力，能做几道做几道。 哈夫曼树 时间限制: 100 second 内存限制: 100 Kb 描述 构造哈夫曼树（最优二叉树） 输入 输入n个结点每个结点的权值 输出 构造哈夫曼树（是最优二叉树）得到每个结点的哈夫曼编码 输入样例 23 186 64 13 22 32 103 21 15 47 57 1 5 32 20 57 63 15 1 48 51 80 23 8 输出样例 1( 186):00 2( 64):1001 3( 13):101100 4( 22):110010 5( 32):11100 6( 103):011 7( 21):110001 8( 15):101101 9( 47):11010 10( 57):0101 11( 1):101111000 12( 5):10111101 13( 32):11101 14( 20):110000 15( 57):1010 16( 63):1000 17( 15):101110 18( 1):101111001 19( 48):11011 20( 51):0100 21( 80):1111 22( 23):110011 23( 8):1011111 提示 输入第一行是结点数23 第二行是这几个结点的权值输出格式为结点号（权值）：哈夫曼编码 数据结构实验报告 一．顺序表 要求：实现顺序表的初始化、在指定位置插入和删除元素。 算法思路：线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。顺序表的初始化操作就是为顺序表分配一个预定义大小的空间，并将线性表的当前长度设为“0”。线性表的插入操作是在线性表的第i-1个数据元素和第i个元素之间插入新的数据元素，使得长度为n的线性表变成长度为n+1的线性表，而删除恰好相反长度变为n-1的线性表，而且删除点后面的元素要往前移动一个位。 程序代码： #include for(i=0;i 数据结构上机实验题目 实验一线性表的顺序存储结构 实验学时 2学时 背景知识:顺序表的插入、删除及应用。 目的要求： 1．掌握顺序存储结构的特点。 2．掌握顺序存储结构的常见算法。 实验容 1．输入一组整型元素序列，建立顺序表。 2．实现该顺序表的遍历。 3．在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0。4．判断该顺序表中元素是否对称,对称返回1,否则返回0。 5．实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。 6．输入整型元素序列利用有序表插入算法建立一个有序表。 7．利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。 8. 利用该顺序结构实现循环队列的入队、出队操作。 8．编写一个主函数,调试上述算法。 #include #define OVERFLOW 0 #define MAXSIZE 100 typedef int ElemType; typedef struct list {ElemType elem[MAXSIZE]; int length; }Sqlist; void Creatlist(Sqlist &L) {int i; printf("请输入顺序表的长度："); //输入一组整型元素序列，建立一个顺序表。 scanf("%d",&L.length); for(i=0;i 《数据结构》上机练习题 1、设有两个有序序列，利用归并排序将它们排成有序表，并输出。 2、设有一有序序列，从键盘输入一个数，判别是否在序列中，如果在输出“YSE”；否则，将它插入到序列中使它仍然有序，并输出排序后的序列。 3、设有一有序序列，从键盘输入一个数，判别是否在序列中，如果不在，则输出“NO”，否则，将它从序列中删除它，并输出删除后的序列。 4、从键盘输入一组任意数据，建立一个有序链表，并从链头开始输出该链，使输出结果是有序的。 5、从键盘输入一组任意数据，建立一个包含所有输入数据的单向循环链表，并从链表的任意开始，依次输出该链表中的所有结点。 10、设有一个链表，（自己建立，数据从键盘输入），再从键盘输入一个数，判别是否在链表中，如果不在，则输出“NO“，否则，将它从链表中删除，并输出删除后的链表。 11、设有一个链表，（自己建立，数据从键盘输入），再从键盘输入一个数，判别是否在链表中，如果在输出“YSE”，否则，将它从插入到链头，并输出插入后的链表。 12、设有一个链表，（自己建立，数据从键盘输入），再从键盘输入一个数，判别是否在链表中，如果在输出“YSE”，否则，将它从插入到链尾，并输出插入后的链表。 13、编写栈的压栈push、弹栈pop函数，从键盘输入一组数据，逐个元素压入堆栈，然后再逐个从栈中弹出它们并输出。 14、编写栈的压栈push、弹栈pop函数，用它判别（）的匹配问题。 15、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出二叉树中序遍历的结果。 16、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出二叉树先序遍历的结果。 17、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出二叉树后序遍历的结果。 18、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出二叉树的总结点数。 19、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出二叉树叶子结点数。 20、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出此二叉树的高度。 21、给出一个无向图的邻接矩阵，输出各个顶点的度。 22、给出一个有向图的邻接矩阵，输出各个顶点的入度与出度。 23、输入一个有序序列，利用折半查找来查找一个数是否在序列中，如在，则输出其位置，否则输出“NO”。 24、用插入排序方法对一组数据进行排序，并输出每趟排序的结果。 25、用选择排序方法对一组数据进行排序，并输出每趟排序的结果。 26、用希尔（SHELL）排序方法对一组数据进行排序，并输出每趟排序的结果。 27、用快速排序方法对一组数据进行排序，并输出每趟排序的结果。． 答案： 1. #include 实习一： 1、编写一个读入一个字符串，把它存入一个链表，并按相反的次序打印的程序。 2、设有一个单位的人员工资有如下信息：name、department、 base pay、allowance、total。现从键盘输入一组人员工资数据并将它们存储到名为paydata的文件中；再从paydata取出工资数据并给每个人的base pay增加100元，增加后将工资数据显示于屏幕(每行1人)。请编写能够完成上述工作的程序。 代码如下： 1.#include 《数据结构》课程上机实验指导书 实验一 【实验名称】顺序表的基本算法 【实验目的】 创建一个顺序表，掌握线性表顺序存储的特点。设计和验证顺序表的查找、插入、删除算法。 【实验要求】 （1）从键盘读入一组整数，按输入顺序形成顺序表。并将创建好的顺序表元素依次打印在屏幕上。 设计一个带选择菜单的主函数，菜单中具备任意选择删除、插入、查找数据元素（2）的功能。 当选择删除功能时，从键盘读入欲删除的元素位置或元素值，按指定方式删除；3（）当选择插入功能时，从键盘读入新元素值和被插入位置，在指定位置插入；当选择查找功能时，从键盘读入欲查找的元素值，返回其位置序号。 （4）每种操作结束后，都能在屏幕上打印出此时顺序表元素的遍历结果。 【实验步骤】、实验前先写好算法。1 上机编写程序。2、编译。3、调试。4、 综合实例！，2-62-8！带菜单的主函数参考书上2.5，，，书上参考算法例程：2-12-42-5注意：顺序表的结构体！typedef struct { datatype items[listsize]; int length; }SpList; 实验二 【实验名称】单链表的基本算法 【实验目的】 创建一个单链表，掌握线性表链式存储的特点。设计和验证链表的查找、插入、删除、求表长的算法。【实验要求】 （1）从键盘读入一组整数，按输入顺序形成单链表。并将创建好的单链表元素依次打印在屏幕上。（注意：选择头插法或者尾插法！） 设计一个带选择功能菜单的主函数，菜单中至少具备任意选择删除、插入、查找（2）数据元素，和求单链表表长等几项功能。 当选择删除功能时，从键盘读入欲删除的元素位置，按指定位置删除；当选择插）（3入功能时，从键盘读入新元素值和被插入位置，在指定位置插入；当选择查找功能时，从键盘读入欲查找的元素值，返回其位置序号；当选择求表长功能时，返回该单链表表长的数值。 （4）每种操作结束后，都能在屏幕上打印出此时单链表元素的遍历结果。 【实验步骤】、实验前先写好算法。1 、上机编写程序。2 编译。3、调试。4、 综合实例！！带菜单的主函数参考书上，2-132-15，2-172.5，，书上参考算法例程：2-102-12 另外，注意，指针的初始化！指针的操作必须谨慎！链表的结构体如下：typedef struct Node { Datatype ch; struct Node *next; }LNode, *Pnode, *Linklist; 实验三 数据结构上机考试试题（C++语言版） 考试要求：本次考试共列考核试题4大题，考生可以在所列4个考核试题中任选3个小题（即可能只属于2个大题），作为上机考核试题。 考核原则：所选题目在上机编程调试通过后即为考核通过。监考教师依据学生编程及调试通过与否情况给予考核成绩。 考核成绩评分标准： 所选3个题目全部编写出程序并调试通过：优 所选3个题目全部编写出程序，但只有2个上机调试通过：良 所选3个题目全部编写出程序，但只有1个上机调试通过：及格 所选3个题目全部编写出程序但都没有上机调试通过，或没有编写出全部程序：不及格。考核时间：2小时。 考核试题： 1、建立一个顺序方式存储的线性表，向表中输入若干元素后进行以下操作： （1）向线性表的表头、表尾或合适位置插入元素 （2）对线性表按升序或降序输出 2、建立一个动态链接方式存储的线性表，向表中输入若干元素后进行以下操作： （1）从单链表中查找指定元素 （2）返回单链表中指定序号的结点值 3、建立一个动态链接结构存储的二叉树，向这棵二叉树进行以下操作： （1）按任中序遍历次序输出二叉树中的所有结点 （2）求二叉树的叶子数 4、编写一个对整型数组A[n+1]中的A[1]至A[n]元素进行选择排序的算法，使得首先从待排序区间中选择出一个最大值并同最后一个元素交换，再从待排序区间中选择出一个最小值并同最第一个元素交换，反复进行直到待排序区间中元素的个数不超过1为止。 #include<> #include<> #include"" //初始化线性表 void InitList(LinearList& L, int ms) { =new ElemType[ms]; if(! { cerr<<"Memory allocation failure!"< 1．将顺序表逆置，要求用最少的附加空间。 参考答案 #include 北科大数据结构上机题代码 《数据结构》上机题 1、输入数据建立单链表，并求相邻两节点data值之和为最大的第一节点。 例如输入：26473 0，建立： 所求结果=4 程序结构： 类型说明； 建表函数：Creatlist(L); 求值函数：Adjmax(L); main( ) { 变量说明； 调用Creatlist(L)建表；调用Adjmax(L)求值； 打印数据；释放链表空间； Y 继续？ N 停止 } 上机题1： #include #include typedef int datatype; //设当前数据元素为整型 typedef struct node //节点类型 { datatype data; //节点的数据域 struct node *next; //节点的后继指针域 }Linknode,*Link; //linknode为节点说明符，link为节点指针说明符 Link Createlist() //创建单链表的算法 { int a,c;float b; Link H,P,r; //H,P,r分别为表头，新节点和表尾节点指针 H=(Link)malloc(sizeof(Linknode)); //建立头节点 r=H; do { c=(fflush(stdin),scanf(\ //判断输入的是否是整数 a=(int)b; if(c!=1||a!=b||a>-2^16||a-2^16||adata=a; //存入数据 r->next=P; //新节点链入表尾 r=P; do { c=(fflush(stdin),scanf(\ //判断输入的是否是 整数 a=(int)b; if(c!=1||a!=b||a>-2^16||a-2^16||anext=NULL; //将尾节点的指针域置空 return(H); //返回已创建的头节点 } Link Adjmax(Link H) //求链表中相邻两节点data值之和为最大的第一节点的指针 的算法 { Link p,p1,q; int i,j; p=p1=H->next; if(p1==NULL) return(p1); //表空返回 q=p->next; if(q==NULL) return(p1); //表长=1时返回 i=p->data+q->data; //相邻两节点data值之和 while(q->next) { p=q;q=q->next; //取下一对相邻节点的指针 j=p->data+q->data; if(j>i) 实验报告 （2015 / 2016学年第二学期） 课程名称数据结构A 实验名称内排序算法的实现以及性能比较 实验时间2016 年 5 月26 日 指导单位计算机科学与技术系 指导教师骆健 学生姓名耿宙班级学号B14111615 学院(系) 管理学院专业信息管理与信息系统 —— 实习题名:内排序算法的实现及性能比较 班级 B141116 姓名耿宙学号 B14111615 日期2016.05.26 一、问题描述 验证教材的各种内排序算法，分析各种排序算法的时间复杂度；改进教材中的快速排序算法，使得当子集合小于10个元素师改用直接插入排序；使用随即数发生器产生大数据集合，运行上述各排序算法，使用系统时钟测量各算法所需的实际时间，并进行比较。系统时钟包含在头文件“time.h”中。 二、概要设计 文件Sort.cpp中包括了简单选择排序SelectSort()，直接插入排序InsertSort()，冒泡排序BubbleSort()，两路合并排序Merge()，快速排序QuickSort()以及改进的快速排序GQuickSort()六个内排序算法函数。主主函数main的代码如下图所示： 三、详细设计 1.类和类的层次设计 在此次程序的设计中没有进行类的定义。程序的主要设计是使用各种内排序算法对随机 生成的数列进行排列，并进行性能的比较，除此之外还对快速排序进行了改进。下图为主函 数main的流程图： —— main() 2.核心算法 1)简单选择排序： 简单选择排序的基本思想是：第1趟，在待排序记录r[1]~r[n]中选出最小的记录，将它与r[1]交换；第2趟，在待排序记录r[2]~r[n]中选出最小的记录，将它与r[2]交换；以此类推，第i趟在待排序记录r[i]~r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到 《数据结构简明教程》练习题及参考答案 练习题1 1. 单项选择题 （1）线性结构中数据元素之间是（）关系。 A.一对多 B.多对多 C.多对一 D.一对一 答：D （2）数据结构中与所使用的计算机无关的是数据的（）结构。 A.存储 B.物理 C.逻辑 D.物理和存储 答：C （3）算法分析的目的是（）。 A.找出数据结构的合理性 B.研究算法中的输入和输出的关系 C.分析算法的效率以求改进 D.分析算法的易懂性和文档性 答：C （4）算法分析的两个主要方面是（）。 A.空间复杂性和时间复杂性 B.正确性和简明性 C.可读性和文档性 D.数据复杂性和程序复杂性 答：A （5）计算机算法指的是（）。 A.计算方法 B. 排序方法 C.求解问题的有限运算序列 D.调度方法 答：C （6）计算机算法必须具备输入、输出和（）等5个特性。 A.可行性、可移植性和可扩充性 B.可行性、确定性和有穷性 C.确定性、有穷性和稳定性 D.易读性、稳定性和安全性 答：B 2. 填空题 （1）数据结构包括数据的①、数据的②和数据的③这三个方面的内容。 答：①逻辑结构②存储结构③运算 （2）数据结构按逻辑结构可分为两大类，它们分别是①和②。 答：①线性结构②非线性结构 （3）数据结构被形式地定义为（D,R），其中D是①的有限集合，R是D上的②有限集合。 答：①数据元素 ②关系 （4）在线性结构中，第一个结点 ① 前驱结点，其余每个结点有且只有1个前驱结点；最后一个结点 ② 后继结点，其余每个结点有且只有1个后继结点。 答：①没有 ②没有 （5）在树形结构中，树根结点没有 ① 结点，其余每个结点有且只有 ② 个前驱结点；叶子结点没有 ③ 结点，其余每个结点的后继结点数可以是 ④ 。 答：①前驱 ②1 ③后继 ④任意多个 （6）在图形结构中，每个结点的前驱结点数和后继结点数可以是（ ）。 答：任意多个 （7）数据的存储结构主要有四种，它们分别是 ① 、 ② 、 ③ 和 ④ 存储结构。 答：①顺序 ②链式 ③索引 ④哈希 （8）一个算法的效率可分为 ① 效率和 ② 效率。 答：①时间 ②空间 3. 简答题 （1）数据结构和数据类型两个概念之间有区别吗？ 答：简单地说，数据结构定义了一组按某些关系结合在一起的数组元素的集合。数据类型不仅定义了一组数据元素，而且还在其上定义了一组操作。 （2）简述线性结构、树形结构和图形结构的不同点。 答：线性结构反映结点间的逻辑关系是一对一的，树形线性结构反映结点间的逻辑关系是一对多的，图在结构反映结点间的逻辑关系是多对多的。 （3）设有采用二元组表示的数据逻辑结构S=(D,R)，其中D={a ,b ,…,i }，R={(a ,b ),(a ,c ),(c ,d ),(c ,f ),(f ,h ),(d ,e ),(f ,g ),(h ,i )}，问相对于关系R ，哪些结点是开始结点，哪些结点是终端结点？ 答：该逻辑结构为树形结构，其中a 结点没有前驱结点，称为根结点，b 、e 、g 、i 结点没有后继结点，是终端结点，也称为叶子结点。 （4）以下各函数是算法中语句的执行频度，n 为问题规模，给出对应的时间复杂度： T 1(n )=n log 2n -1000log 2n T 2(n )=3log 2n -1000log 2n T 3(n )=n 2-1000log 2n T 4(n )=2n log 2n -1000log 2n 答：T 1(n )=O(n log 2n )，T 2(n )=O( )，T 3(n )=O(n 2)，T 4(n )=O(n log 2n )。 （5）分析下面程序段中循环语句的执行次数。 int j=0,s=0,n=100; do { j=j+1; s=s+10*j; } while (j数据结构上机实验报告
华农数据结构上机实验答案
数据结构能力测试集训题目
数据结构实验报告全集
数据结构上机例题及答案
数据结构上机实验答案
数据结构上机考试题
数据结构上机实验报告
经典数据结构上机题_答案解析
数据结构上机考试(含答案)
数据结构上机答案(c语言版)
数据结构上机实验指导
数据结构上机考试试题
大连理工大学数据结构(一)上机作业答案——张老师
北科大数据结构上机题代码
南邮数据结构上机实验四内排序算法的实现以及性能比较
数据结构课程课后习题答案