经典数据结构上机题—答案
数据结构上机实验题目
实验一线性表的顺序存储结构
实验学时 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 数据结构实验指导书 一、实验目的 《数据结构》是计算机学科一门重要的专业基础课程，也是计算机学科的一门核心课程。本课程较为系统地论述了软件设计中常用的数据结构以及相应的存储结构与实现算法，并做了相应的性能分析和比较，课程内容丰富，理论系统。本课程的学习将为后续课程的学习以及软件设计水平的提高打下良好的基础。 由于以下原因，使得掌握这门课程具有较大的难度： 1）理论艰深，方法灵活，给学习带来困难； 2）内容丰富，涉及的知识较多，学习有一定的难度； 3）侧重于知识的实际应用，要求学生有较好的思维以及较强的分析和解决问题的能力，因而加大了学习的难度； 根据《数据结构》课程本身的特性，通过实验实践内容的训练，突出构造性思维训练的特征，目的是提高学生分析问题，组织数据及设计大型软件的能力。 课程上机实验的目的，不仅仅是验证教材和讲课的内容，检查自己所编的程序是否正确，课程安排的上机实验的目的可以概括为如下几个方面： （1）加深对课堂讲授内容的理解 实验是对学生的一种全面综合训练。是与课堂听讲、自学和练习相辅相成的必不可少的一个教学环节。通常，实验题中的问题比平时的习题复杂得多，也更接近实际。实验着眼于原理与应用的结合点，使学生学会如何把书上学到的知识用于解决实际问题，培养软件工作所需要的动手能力；另一方面，能使书上的知识变" 活" ，起到深化理解和灵活掌握教学内容的目的。 不少学生在解答习题尤其是算法设计时，觉得无从下手。实验中的内容和教科书的内容是密切相关的，解决题目要求所需的各种技术大多可从教科书中找到，只不过其出 现的形式呈多样化，因此需要仔细体会，在反复实践的过程中才能掌握。 (2) 培养学生软件设计的综合能力 平时的练习较偏重于如何编写功能单一的" 小" 算法，而实验题是软件设计的综合训练，包括问题分析、总体结构设计、用户界面设计、程序设计基本技能和技巧，多人合作，以至一整套软件工作规范的训练和科学作风的培养。 通过实验使学生不仅能够深化理解教学内容，进一步提高灵活运用数据结构、算法和程序设计技术的能力，而且可以在需求分析、总体结构设计、算法设计、程序设计、上机操作及程序调试等基本技能方面受到综合训练。实验着眼于原理与应用的结合点，使学生学会如何把书本上和课堂上学到的知识用于解决实际问题，从而培养计算机软件工作所需要的动手能力。 (3) 熟悉程序开发环境，学习上机调试程序一个程序从编辑，编译，连接到运行，都要在一定的外部操作环境下才能进行。所谓" 环境" 就是所用的计算机系统硬件，软件条件，只有学会使用这些环境，才能进行 程序开发工作。通过上机实验，熟练地掌握程序的开发环境，为以后真正编写计算机程序解决实际问题打下基础。同时，在今后遇到其它开发环境时就会触类旁通，很快掌握新系统的使用。 完成程序的编写，决不意味着万事大吉。你认为万无一失的程序，实际上机运行时可能不断出现麻烦。如编译程序检测出一大堆语法错误。有时程序本身不存在语法错误，也能够顺利运行，但是运行结果显然是错误的。开发环境所提供的编译系统无法发现这种程序逻辑错误，只能靠自己的上机经验分析判断错误所在。程序的调试是一个技巧性很强的工作，尽快掌握程序调试方法是非常重要的。分析问题，选择算法，编好程序，只能说完成一半工作，另一半工作就是调试程序，运行程序并得到正确结果。 二、实验要求 常用的软件开发方法，是将软件开发过程划分为分析、设计、实现和维护四个阶段。虽然数据结构课程中的实验题目的远不如从实际问题中的复杂程度度高，但为了培养一个软件工作者所应具备的科学工作的方法和作风，也应遵循以下五个步骤来完成实验题目： 1) 问题分析和任务定义 在进行设计之前，首先应该充分地分析和理解问题，明确问题要求做什么?限制条件是什么。本步骤强调的是做什么?而不是怎么做。对问题的描述应避开算法和所涉及的数据类型，而是对所需完成的任务作出明确的回答。例如：输入数据的类型、值的范围以及输入的 数据结构(C语言版) 实验报告 专业班级学号姓名 实验1 实验题目：单链表的插入和删除 实验目的： 了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。 实验要求： 建立一个数据域定义为字符串的单链表，在链表中不允许有重复的字符串；根据输入的字符串，先找到相应的结点，后删除之。 实验主要步骤： 1、分析、理解给出的示例程序。 2、调试程序，并设计输入数据（如：bat，cat，eat，fat，hat，jat，lat，mat，#），测 试程序的如下功能：不允许重复字符串的插入；根据输入的字符串，找到相应的结点并删除。 3、修改程序： （1）增加插入结点的功能。 （2）将建立链表的方法改为头插入法。 程序代码: #include"" #include"" #include"" #include"" typedef struct node . . 示意图： head head head 心得体会： 本次实验使我们对链表的实质了解更加明确了，对链表的一些基本操作也更加熟练了。另外实验指导书上给出的代码是有一些问题的，这使我们认识到实验过程中不能想当然的直接编译执行，应当在阅读并完全理解代码的基础上再执行，这才是实验的意义所在。 实验2 实验题目：二叉树操作设计和实现 实验目的： 掌握二叉树的定义、性质及存储方式，各种遍历算法。 实验要求： 采用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序以及按层次遍历 的操作，求所有叶子及结点总数的操作。 实验主要步骤： 1、分析、理解程序。 2、调试程序，设计一棵二叉树，输入完全二叉树的先序序列，用#代表虚结点（空指针）， 如ABD###CE##F##，建立二叉树，求出先序、中序和后序以及按层次遍历序列，求 所有叶子及结点总数。 实验代码 #include"" #include"" #include"" #define Max 20 ertex=a; irstedge=NULL; irstedge; G->adjlist[i].firstedge=s; irstedge; R[i] 留在原位 国家二级ACCESS机试选择题（数据结构与算法）模拟试卷3 (总分：60.00，做题时间：90分钟) 一、选择题(总题数：30，分数：60.00) 1.在最坏情况下 （分数：2.00） A.快速排序的时间复杂度比冒泡排序的时间复杂度要小 B.快速排序的时间复杂度比希尔排序的时间复杂度要小 C.希尔排序的时间复杂度比直接插入排序的时间复杂度要小√ D.快速排序的时间复杂度与希尔排序的时间复杂度是一样的 解析：解析：按平均时间将排序分为四类：①平方阶(O(n 2 ))排序：各类简单排序，例如直接插入、直接选择和冒泡排序；②线性对数阶(O(n。log2n))排序：如快速排序、堆排序和归并排序；③O(n1+§))排序：§是介于0和1之间的常数。希尔排序便是一种；④线性阶(O(n))排序：本程序中的基数排序，此外还有桶、箱排序。 2.在深度为7的满二叉树中，度为2的结点个数为 （分数：2.00） A.64 B.63 √ C.32 D.31 解析：解析：因为在任意的二叉树中，度为O的结点(即叶子结点)总比度为2的结点的个数多1个，而度为0的结点数n 0 =2 m-1 (其中m为二叉树的深度)。本题的度为0的结点个数n 0 =2 7-1 =2 6 =64。因此，度为2的结点数n 2 =n 0 -1=63。所以选项B正确 3.设栈的顺序存储空间为S(1：m)，初始状态为top=m+1。现经过一系列入栈与退栈运算后，top=20，则当前栈中的元素个数为 （分数：2.00） A.30 B.20 C.m-19 √ D.m-20 TOP指针向上移动一位。当压入第一个元素时，TOP指针指向m+1-1=m；当压入第二个元素时，TOP指针指向 1n+1．2=m．1；…以此类推，当压入第N个元素时，TOP指针指向m+1-N=20；则N=m+1-20=m-19。因此选项C正确。 4.算法空间复杂度的度量方法是 （分数：2.00） A.算法程序的长度 B.算法所处理的数据量 C.执行算法所需要的工作单元 D.执行算法所需要的存储空间√ 解析：解析：算法空间复杂度是对一个算法在运行过程中临时占用存储空间大小的度量，因此选项D正确。 5.设循环队列为Q(1：m)，其初始状态为front=rear=m。经过一系列入队与退队运算后，front=15，rear=20。现要在该循环队列中寻找最大值的元素，最坏情况下需要比较的次数为 （分数：2.00） A.4 √ B.6 C.m-5 习题二 ⒉１描述以下四个概念的区别：头指针变量，头指针，头结点，首结点（第一个结点）。解：头指针变量和头指针是指向链表中第一个结点（头结点或首结点）的指针；在首结点之前附设一个结点称为头结点；首结点是指链表中存储线性表中第一个数据元素的结点。若单链表中附设头结点，则不管线性表是否为空，头指针均不为空，否则表示空表的链表的头指针为空。 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.问题分析与系统结构设计 充分地分析和理解问题本身，弄清要求做什么（而不是怎么做），限制条件是什么。按照以数据结构为中心的原则划分模块，搞清数据的逻辑结构（是线性表还是树、图？），确定数据的存储结构（是顺序结构还是链表结构？），然后设计有关操作的函数。在每个函数模块中，要综合考虑系统功能，使系统结构清晰、合理、简单和易于调试。最后写出每个模块的算法头和规格说明，列出模块之间的调用关系（可以用图表示），便完成了系统结构设计。 2.详细设计和编码 详细设计是对函数（模块）的进一步求精，用伪高级语言（如类C语言）或自然语言写出算法框架，这时不必确定很多结构和变量。 编码，即程序设计，是对详细设计结果的进一步求精，即用某种高级语言（如C/C++语言）表达出来。尽量多设一些注释语句，清晰易懂。尽量临时增加一些输出语句，便于差错矫正，在程序成功后再删去它们。 3.上机准备 熟悉高级语言用法，如C语言。熟悉机器（即操作系统），基本的常用命令。静态检查主要有两条路径，一是用一组测试数据手工执行程序（或分模块进行）；二是通过阅读或给别人讲解自己的程序而深入全面地理解程序逻辑，在这个过程中再加入一些注释和断言。如果程序中逻辑概念清楚，后者将比前者有效。 4.上机调试程序 调试最好分块进行，自底向上，即先调试底层函数，必要时可以另写一个调用驱动程序，表面上的麻烦工作可以大大降低调试时所面临的复杂性，提高工作效率。 5.整理实验报告 在上机实验开始之前要充分准备实验数据，在上机实践过程中要及时记录实验数据，在上机实践完成之后必须及时总结分析，写出实验报告。 实习一： 1、编写一个读入一个字符串，把它存入一个链表，并按相反的次序打印的程序。 2、设有一个单位的人员工资有如下信息：name、department、 base pay、allowance、total。现从键盘输入一组人员工资数据并将它们存储到名为paydata的文件中；再从paydata取出工资数据并给每个人的base pay增加100元，增加后将工资数据显示于屏幕(每行1人)。请编写能够完成上述工作的程序。 代码如下： 1.#include 数据结构上机实验题目 实验一线性表的顺序存储结构 实验学时 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小时，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 第二行是这几个结点的权值输出格式为结点号（权值）：哈夫曼编码 数据结构上机实验报告 学院：电子工程学院 专业：信息对抗技术 姓名： 学号： 教师：饶鲜 日期： 目录 实验一线性表 ........................................................................................................ - 2 - 一、实验目的.................................................................................................... - 2 - 二、实验代码.................................................................................................... - 2 - 三、实验结果.................................................................................................... - 8 - 四、个人思路.................................................................................................... - 9 - 实验二栈和队列 .................................................................................................... - 9 - 一、实验目的.................................................................................................... - 9 - 二、实验代码.................................................................................................. - 10 - 三、实验结果.................................................................................................. - 15 - 四、个人思路.................................................................................................. - 16 - 实验三数组 .......................................................................................................... - 16 - 一、实验目的.................................................................................................. - 16 - 二、实验代码.................................................................................................. - 16 - 三、实验结果.................................................................................................. - 18 - 四、个人思路.................................................................................................. - 18 - 实验四树 .............................................................................................................. - 18 - 一、实验目的.................................................................................................. - 18 - 二、实验代码.................................................................................................. - 19 - 三、实验结果.................................................................................................. - 24 - 四、个人思路.................................................................................................. - 25 - 《数据结构》上机练习题 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）的功能。 当选择删除功能时，从键盘读入欲删除的元素位置或元素值，按指定方式删除；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; 实验三 《数据结构简明教程》练习题及参考答案 练习题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为问题规模，给出对应的时间复杂度： T1(n)=n log2n-1000log2n T2(n)=3 log2 n-1000log2n 数据结构上机考试试题（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!"< 2013-03-08 上机实验题 1.构建两个顺序表示的非空线性表LA和LB (数据元素为整型，其值自行确定)； 2.从线性表LA中删除第i 个元素； 3.将元素e插入到线性表LB中的第i个元素之后； 4.假设LA中不含重复的元素 (LB同)，将线性表LA和LB合并，并输出结果，要求结 果中不含重复的元素。 //构建两个顺序表（定义、初始化） //在一个顺序表中删除指定位置的元素 //在一个顺序表中指定位置插入一个新元素 //将两个线性表LA和LB进行合并 //遍历LB, 如果其中的数据元素不在LA中，则将其插入LA，否则不予处理 //打印线性表LA #define List_Init_Size 100 #define LISTINCREMENT 10 typedef int Status; typedef struct { int * elem; int length; // 当前长度 int ListSize; // 当前分配的存储容量 }SqList; Status Initialize_table (SqList &L) {// 初始化线性表 int i, m, data; L.elem=(int *)malloc(List_Init_Size *sizeof(int)); if (!L.elem) { // 为线性表分配空间 printf("Overflow"); return FAILURE; } L.ListSize=List_Init_Size; L.length=0; printf ("Please input the size of linear table (<=%d): "+ List_Init_Size); scanf_s("%d",&m); for (i=0;i 国家二级MS Office高级应用机试（数据结构与算法）模拟试卷 8 (总分：56.00，做题时间：90分钟) 一、选择题(总题数：28，分数：56.00) 1.下列结构中属于线性结构链式存储的是 （分数：2.00） A.双向链表√ B.循环队列 C.二叉链表 D.二维数组 解析：解析：数据元素之间的关系有两种不同的表示方法：顺序映象和非顺序映象，并由此得到两种不同的存储结构：顺序存储结构和链式存储结构。数据的存储结构是指数据的逻辑结构在计算机中的表示。双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱，它的存储方式是线性结构链式。循环队列、二叉链表和二维数组都是顺序存储结构。 2.下列叙述中错误的是 （分数：2.00） A.循环链表中有一个表头结点 B.循环链表的存储空间是连续的√ C.循环链表实现了空表与非空表运算的统一 D.循环链表的表头指针与循环链表中最后一个结点的指针均指向表头结点 解析：解析：循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。循环链表的结点是指针指向，它不一定要是连续的存储空间，也可以是断开的空间。 3.度为3的一棵树共有30个结点，其中度为3、1的结点个数分别为3、4。则该树中的叶子结点数为 （分数：2.00） A.14 B.15 √ C.16 D.不可能有这样的树 解析：解析：根据题目可知本树中还有度为2的结点。树的总结点＝(度1*个数＋度2*个数…)＋1，这里我们设度为2的结点数为x，那么30＝3*3＋2*x＋1*4＋1＝2*x＋14，由此可计算出x＝8。树的叶子结点数等于总结点减去所有度不为0的结点，也就是30－3－8－4＝15。 4.在长度为97的顺序有序表中作二分查找，最多需要的比较次数为 （分数：2.00） A.7 √ B.96 C.48 D.6 解析：解析：二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。最多比较次数的计算方式：k＝log 2 n。其中n代表长度，k为比较次数。本题中可以计算出k＝7。 5.下列结构中属于非线性结构的是 （分数：2.00） A.二叉链表 B.二维数组√ C.循环队列 《数据结构》实验指导书 计算机专业实验中心编 2020年5月25日 目录 《数据结构》上机实验内容和要求 ................................................................... 错误!未定义书签。实验一、顺序表的实现及应用 ........................................................................... 错误!未定义书签。实验二、链表的实现及应用 ............................................................................... 错误!未定义书签。实验三、栈的实现及应用 ................................................................................... 错误!未定义书签。实验四、队列的实现及应用 ............................................................................... 错误!未定义书签。实验五、二叉树操作及应用 ............................................................................... 错误!未定义书签。实验六、图的遍历操作及应用 ........................................................................... 错误!未定义书签。实验七、查找算法的实现 ................................................................................... 错误!未定义书签。实验八、排序算法的实现 ................................................................................... 错误!未定义书签。 【实验题】 1．狐狸逮兔子 围绕着山顶有10个圆形排列的洞，狐狸要吃兔子，兔子说：“可以，但必须找到我，我就藏身于这十个洞中，你先到１号洞找，第二次隔１个洞（即3号洞）找，第三次隔２个洞（即6号洞）找，以后如此类推，次数不限。”但狐狸从早到晚进进出出了1000次，仍没有找到兔子。问兔子究竟藏在哪个洞里？ （提示：这实际上是一个反复查找线性表的过程。） 【数据描述】 定义一个顺序表，用具有10个元素顺序表来表示这10个洞。每个元素分别表示围着山顶的一个洞，下标为洞的编号。 #define LIST_INIT_SIZE 10 //线性表存储空间的初始分配量 typedef struct { ElemType *elem; //存储空间基址 int length; //当前长度 int listsize; //当前分配的存储容量（以sizeof(ElemType)为单位） }SqList; 【算法描述】 status InitList_Sq(SqList &L) { //构造一个线性表L L.elem=(ElemType )malloc(LIST_INIT_SIZE*sizeof(ElemType)); If(!L.elem) return OVERFLOW; //存储分配失败 L.length=0; //空表长度为0 L.listsize=LIST_INIT_SIZE; //初始存储容量 return OK; } //InitList_Sq status Rabbit(SqList &L) { //构造狐狸逮兔子函数 int current=0; //定义一个当前洞口号的记数器，初始位置为第一个洞口 for(i=0;i数据结构课程实验指导书
数据结构实验报告-答案
国家二级ACCESS机试选择题(数据结构与算法)模拟试卷3
数据结构上机例题及答案
计10--数据结构专题实验rev2
数据结构上机答案(c语言版)
经典数据结构上机题_答案解析
数据结构上机考试题
数据结构上机实验报告
数据结构上机考试(含答案)
数据结构上机实验指导
数据结构课程__课后习题答案
数据结构上机考试试题
数据结构 上机实验题及题解
国家二级MS+Office高级应用机试(数据结构与算法)模拟试卷8
数据结构-实验指导书
数据结构实验题参考答案