数据结构上机实验2011
东华大学数据结构上机实验报告
东华大学信息科学与技术学院实验报告实验名称：线性表的基本操作指导教师：学生姓名：学生学号：实验日期：2012/11一、实验目的１、熟悉Ｃ或VC++语言上机环境。
２、会定义线性表的顺序存储结构和链式存储结构。
３、熟悉顺序表和单链表的一些基本操作和应用。
４、加深对线性表的理解，逐步培养解决实际问题的编程能力。
二、实验环境运行Ｃ或VC++的微机。
三、实验内容：分别使用顺序表和单链表存储结构实现以下操作：1.建立线性表L＝｛12,13,21,24,28,31,42,77｝；2.在第5个元素之前插入26；3.删除第5个元素28；4.查找28。
四、实验设计思路及算法流程(一)使用顺序表实现操作:建立顺序表，完成顺序表的基本操作：初始化、插入、删除、输出、查找元素、判线性表是否为空；问题分析：利用顺序表,设计一组输入数据，能够对顺序表进行如下操作：创建一个新的顺序表，实现动态空间分配的初始化；已给定的值插入到指定位置和删除指定位置的值，形成有序顺序表；按值查找，根据给定数据元素的值，查找该元素的位置，对查找结果进行返回；实现顺序表的各个元素的输出；“初始化算法”的操作结果：构造一个空的顺序线性表，对顺序表的空间进行动态管理，实现动态分配、回收和增加存储空间；“位置插入算法”的初始条件：顺序线性表L已存在，给定的元素位置为i，且1≤i≤ListLength(L)+1 ；其操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1；“位置删除算法”的初始条件：顺序线性表L已存在，1≤i≤ListLength(L) ；其操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 ；“输出算法”的初始条件：顺序线性表L已存在；其操作结果：依次对L的每个数据元素进行输出；“按值查找算法”初始条件：顺序线性表L已存在，元素值为e；其操作结果：返回L 中数据元素值为e的元素位置；线性表的顺序存储结构的定义及其基本操作的参考程序（顺序表）文件一：pubuse. h 是公共使用的常量定义和系统函数调用声明。
数据结构上机考试题目及要求
数据结构上机实验考试标准一、评分标准：1.根据考试完成情况，参考平时上机情况评定优、良、中、及格、不及格5个档。
2.成绩分布比例近似为：优15%、良30%、中30%、及格20%、不及格<10%二、评分原则：1.充分参考平时实验完成情况，结合如下原则给出成绩；2.只完成第一题，成绩为良以下成绩（中、及格），若平时上机情况很好，可以考虑良好；3.两道题都完成，成绩为良及以上（优、良），根据完成质量和完成时间给成绩；4.如未完成任何程序，则不及格（根据平时成绩将不及格率控制在10%以下）；三、监考要求：1.考试前，要求学生检查电脑是否工作正常，如果不正常及时解决，待所有考生均可正常考试后再发布试题。
2.平时上机完成的程序可以在考试过程直接调用，在考试开始前复制到硬盘当中，考试过程中可以看教材。
3.考试开始后向学生分发考题的电子文档，同时宣读试题，学生可以通过网络或磁盘拷贝试题。
4.考试开始十五分钟之后把网络断开，学生不得再使用任何形式的磁盘。
5.程序检查时，记录其完成时间和完成情况。
除检查执行情况外，还要求学生对代码进行简要讲解，核实其对代码的理解情况和设计思想，两项均合格方视为试题完成。
6.完成考试的学生须关闭电脑立刻离开考场，考试成绩由教务办统一公布，负责教师不在考试现场公布成绩。
数据结构上机实验考试题目（2011年12月23日）题目1.设C={a1,b1,a2,b2,…,a n,b n}为一线性表，采用带头结点的单链表hc（hc为C链表的头指针）存放，设计一个算法，将其拆分为两个线性表（它们都用带头结点的单链表存放），使得：A={a1,a2,…,a n}，B={b n,b n-1,…,b1}。
[例] C链表为：C={1，2，3，4，5，6，7，8，9，10｝拆分后的A、B链表如下：A={1，3，5，7，9}，B={10，8，6，4，2}。
要求：算法的空间复杂度为O（1）。
即利用C链表原来的空间。
数据结构上机实验报告
else insert(lc,i/2,la.list[i]); //偶数位次元素插入lc
}
printf("\n您输入的线性表元素为:\n\n");
print(la);
printf("线性表的奇数位次的元素为：\n\n");
print(lb);
printf("线性表的偶数位次的元素为：\n\n");
print(lc);
}
void initial(sqlist &v)
{printf(" ****本程序可以实现线性表奇偶位序的元素分别输出****\n\n\n");
int i,a;
printf("请输入一个偶数作为线性表的长度：\n\n");
void initlist(sqlist &);
void print(sqlist); //输出线性表
void main()
{printf(" *****************本程序可以实现线性表的复制******************\n");
sqlist la,lb; //声明线性表
initial(la);
【程序设计细想】：
建立三个线性表la,lb,lc，对线性表la进行输入，然后利用循环结构对la中奇数位序的元素对lb进行插入操作，对偶数位序的元素对lc进行插入操作，从而得到线性表lb和lc。
【程序代码】：
#include<stdio.h>
#include<malloc.h>
数据结构集中上机实验报告
XX大学信息与计算科学专业2008级《数据结构》集中上机设计题目：迷宫求解（非递归求解）设计时间：2010-2011学年第一学期目录一、实验内容 (2)二、需求分析 (2)三、总体设计 (2)（一）存储结构 (2)（二）流程图 (3)四、详细设计 (3)（一）基本算法解析 (3)（二）为实现算法，需要的象的数据类型 (4)(三)函数的调用关系 (5)（四）算法时间、空间复杂度 (5)五、代码 (5)六、运行结果分析 (10)（一）迷宫路径探索成功 (10)（二）迷宫路径未找到的情况 (13)（三）程序的优缺点与改进 (13)七、参考文献 (14)八、心得体会 (14)一、实验内容任务：可以输入一个任意大小的迷宫数据，用非递归的方法求出一条走出迷宫的路径，并将路径输出。
二、需求分析1、可以输入一个任意大小的迷宫数据，用非递归的方法求出一条走出迷宫的路径，并将路径输出；要求使用非递归算法。
2、用户可以根据自己的需求进行输入所需的迷宫，其中1表示迷宫的墙壁，0表示迷宫的通路，从而建立迷宫。
3、可以自行输入迷宫的入口和出口坐标。
4、程序执行的命令包括：（1）构造栈函数。
其中包括了构造空栈InitStack；压入新数据元素Push；栈顶元素出栈Pop。
（2）构造求迷宫路径函数。
其中定义了二维数组maze[M][N]存取迷宫数据；输出找到的通路MazePath。
（3）建立一个迷宫initmaze。
其中包括输入迷宫行数列数以及各行各列；加一圈围墙并输出迷宫。
三、总体设计（一）存储结构：首先用二维数组存储迷宫数据，迷宫数据由用户输入。
一个以链表结构作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。
求得的通路以三元组（i,j,d）形式输出，其中（i,j）指示迷宫中的一个坐标，d表示走到下一坐标的方向（东南西北所用代表数字，自行定义）。
1．从入口出发，顺着某一个方向进行探索，若能走通，继续往前走，否则沿原路退回，换一个方向继续探索，直至出口位置，求得一条通路。
数据结构上机实验
目录第1章绪论——上机实验题1解析实验题1.1求素数实验题1.2求一个正整数的各位数字之和实验题1.3求一个字符串是否为回文第2章线性表——上机实验题2解析实验题2.1实现顺序表各种基本运算的算法/*文件名:algo2-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType elem[MaxSize];int length;} SqList;void InitList(SqList *&L){L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *L){free(L);}int ListEmpty(SqList *L){return(L->length==0);}int ListLength(SqList *L){return(L->length);}void DispList(SqList *L){int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c",L->elem[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e){if (i<1 || i>L->length)return 0;e=L->elem[i-1];return 1;}int LocateElem(SqList *L, ElemType e){int i=0;while (i<L->length && L->elem[i]!=e) i++;if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e){int j;if (i<1 || i>L->length+1)return 0;i--; /*将顺序表位序转化为elem下标*/for (j=L->length;j>i;j--) /*将elem[i]及后面元素后移一个位置*/L->elem[j]=L->elem[j-1];L->elem[i]=e;L->length++; /*顺序表长度增1*/return 1;}int ListDelete(SqList *&L,int i,ElemType &e){int j;if (i<1 || i>L->length)return 0;i--; /*将顺序表位序转化为elem下标*/e=L->elem[i];for (j=i;j<L->length-1;j++)L->elem[j]=L->elem[j+1];L->length--;return 1;}实验题2.2实现单链表各种基本运算的算法*文件名:algo2-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct LNode /*定义单链表结点类型*/{ElemType data;struct LNode *next;} LinkList;void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/L->next=NULL;}void DestroyList(LinkList *&L){LinkList *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList *L){return(L->next==NULL);}int ListLength(LinkList *L){LinkList *p=L;int i=0;while (p->next!=NULL){i++;p=p->next;}return(i);}void DispList(LinkList *L){LinkList *p=L->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(LinkList *L,int i,ElemType &e) {int j=0;LinkList *p=L;while (j<i && p!=NULL){j++;p=p->next;}if (p==NULL)return 0;else{e=p->data;return 1;}}int LocateElem(LinkList *L,ElemType e){LinkList *p=L->next;int n=1;while (p!=NULL && p->data!=e){p=p->next;n++;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(LinkList *&L,int i,ElemType e)int j=0;LinkList *p=L,*s;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/s->data=e;s->next=p->next; /*将*s插p->next=s;return 1;}}int ListDelete(LinkList *&L,int i,ElemType &e){int j=0;LinkList *p=L,*q;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/p->next=q->next; /*从单链表中删除*q结点*/free(q); /*释放*q结点*/return 1;}}第3章栈和队列——上机实验题3解析实验题3.1实现顺序栈各种基本运算的算法*文件名:algo3-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct{ElemType elem[MaxSize];int top; /*栈指针*/} SqStack;void InitStack(SqStack *&s){s=(SqStack *)malloc(sizeof(SqStack));s->top=-1;}void ClearStack(SqStack *&s){free(s);}int StackLength(SqStack *s){return(s->top+1);}int StackEmpty(SqStack *s){return(s->top==-1);}int Push(SqStack *&s,ElemType e){if (s->top==MaxSize-1)return 0;s->top++;s->elem[s->top]=e;return 1;}int Pop(SqStack *&s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];s->top--;return 1;int GetTop(SqStack *s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];return 1;}void DispStack(SqStack *s){int i;for (i=s->top;i>=0;i--)printf("%c ",s->elem[i]);printf("\n");}实验题3.2实现链栈各种基本运算的算法/*文件名:algo3-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct linknode{ElemType data; /*数据域*/struct linknode *next; /*指针域*/} LiStack;void InitStack(LiStack *&s){s=(LiStack *)malloc(sizeof(LiStack));s->next=NULL;}void ClearStack(LiStack *&s){LiStack *p=s->next;while (p!=NULL){free(s);s=p;p=p->next;}}int StackLength(LiStack *s){int i=0;LiStack *p;p=s->next;while (p!=NULL){i++;p=p->next;}return(i);}int StackEmpty(LiStack *s){return(s->next==NULL);}void Push(LiStack *&s,ElemType e){LiStack *p;p=(LiStack *)malloc(sizeof(LiStack));p->data=e;p->next=s->next; /*插入*p结点作为第一个数据结点*/s->next=p;}int Pop(LiStack *&s,ElemType &e){LiStack *p;if (s->next==NULL) /*栈空的情况*/return 0;p=s->next; /*p指向第一个数据结点*/e=p->data;s->next=p->next;free(p);return 1;}int GetTop(LiStack *s,ElemType &e){if (s->next==NULL) /*栈空的情况*/return 0;e=s->next->data;return 1;}void DispStack(LiStack *s){LiStack *p=s->next;while (p!=NULL){printf("%c ",p->data);p=p->next;}printf("\n");}实验题3.3实现顺序队列各种基本运算的算法/*文件名:algo3-3.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 5typedef char ElemType;typedef struct{ElemType elem[MaxSize];int front,rear; /*队首和队尾指针*/} SqQueue;void InitQueue(SqQueue *&q){q=(SqQueue *)malloc (sizeof(SqQueue));q->front=q->rear=0;}void ClearQueue(SqQueue *&q){free(q);}int QueueEmpty(SqQueue *q){return(q->front==q->rear);}int QueueLength(SqQueue *q){return (q->rear-q->front+MaxSize)%MaxSize; }int enQueue(SqQueue *&q,ElemType e){if ((q->rear+1)%MaxSize==q->front) /*队满*/return 0;q->rear=(q->rear+1)%MaxSize;q->elem[q->rear]=e;return 1;}int deQueue(SqQueue *&q,ElemType &e){if (q->front==q->rear) /*队空*/return 0;q->front=(q->front+1)%MaxSize;e=q->elem[q->front];return 1;}实验题3.4实现链队各种基本运算的算法/*文件名:algo3-4.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct qnode{ElemType data;struct qnode *next;} QNode;typedef struct{QNode *front;QNode *rear;} LiQueue;void InitQueue(LiQueue *&q){q=(LiQueue *)malloc(sizeof(LiQueue));q->front=q->rear=NULL;}void ClearQueue(LiQueue *&q){QNode *p=q->front,*r;if (p!=NULL) /*释放数据结点占用空间*/{r=p->next;while (r!=NULL){free(p);p=r;r=p->next;}}free(q); /*释放头结点占用空间*/ }int QueueLength(LiQueue *q){int n=0;QNode *p=q->front;while (p!=NULL){n++;p=p->next;}return(n);}int QueueEmpty(LiQueue *q){if (q->rear==NULL)return 1;elsereturn 0;}void enQueue(LiQueue *&q,ElemType e){QNode *s;s=(QNode *)malloc(sizeof(QNode));s->data=e;s->next=NULL;if (q->rear==NULL) /*若链队为空,则新结点是队首结点又是队尾结点*/q->front=q->rear=s;else{q->rear->next=s; /*将*s结点链到队尾,rear指向它*/q->rear=s;}}int deQueue(LiQueue *&q,ElemType &e){QNode *t;if (q->rear==NULL) /*队列为空*/return 0;if (q->front==q->rear) /*队列中只有一个结点时*/{t=q->front;q->front=q->rear=NULL;}else /*队列中有多个结点时*/{t=q->front;q->front=q->front->next;}e=t->data;free(t);return 1;}第4章串——上机实验题4解析实验题4.1实现顺序串各种基本运算的算法/*文件名:algo4-1.cpp*/#include <stdio.h>#define MaxSize 100 /*最多的字符个数*/typedef struct{ char ch[MaxSize]; /*定义可容纳MaxSize个字符的空间*/ int len; /*标记当前实际串长*/} SqString;void StrAssign(SqString &str,char cstr[]) /*str为引用型参数*/ {int i;for (i=0;cstr[i]!='\0';i++)str.ch[i]=cstr[i];str.len=i;}void StrCopy(SqString &s,SqString t) /*s为引用型参数*/ {int i;for (i=0;i<t.len;i++)s.ch[i]=t.ch[i];s.len=t.len;}int StrEqual(SqString s,SqString t){int same=1,i;if (s.len!=t.len) /*长度不相等时返回0*/same=0;else{for (i=0;i<s.len;i++)if (s.ch[i]!=t.ch[i]) /*有一个对应字符不相同时返回0*/same=0;}return same;}int StrLength(SqString s){return s.len;}SqString Concat(SqString s,SqString t){SqString str;int i;str.len=s.len+t.len;for (i=0;i<s.len;i++) /*将s.ch[0]～s.ch[s.len-1]复制到str*/ str.ch[i]=s.ch[i];for (i=0;i<t.len;i++) /*将t.ch[0]～t.ch[t.len-1]复制到str*/ str.ch[s.len+i]=t.ch[i];return str;}SqString SubStr(SqString s,int i,int j){SqString str;int k;str.len=0;if (i<=0 || i>s.len || j<0 || i+j-1>s.len){printf("参数不正确\n");return str; /*参数不正确时返回空串*/}for (k=i-1;k<i+j-1;k++) /*将s.ch[i]～s.ch[i+j]复制到str*/str.ch[k-i+1]=s.ch[k];str.len=j;return str;}SqString InsStr(SqString s1,int i,SqString s2){int j;SqString str;str.len=0;if (i<=0 || i>s1.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return s1;}for (j=0;j<i-1;j++) /*将s1.ch[0]～s1.ch[i-2]复制到str*/str.ch[j]=s1.ch[j];for (j=0;j<s2.len;j++) /*将s2.ch[0]～s2.ch[s2.len-1]复制到str*/str.ch[i+j-1]=s2.ch[j];for (j=i-1;j<s1.len;j++) /*将s1.ch[i-1]～s.ch[s1.len-1]复制到str*/str.ch[s2.len+j]=s1.ch[j];str.len=s1.len+s2.len;return str;}SqString DelStr(SqString s,int i,int j){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j>s.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]～s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=i+j-1;k<s.len;k++)/*将s.ch[i+j-1]～ch[s.len-1]复制到str*/ str.ch[k-j]=s.ch[k];str.len=s.len-j;return str;}SqString RepStr(SqString s,int i,int j,SqString t){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j-1>s.len) /*参数不正确时返回空串*/ {printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]～s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=0;k<t.len;k++) /*将t.ch[0]～t.ch[t.len-1]复制到str*/str.ch[i+k-1]=t.ch[k];for (k=i+j-1;k<s.len;k++) /*将s.ch[i+j-1]～ch[s.len-1]复制到str*/str.ch[t.len+k-j]=s.ch[k];str.len=s.len-j+t.len;return str;}void DispStr(SqString str){int i;if (str.len>0){for (i=0;i<str.len;i++)printf("%c",str.ch[i]);printf("\n");}}实验题4.2实现链串各种基本运算的算法*文件名:algo4-2.cpp*/#include <stdio.h>#include <malloc.h>typedef struct snode{char data;struct snode *next;} LiString;void StrAssign(LiString *&s,char t[]){int i;LiString *r,*p;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;r=s;for (i=0;t[i]!='\0';i++){p=(LiString *)malloc(sizeof(LiString));p->data=t[i];p->next=NULL;r->next=p;r=p;}}void StrCopy(LiString *&s,LiString *t){LiString *p=t->next,*q,*r;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;s->next=NULL;r=s;while (p!=NULL) /*将t的所有结点复制到s*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}}int StrEqual(LiString *s,LiString *t){LiString *p=s->next,*q=t->next;while (p!=NULL && q!=NULL && p->data==q->data){p=p->next;q=q->next;}if (p==NULL && q==NULL)return 1;elsereturn 0;}int StrLength(LiString *s){int i=0;LiString *p=s->next;while (p!=NULL){i++;p=p->next;}return i;}LiString *Concat(LiString *s,LiString *t){LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;while (p!=NULL) /*将s的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}p=t->next;while (p!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *SubStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++)p=p->next;for (k=1;k<=j;k++) /*将s的第i个结点开始的j个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *InsStr(LiString *s,int i,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s)+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=1;k<i;k++) /*将s的前i个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}while (p1!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *DelStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *RepStr(LiString *s,int i,int j,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p1!=NULL) /*将t的所有结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}void DispStr(LiString *s){LiString *p=s->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}第5章数组和稀疏矩阵——上机实验题5解析实验题5.1求5×5阶螺旋方阵/*文件名:exp5-1.cpp*/#include <stdio.h>#define MaxLen 10void fun(int a[MaxLen][MaxLen],int n){int i,j,k=0,m;if (n%2==0) //m=én/2ùm=n/2;elsem=n/2+1;for (i=0;i<m;i++){for (j=i;j<n-i;j++){k++;a[i][j]=k;}for (j=i+1;j<n-i;j++){k++;a[j][n-i-1]=k;}for (j=n-i-2;j>=i;j--){k++;a[n-i-1][j]=k;}for (j=n-i-2;j>=i+1;j--){k++;a[j][i]=k;}}}void main(){int n,i,j;int a[MaxLen][MaxLen];printf("\n");printf("输入n(n<10):");scanf("%d",&n);fun(a,n);printf("%d阶数字方阵如下:\n",n);for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",a[i][j]);printf("\n");}printf("\n");}实验题5.2求一个矩阵的马鞍点/*文件名:exp5-2.cpp*/#include <stdio.h>#define M 4#define N 4void MinMax(int A[M][N]){int i,j,have=0;int min[M],max[N];for (i=0;i<M;i++) /*计算出每行的最小值元素,放入min[0..M-1]之中*/{min[i]=A[i][0];for (j=1;j<N;j++)if (A[i][j]<min[i])min[i]=A[i][j];}for (j=0;j<N;j++) /*计算出每列的最大值元素,放入max[0..N-1]之中*/{max[j]=A[0][j];for (i=1;i<M;i++)if (A[i][j]>max[j])max[j]=A[i][j];}for (i=0;i<M;i++)for (j=0;j<N;j++)if (min[i]==max[j]){printf(" A[%d,%d]=%d\n",i,j,A[i][j]); /*显示马鞍点*/have=1;}if (!have)printf("没有鞍点\n");}void main(){int i,j;int A[M][N]={{9, 7, 6, 8},{20,26,22,25},{28,36,25,30},{12,4, 2, 6}};printf("A矩阵:\n");for (i=0;i<M;i++){for (j=0;j<N;j++)printf("%4d",A[i][j]);printf("\n");}printf("A矩阵中的马鞍点:\n");MinMax(A); /*调用MinMax()找马鞍点*/}实验题5.3求两个对称矩阵之和与乘积/*文件名:exp5-3.cpp*/#include <stdio.h>#define n 4#define m 10int value(int a[],int i,int j){if (i>=j)return a[(i*(i-1))/2+j];elsereturn a[(j*(j-1))/2+i];}void madd(int a[],int b[],int c[n][n]){int i,j;for (i=0;i<n;i++)for (j=0;j<n;j++)c[i][j]=value(a,i,j)+value(b,i,j);}void mult(int a[],int b[],int c[n][n]){int i,j,k,s;for (i=0;i<n;i++)for (j=0;j<n;j++){s=0;for (k=0;k<n;k++)s=s+value(a,i,k)*value(b,k,j); c[i][j]=s;}}void disp1(int a[]){int i,j;for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",value(a,i,j));printf("\n");}}void disp2(int c[n][n]){int i,j;for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",c[i][j]);printf("\n");}}void main(){int a[m]={1,2,3,4,5,6,7,8,9,10};int b[m]={1,1,1,1,1,1,1,1,1,1};int c1[n][n],c2[n][n];madd(a,b,c1);mult(a,b,c2);printf("\n");printf("a矩阵:\n");disp1(a);printf("b矩阵:\n");disp1(b);printf("a+b:\n");disp2(c1);printf("a*b:\n");disp2(c2);printf("\n");}实验题5.4实现稀疏矩阵（采用三元组表示）的基本运算/*文件名:exp5-4.cpp*/#include <stdio.h>#define N 4typedef int ElemType;#define MaxSize 100 /*矩阵中非零元素最多个数*/ typedef struct{ int r; /*行号*/int c; /*列号*/ElemType d; /*元素值*/} TupNode; /*三元组定义*/typedef struct{ int rows; /*行数值*/int cols; /*列数值*/int nums; /*非零元素个数*/TupNode data[MaxSize];} TSMatrix; /*三元组顺序表定义*/void CreatMat(TSMatrix &t,ElemType A[N][N]){int i,j;t.rows=N;t.cols=N;t.nums=0;for (i=0;i<N;i++){for (j=0;j<N;j++)if (A[i][j]!=0){t.data[t.nums].r=i;t.data[t.nums].c=j;t.data[t.nums].d=A[i][j];t.nums++;}}}void DispMat(TSMatrix t){int i;if (t.nums<=0)return;printf("\t%d\t%d\t%d\n",t.rows,t.cols,t.nums);printf("\t------------------\n");for (i=0;i<t.nums;i++)printf("\t%d\t%d\t%d\n",t.data[i].r,t.data[i].c,t.data[i].d); }void TranMat(TSMatrix t,TSMatrix &tb){int p,q=0,v; /*q为tb.data的下标*/tb.rows=t.cols;tb.cols=t.rows;tb.nums=t.nums;if (t.nums!=0){for (v=0;v<t.cols;v++) /*tb.data[q]中的记录以c 域的次序排列*/for (p=0;p<t.nums;p++) /*p为t.data的下标*/if (t.data[p].c==v){tb.data[q].r=t.data[p].c;tb.data[q].c=t.data[p].r;tb.data[q].d=t.data[p].d;q++;}}}int MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c){int i=0,j=0,k=0;ElemType v;if (a.rows!=b.rows || a.cols!=b.cols)return 0; /*行数或列数不等时不能进行相加运算*/c.rows=a.rows;c.cols=a.cols; /*c的行列数与a的相同*/while (i<a.nums && j<b.nums) /*处理a和b中的每个元素*/{if (a.data[i].r==b.data[j].r) /*行号相等时*/{if(a.data[i].c<b.data[j].c) /*a元素的列号小于b 元素的列号*/{c.data[k].r=a.data[i].r;/*将a元素添加到c中*/c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else if (a.data[i].c>b.data[j].c)/*a元素的列号大于b元素的列号*/{c.data[k].r=b.data[j].r; /*将b元素添加到c中*/c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}else /*a元素的列号等于b元素的列号*/{v=a.data[i].d+b.data[j].d;if (v!=0) /*只将不为0的结果添加到c中*/{c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=v;k++;}i++;j++;}}else if (a.data[i].r<b.data[j].r) /*a元素的行号小于b元素的行号*/{c.data[k].r=a.data[i].r; /*将a元素添加到c中*/c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else /*a元素的行号大于b元素的行号*/{c.data[k].r=b.data[j].r; /*将b元素添加到c中*/c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}c.nums=k;}return 1;}int value(TSMatrix c,int i,int j){int k=0;while (k<c.nums && (c.data[k].r!=i || c.data[k].c!=j))k++;if (k<c.nums)return(c.data[k].d);elsereturn(0);}int MatMul(TSMatrix a,TSMatrix b,TSMatrix &c){int i,j,k,p=0;ElemType s;if (a.cols!=b.rows) /*a的列数不等于b的行数时不能进行相乘运算*/return 0;for (i=0;i<a.rows;i++)for (j=0;j<b.cols;j++){s=0;for (k=0;k<a.cols;k++)s=s+value(a,i,k)*value(b,k,j);if (s!=0) /*产生一个三元组元素*/{c.data[p].r=i;c.data[p].c=j;c.data[p].d=s;p++;}}c.rows=a.rows;c.cols=b.cols;c.nums=p;return 1;}void main(){ElemType a1[N][N]={{1,0,3,0},{0,1,0,0},{0,0,1,0},{0,0,1,1}};ElemType b1[N][N]={{3,0,0,0},{0,4,0,0},{0,0,1,0},{0,0,0,2}};TSMatrix a,b,c;CreatMat(a,a1);CreatMat(b,b1);printf("a的三元组:\n");DispMat(a);printf("b的三元组:\n");DispMat(b);printf("a转置为c\n");TranMat(a,c);printf("c的三元组:\n");DispMat(c);printf("c=a+b\n");MatAdd(a,b,c);printf("c的三元组:\n");DispMat(c);printf("c=a*b\n");MatMul(a,b,c);printf("c的三元组:\n");DispMat(c);}实验题5.5实现广义表的基本运算#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct lnode{ int tag; /*结点类型标识*/ union{ElemType data;struct lnode *sublist;}val;struct lnode *link; /*指向下一个元素*/} GLNode;extern GLNode *CreatGL(char *&s);extern void DispGL(GLNode *g);void Change(GLNode *&g,ElemType s,ElemType t) /*将广义表g中所有原子s 替换成t*/{if (g!=NULL){if (g->tag==1) /*子表的情况*/Change(g->val.sublist,s,t);else if (g->val.data==s) /*原子且data域值为s的情况*/g->val.data=t;Change(g->link,s,t);}}void Reverse(GLNode *&g) /*将广义表g所有元素逆置*/{GLNode *p,*q,*t;t=NULL;if (g!=NULL){p=g;while (p!=NULL) /*将同级的兄弟逆置*/{q=p->link;if (t==NULL){t=p;p->link=NULL;}else{p->link=t;t=p;}p=q;}g=t;p=g;while (p!=NULL){if (p->tag==1)Reverse(p->val.sublist);p=p->link;}}}int Same(GLNode *g1,GLNode *g2) /*判断两个广义表是否相同*/ {int s;if (g1==NULL && g2==NULL) /*均为NULL的情况*/return 1;else if ((g1==NULL && g2!=NULL) || (g1!=NULL && g2==NULL)) /*一个为NULL,另一不为NULL的情况*/return 0;else{s=1;while (g1!=NULL && g2!=NULL && s==1){if (g1->tag==1 && g2->tag==1)/*均为子表的情况*/s=Same(g1->val.sublist,g2->val.sublist);else if (g1->tag==0 && g2->tag==0)/*均为原子的情况*/{if (g1->val.data!=g2->val.data)s=0;}else /*一个为原子,另一为子表的情况*/s=0;g1=g1->link;g2=g2->link;}if (g1!=NULL || g2!=NULL) /*有一个子表尚未比较完时*/s=0;return s;}}ElemType MaxAtom(GLNode *g) /*求广义表g中最大的原子*/{ElemType m=0,m1; /*m赋初值0*/while (g!=NULL){if (g->tag==1) /*子表的情况*/{m1=MaxAtom(g->val.sublist); /*对子表递归调用*/if (m1>m) m=m1;}else{if (g->val.data>m) /*为原子时,进行原子比较*/m=g->val.data;}g=g->link;}return m;}void DelAtom(GLNode *&g,ElemType x) /*删除广义表g中的第一个为x原子*/{GLNode *p=g,*q,*pre;while (p!=NULL){q=p->link;if (p->tag==1) /*子表的情况*/DelAtom(p->val.sublist,x); /*对子表递归调用*/else{if (p->val.data==x) /*为原子时,进行原子比较*/{if (p==g)/*被删结点是本层的第1个结点*/{g=q;free(p); /*释放结pre=g;}else /*被删结{pre->link=q;free(p);}return;}}pre=p;p=q;}}void DelAtomAll(GLNode *&g,ElemType x) /*删除广义表g中的所有为x原子*/{GLNode *p=g,*q,*pre;while (p!=NULL){q=p->link;if (p->tag==1) /*子表的情况*/DelAtomAll(p->val.sublist,x); /*对子表递归调用*/else{if (p->val.data==x) /*为原子时,进行原子比较*/if (p==g)/*被删结点是本层的第1个结点*/{g=q;free(p); /*释放结pre=g;}else /*被删结{pre->link=q;free(p);}}pre=p;p=q;}}void PreOrder(GLNode *g) /*采用先根遍历g*/{if (g!=NULL){if (g->tag==0) /*为原子结点时*/printf("%c ",g->val.data);elsePreOrder(g->val.sublist); /*为子表时*/ PreOrder(g->link);}}void main(){GLNode *g1,*g2,*g3,*g4;char *str1="(a,(a),((a,b)),((a)),a)";char *str2="(a,(b),((c,d)),((e)),f)";char *str3="(a,(a,b),(a,b,c)))";char *str4="(a,(b),((c,d)),((e)),f)";g1=CreatGL(str1);printf("\n");printf(" 广义表g1:");DispGL(g1);printf("\n");printf(" 将广义表g1中所有'a'改为'b'\n");Change(g1,'a','b');printf(" 广义表g1:");DispGL(g1);printf("\n\n");g2=CreatGL(str2);printf(" 广义表g2:");DispGL(g2);printf("\n");printf(" 广义表g2中最大原子:%c\n",MaxAtom(g2));printf(" 将g2的元素逆置\n");Reverse(g2);printf(" 广义表g2:");DispGL(g2);printf("\n\n");printf(" 广义表g1和g2%s\n\n",(Same(g1,g2)?"相同":"不相同"));g3=CreatGL(str3);printf(" 广义表g3:");DispGL(g3);printf("\n");printf(" 删除广义表g3的第一个为'a'的原子\n");DelAtom(g3,'a');printf(" 广义表g3:");DispGL(g3);printf("\n\n");printf(" 删除广义表g3中的所有'a'原子\n");DelAtomAll(g3,'a');printf(" 广义表g3:");DispGL(g3);printf("\n\n");g4=CreatGL(str4);printf(" 广义表g4:");DispGL(g4);printf("\n");printf(" 采用先根遍历g4的结果:");PreOrder(g4);printf("\n\n");}。
数据结构实验报告及心得体会
2011~2012第一学期数据结构实验报告班级：信管一班学号：201051018姓名：史孟晨实验报告题目及要求一、实验题目设某班级有M（6）名学生，本学期共开设N（3）门课程，要求实现并修改如下程序（算法）。
1. 输入学生的学号、姓名和 N 门课程的成绩（输入提示和输出显示使用汉字系统），输出实验结果。
（15分）2. 计算每个学生本学期 N 门课程的总分，输出总分和N门课程成绩排在前 3 名学生的学号、姓名和成绩。
3. 按学生总分和 N 门课程成绩关键字升序排列名次，总分相同者同名次。
二、实验要求1．修改算法。
将奇偶排序算法升序改为降序。
（15分）2．用选择排序、冒泡排序、插入排序分别替换奇偶排序算法,并将升序算法修改为降序算法；。
（45分））3．编译、链接以上算法，按要求写出实验报告（25）。
4. 修改后算法的所有语句必须加下划线，没做修改语句保持按原样不动。
5．用A4纸打印输出实验报告。
三、实验报告说明实验数据可自定义，每种排序算法数据要求均不重复。
(1) 实验题目：《N门课程学生成绩名次排序算法实现》；(2) 实验目的：掌握各种排序算法的基本思想、实验方法和验证算法的准确性；(3) 实验要求：对算法进行上机编译、链接、运行；(4) 实验环境（Windows XP-sp3,Visual c++)；(5) 实验算法（给出四种排序算法修改后的全部清单）；(6) 实验结果（四种排序算法模拟运行后的实验结果）；(7) 实验体会（文字说明本实验成功或不足之处）。
三、实验源程序（算法）Score.c#include "stdio.h"#include "string.h"#define M 6#define N 3struct student{ char name[10];int number;int score[N+1]; /*score[N]为总分,score[0]-score[2]为学科成绩*/ }stu[M];void changesort(struct student a[],int n,int j){int flag=1,i;struct student temp;while(flag){ flag=0;for(i=1;i<n-1;i+=2) /*对所有奇数项进行一遍比较*/ if (a[i].score[j]>a[i+1].score[j]){ temp=a[i];a[i]=a[i+1];a[i+1]=temp;flag=1;}for(i=0;i<n-1;i+=2) /*对所有偶数项进行一遍比较*/if (a[i].score[j]>a[i+1].score[j]){ temp=a[i];a[i]=a[i+1];a[i+1]=temp;flag=1;}}}void print_score(struct student a[],int n,int j){ int i,k;printf(“ 奇偶交换成绩 %d 排序表",j+1);printf("\n");printf(" 名次学号姓名分数\n");k=1;for(i=0;k<N&&i<n;i++){ if(i>0&&a[i].score[j]!=a[i-1].score[j])k++;p rintf(" %4d ",k);p rintf("%4d",a[i].number);p rintf(" %s",a[i].name);p rintf(" %6d",a[i].score[j]);p rintf("\n");}}main(){ int i,j,k;for (i=0;i<M;i++) /*输入每个学生信息*/{ printf("请输入第 %d 名学生分数: ",i+1);printf("\n"); printf("姓名: ");s canf("%s",stu[i].name);printf("编号: ");scanf("%4d",&stu[i].number);printf("数据结构: ");scanf("%4d",&stu[i].score[0]);printf("离散数学: ");scanf("%4d",&stu[i].score[1]);printf("大学英语: ");scanf("%4d",&stu[i].score[2]);}for(i=0;i<M;i++) /*计算每个学生总分*/{ stu[i].score[N]=0;for(j=0;j<N;j++)stu[i].score[N]+=stu[i].score[j];}changesort(stu,M,N); /*对总分进行排序*/printf(" 学生总分成绩排序表\n");printf(" 名次学号姓名数据结构离散数学大学英语总分\n"); k=1;for(i=0;i<M;i++){ if(i>0&&stu[i].score[N]!=stu[i-1].score[N])k++;printf("%4d",k);printf(" %4d",stu[i].number);printf(" %s",stu[i].name);for(j=0;j<N+1;j++)printf(" %6d",stu[i].score[j]);printf("\n");}changesort(stu,M,0); /*对数据结构成绩进行排序*/print_score(stu,M,0); /*输出数据结构前 3 名同学成绩*/changesort(stu,M,1); /*对离散数学成绩进行排序*/print_score(stu,M,1); /*输出离散数学前 3 名同学成绩*/changesort(stu,M,2); /*对大学英语成绩进行排序*/print_score(stu,M,2); /*输出大学英语前 3 名同学成绩*/}源代码结果：请输入第1 名学生分数: 姓名: 史孟晨编号: 01数据结构: 87离散数学: 90大学英语: 78请输入第2 名学生分数: 姓名: 袁欣编号: 02数据结构: 78离散数学: 80大学英语: 92请输入第 3 名学生分数: 姓名: 赵宇编号: 03数据结构: 88离散数学: 76大学英语: 95请输入第4 名学生分数: 姓名: 滕芷编号: 04数据结构: 79离散数学: 84大学英语: 88请输入第5 名学生分数: 姓名: 张一析编号: 05数据结构: 78离散数学: 68大学英语: 91请输入第6 名学生分数: 姓名: 白晓彤编号: 06数据结构: 88离散数学: 76大学英语: 90学生总分成绩排序表名次学号姓名数据结构离散数学大学英语总分1 5 张一析78 68 91 2372 2 袁欣78 80 92 2503 4 滕芷79 84 88 2514 6 白晓彤88 76 90 2545 1 史孟晨87 90 78 2556 3 赵宇88 76 95 259 奇偶交换成绩1 排序表名次学号姓名分数1 5 张一析781 2 袁欣782 4 滕芷793 1 史孟晨87奇偶交换成绩2 排序表名次学号姓名分数1 5 张一析682 6 白晓彤762 3 赵宇763 2 袁欣80奇偶交换成绩3 排序表名次学号姓名分数1 1 史孟晨782 4 滕芷883 6 白晓彤90Press any key to continue#include "stdio.h"#include "string.h"#define M 6#define N 3void changesort(struct student a[],int n,int j);void print_score(struct student a[],int n,int j);struct student{char name[10];int number;int score[N+1]; /*score[N]为总分,score[0]-score[2]为学科成绩*/}stu[M];main(){int i,j,k;for (i=0;i<M;i++) /*输入每个学生信息*/{printf("请输入第%d 名学生分数: ",i+1);printf("\n");printf("姓名: ");scanf("%s",stu[i].name);printf("编号: ");scanf("%4d",&stu[i].number);printf("数据结构: ");scanf("%4d",&stu[i].score[0]);printf("离散数学: ");scanf("%4d",&stu[i].score[1]);printf("大学英语: ");scanf("%4d",&stu[i].score[2]);}for(i=0;i<M;i++) /*计算每个学生总分*/{stu[i].score[N]=0;for(j=0;j<N;j++)stu[i].score[N]+=stu[i].score[j];changesort(stu,M,N); /*对总分进行排序*/printf(" 学生总分成绩排序表\n");printf(" 名次学号姓名数据结构离散数学大学英语总分\n");k=0;for(i=0;i<M+1;i++){if(i>0&&stu[i].score[N]!=stu[i-1].score[N]){k++;printf("%4d",k);printf(" %4d",stu[i-1].number);printf(" %s",stu[i-1].name);for(j=0;j<N+1;j++){printf(" %6d",stu[i-1].score[j]);}}printf("\n");}changesort(stu,M,0); /*对数据结构成绩进行排序*/print_score(stu,M,0); /*输出数据结构前3 名同学成绩*/changesort(stu,M,1); /*对离散数学成绩进行排序*/print_score(stu,M,1); /*输出离散数学前3 名同学成绩*/changesort(stu,M,2); /*对大学英语成绩进行排序*/print_score(stu,M,2); /*输出大学英语前3 名同学成绩*/}void changesort(struct student a[],int n,int j){int flag=1,i;struct student temp;while(flag){flag=0;for(i=1;i<n-1;i+=2) /*对所有奇数项进行一遍比较*/if (a[i].score[j] < a[i+1].score[j]){temp=a[i];a[i]=a[i+1];a[i+1]=temp;flag=1;}for(i=0;i<n-1;i+=2) /*对所有偶数项进行一遍比较*/if (a[i].score[j] < a[i+1].score[j]){temp=a[i];a[i]=a[i+1];a[i+1]=temp;flag=1;}}}void print_score(struct student a[],int n,int j){int i,k;printf(" 奇偶交换成绩%d 排序表",j+1);printf("\n");printf(" 名次学号姓名分数\n");k=1;for(i=0;k<N&&i<n;i++){if(i>0&&a[i].score[j]!=a[i-1].score[j])k++;printf(" %4d ",k);printf("%4d",a[i].number);printf(" %s",a[i].name);printf(" %6d",a[i].score[j]);printf("\n");}}升序改降序：请输入第1 名学生分数:姓名: 史孟晨编号: 01数据结构: 87离散数学: 90大学英语: 78请输入第2 名学生分数:姓名: 袁欣编号: 02数据结构: 78离散数学: 80大学英语: 92请输入第3 名学生分数:姓名: 赵宇编号: 03数据结构: 88离散数学: 76大学英语: 95请输入第4 名学生分数:姓名: 滕芷编号: 04数据结构: 79离散数学: 84大学英语: 88请输入第5 名学生分数:姓名: 张一析编号: 05数据结构: 78离散数学: 68大学英语: 91请输入第6 名学生分数:姓名: 白晓彤编号: 06数据结构: 88离散数学: 76大学英语: 90学生总分成绩排序表名次学号姓名数据结构离散数学大学英语总分1 3 赵宇88 76 95 2592 1 史孟晨87 90 78 2553 6 白晓彤88 76 90 2544 4 滕芷79 84 88 2515 2 袁欣78 80 92 2506 5 张一析78 68 91 237 奇偶交换成绩1 排序表名次学号姓名分数1 3 赵宇881 6 白晓彤882 1 史孟晨873 4 滕芷79奇偶交换成绩2 排序表名次学号姓名分数1 1 史孟晨902 4 滕芷843 2 袁欣80 奇偶交换成绩3 排序表名次学号姓名分数1 3 赵宇952 2 袁欣923 5 张一析91 Press any key to continue#include "stdio.h"#include "string.h"#define M 6#define N 3void changesort(struct student a[],int n,int j);void print_score(struct student a[],int n,int j);struct student{char name[10];int number;int score[N+1]; /*score[N]为总分,score[0]-score[2]为学科成绩*/}stu[M];main(){int i,j,k;for (i=0;i<M;i++) /*输入每个学生信息*/{printf("请输入第%d 名学生分数: ",i+1);printf("\n");printf("姓名: ");scanf("%s",stu[i].name);printf("编号: ");scanf("%4d",&stu[i].number);printf("数据结构: ");scanf("%4d",&stu[i].score[0]);printf("离散数学: ");scanf("%4d",&stu[i].score[1]);printf("大学英语: ");scanf("%4d",&stu[i].score[2]);}for(i=0;i<M;i++) /*计算每个学生总分*/{stu[i].score[N]=0;for(j=0;j<N;j++)stu[i].score[N]+=stu[i].score[j];changesort(stu,M,N); /*对总分进行排序*/printf(" 学生总分成绩排序表\n");printf(" 名次学号姓名数据结构离散数学大学英语总分\n");k=0;for(i=0;i<M+1;i++){if(i>0&&stu[i].score[N]!=stu[i-1].score[N]){k++;printf("%4d",k);printf(" %4d",stu[i-1].number);printf(" %s",stu[i-1].name);for(j=0;j<N+1;j++){printf(" %6d",stu[i-1].score[j]);}}printf("\n");}changesort(stu,M,0); /*对数据结构成绩进行排序*/print_score(stu,M,0); /*输出数据结构前3 名同学成绩*/changesort(stu,M,1); /*对离散数学成绩进行排序*/print_score(stu,M,1); /*输出离散数学前3 名同学成绩*/changesort(stu,M,2); /*对大学英语成绩进行排序*/print_score(stu,M,2); /*输出大学英语前3 名同学成绩*/}void changesort(struct student a[],int n,int j){int flag=1,i,m,k;struct student temp;while(flag){flag=0;for(i=0;i<n-1;i++) /*选择排序法*/{k=i;for(m=i+1;m<n;m++)if (a[m].score[j]>a[k].score[j]){k=m;temp=a[i];a[i]=a[k];a[k]=temp;flag=1;}}}}void print_score(struct student a[],int n,int j){int i,k;printf(" 选择交换成绩%d 排序表",j+1);printf("\n");printf(" 名次学号姓名分数\n");k=1;for(i=0;k<N&&i<n;i++){if(i>0&&a[i].score[j]!=a[i-1].score[j])k++;printf(" %4d ",k);printf("%4d",a[i].number);printf(" %s",a[i].name);printf(" %6d",a[i].score[j]);printf("\n");}}简单选择：请输入第1 名学生分数:姓名: 史孟晨编号: 01数据结构: 87离散数学: 90大学英语: 78请输入第2 名学生分数:姓名: 袁欣编号: 02数据结构: 78离散数学: 80大学英语: 92请输入第3 名学生分数:姓名: 赵宇编号: 03数据结构: 88离散数学: 76大学英语: 95请输入第4 名学生分数:姓名: 滕芷编号: 04数据结构: 79离散数学: 84大学英语: 88请输入第5 名学生分数:姓名: 张一析编号: 05数据结构: 78离散数学: 68大学英语: 91请输入第6 名学生分数:姓名: 白晓彤编号: 06数据结构: 88离散数学: 76大学英语: 90学生总分成绩排序表名次学号姓名数据结构离散数学大学英语总分1 3 赵宇88 76 95 2592 1 史孟晨87 90 78 2553 6 白晓彤88 76 90 2544 4 滕芷79 84 88 2515 2 袁欣78 80 92 2506 5 张一析78 68 91 237 选择交换成绩1 排序表名次学号姓名分数1 3 赵宇881 6 白晓彤882 1 史孟晨873 4 滕芷79选择交换成绩2 排序表名次学号姓名分数1 1 史孟晨902 4 滕芷843 2 袁欣80 选择交换成绩3 排序表名次学号姓名分数1 3 赵宇952 2 袁欣923 5 张一析91 Press any key to continue#include "stdio.h"#include "string.h"#define M 6#define N 3void changesort(struct student a[],int n,int j);void print_score(struct student a[],int n,int j);struct student{char name[10];int number;int score[N+1]; /*score[N]为总分,score[0]-score[2]为学科成绩*/}stu[M];main(){int i,j,k;for (i=0;i<M;i++) /*输入每个学生信息*/{printf("请输入第%d 名学生分数: ",i+1);printf("\n");printf("姓名: ");scanf("%s",stu[i].name);printf("编号: ");scanf("%4d",&stu[i].number);printf("数据结构: ");scanf("%4d",&stu[i].score[0]);printf("离散数学: ");scanf("%4d",&stu[i].score[1]);printf("大学英语: ");scanf("%4d",&stu[i].score[2]);}for(i=0;i<M;i++) /*计算每个学生总分*/{stu[i].score[N]=0;for(j=0;j<N;j++)stu[i].score[N]+=stu[i].score[j];changesort(stu,M,N); /*对总分进行排序*/printf(" 学生总分成绩排序表\n");printf(" 名次学号姓名数据结构离散数学大学英语总分\n");k=0;for(i=0;i<M+1;i++){if(i>0&&stu[i].score[N]!=stu[i-1].score[N]){k++;printf("%4d",k);printf(" %4d",stu[i-1].number);printf(" %s",stu[i-1].name);for(j=0;j<N+1;j++){printf(" %6d",stu[i-1].score[j]);}}printf("\n");}changesort(stu,M,0); /*对数据结构成绩进行排序*/print_score(stu,M,0); /*输出数据结构前3 名同学成绩*/changesort(stu,M,1); /*对离散数学成绩进行排序*/print_score(stu,M,1); /*输出离散数学前3 名同学成绩*/changesort(stu,M,2); /*对大学英语成绩进行排序*/print_score(stu,M,2); /*输出大学英语前3 名同学成绩*/}void changesort(struct student a[],int n,int j){{int flag=1,i;struct student temp;while(flag){flag=0;for(i=0;i<n;i++) /*冒泡排序法*/if (a[i].score[j] < a[i+1].score[j]){temp=a[i];a[i]=a[i+1];a[i+1]=temp;flag=1;}}}}void print_score(struct student a[],int n,int j){int i,k;printf(" 冒泡交换成绩%d 排序表",j+1);printf("\n");printf(" 名次学号姓名分数\n");k=1;for(i=0;k<N&&i<n;i++){if(i>0&&a[i].score[j]!=a[i-1].score[j])k++;printf(" %4d ",k);printf("%4d",a[i].number);printf(" %s",a[i].name);printf(" %6d",a[i].score[j]);printf("\n");}}运行结果：请输入第1 名学生分数:姓名: 史孟晨编号: 01数据结构: 87离散数学: 90大学英语: 78请输入第2 名学生分数:姓名: 袁欣编号: 02数据结构: 78离散数学: 80大学英语: 92请输入第3 名学生分数:姓名: 赵宇编号: 03数据结构: 88离散数学: 76大学英语: 95请输入第4 名学生分数:姓名: 滕芷编号: 04数据结构: 79离散数学: 84大学英语: 88请输入第5 名学生分数:姓名: 张一析编号: 05数据结构: 78离散数学: 68大学英语: 91请输入第6 名学生分数:姓名: 白晓彤编号: 06数据结构: 88离散数学: 76大学英语: 90学生总分成绩排序表名次学号姓名数据结构离散数学大学英语总分1 3 赵宇88 76 95 2592 1 史孟晨87 90 78 2553 6 白晓彤88 76 90 2544 4 滕芷79 84 88 2515 2 袁欣78 80 92 2506 5 张一析78 68 91 237 冒泡交换成绩1 排序表名次学号姓名分数1 3 赵宇881 6 白晓彤882 1 史孟晨873 4 滕芷79冒泡交换成绩2 排序表名次学号姓名分数1 1 史孟晨902 4 滕芷843 2 袁欣80冒泡交换成绩3 排序表名次学号姓名分数1 3 赵宇952 2 袁欣923 5 张一析91 Press any key to continueJusertsort.c#include "stdio.h"#include "string.h"#define M 6#define N 3void changesort(struct student a[],int n,int j);void print_score(struct student a[],int n,int j);struct student{char name[10];int number;int score[N+1]; /*score[N]为总分,score[0]-score[2]为学科成绩*/}stu[M];main(){int i,j,k;for (i=0;i<M;i++) /*输入每个学生信息*/{printf("请输入第%d 名学生分数: ",i+1);printf("\n");printf("姓名: ");scanf("%s",stu[i].name);printf("编号: ");scanf("%4d",&stu[i].number);printf("数据结构: ");scanf("%4d",&stu[i].score[0]);printf("离散数学: ");scanf("%4d",&stu[i].score[1]);printf("大学英语: ");scanf("%4d",&stu[i].score[2]);}for(i=0;i<M;i++) /*计算每个学生总分*/{stu[i].score[N]=0;for(j=0;j<N;j++)stu[i].score[N]+=stu[i].score[j];}changesort(stu,M,N); /*对总分进行排序*/printf(" 学生总分成绩排序表\n");printf(" 名次学号姓名数据结构离散数学大学英语总分\n");k=0;for(i=0;i<M+1;i++){if(i>0&&stu[i].score[N]!=stu[i-1].score[N]){k++;printf("%4d",k);printf(" %4d",stu[i-1].number);printf(" %s",stu[i-1].name);for(j=0;j<N+1;j++){printf(" %6d",stu[i-1].score[j]);}}printf("\n");}changesort(stu,M,0); /*对数据结构成绩进行排序*/print_score(stu,M,0); /*输出数据结构前3 名同学成绩*/changesort(stu,M,1); /*对离散数学成绩进行排序*/print_score(stu,M,1); /*输出离散数学前3 名同学成绩*/changesort(stu,M,2); /*对大学英语成绩进行排序*/print_score(stu,M,2); /*输出大学英语前3 名同学成绩*/}void changesort(struct student a[],int n,int j){int i, m;struct student temp;/*插入排序法*/for(i=1; i<n; i++){temp = a[i];for(m=i; m>0 && temp.score[j] > a[m-1].score[j]; m--){a[m] = a[m-1];}a[m] = temp;}}void print_score(struct student a[],int n,int j){int i,k;printf(" 插入交换成绩%d 排序表",j+1);printf("\n");printf(" 名次学号姓名分数\n");k=1;for(i=0;k<N&&i<n;i++){if(i>0&&a[i].score[j]!=a[i-1].score[j])k++;printf(" %4d ",k);printf("%4d",a[i].number);printf(" %s",a[i].name);printf(" %6d",a[i].score[j]);printf("\n");}}请输入第1 名学生分数:姓名: 史孟晨编号: 01数据结构: 87离散数学: 90大学英语: 78请输入第2 名学生分数:姓名: 袁欣编号: 02数据结构: 78离散数学: 80大学英语: 92请输入第3 名学生分数:姓名: 赵宇编号: 03数据结构: 88离散数学: 76大学英语: 95请输入第4 名学生分数:姓名: 滕芷编号: 04数据结构: 79离散数学: 84大学英语: 88请输入第5 名学生分数:姓名: 张一析编号: 05数据结构: 78离散数学: 68大学英语: 91请输入第6 名学生分数:姓名: 白晓彤编号: 06数据结构: 88离散数学: 76大学英语: 90学生总分成绩排序表名次学号姓名数据结构离散数学大学英语总分1 3 赵宇88 76 95 2592 1 史孟晨87 90 78 2553 6 白晓彤88 76 90 2544 4 滕芷79 84 88 2515 2 袁欣78 80 92 2506 5 张一析78 68 91 237 插入交换成绩1 排序表名次学号姓名分数1 3 赵宇881 6 白晓彤882 1 史孟晨873 4 滕芷79插入交换成绩2 排序表名次学号姓名分数1 1 史孟晨902 4 滕芷843 2 袁欣80插入交换成绩3 排序表名次学号姓名分数1 3 赵宇952 2 袁欣923 5 张一析91Press any key to continue心得体会本学期开设的《数据结构基础》课程已经告一段落，现就学习体会进行学习总结.这是一门纯属于设计的科目，它需用把理论变为上机调试。
数据结构上机实验报告
数据结构上机实验报告学院：电子工程学院专业：信息对抗技术姓名：学号：教师：饶鲜日期：目录实验一线性表 ........................................................................................................ - 4 -一、实验目的.................................................................................................... - 4 -二、实验代码.................................................................................................... - 4 -三、实验结果.................................................................................................. - 14 -四、个人思路.................................................................................................. - 15 - 实验二栈和队列 .................................................................................................. - 15 -一、实验目的.................................................................................................. - 15 -二、实验代码.................................................................................................. - 16 -三、实验结果.................................................................................................. - 24 -四、个人思路.................................................................................................. - 25 - 实验三数组 .......................................................................................................... - 26 -一、实验目的.................................................................................................. - 26 -二、实验代码.................................................................................................. - 26 -三、实验结果.................................................................................................. - 28 -四、个人思路.................................................................................................. - 28 - 实验四树 .............................................................................................................. - 29 -一、实验目的.................................................................................................. - 29 -二、实验代码.................................................................................................. - 29 -三、实验结果.................................................................................................. - 39 -四、个人思路.................................................................................................. - 39 -实验一线性表一、实验目的1．熟悉线性表的顺序和链式存储结构2．掌握线性表的基本运算3．能够利用线性表的基本运算完成线性表应用的运算二、实验代码1．设有一个线性表E={e1, e2, … , e n-1, e n}，设计一个算法，将线性表逆置，即使元素排列次序颠倒过来，成为逆线性表E’={ e n, e n-1 , … , e2 , e1 }，要求逆线性表占用原线性表空间，并且用顺序表和单链表两种方法表示，分别用两个程序来完成。
《数据结构》上机实验的目的和要求
《数据结构》上机实验的目的和要求
通过上机实验加深对课程内容的理解，增加感性认识，提高软件设计、编写及调试程序的能力。
要求所编的程序能正确运行，并提交实验报告。
实验报告的基本要求为：
1、需求分析：陈述程序设计的任务，强调程序要做什么，明确规定：
（1）输入的形式和输出值的范围；
（2）输出的形式；
（3）程序所能达到的功能；
（4）测试数据：包括正确的输入输出结果和错误的输入及输出结果。
2、概要设计：说明用到的数据结构定义、主程序的流程及各程序模块之间的调用关系。
3、详细设计：提交带注释的源程序或者用伪代码写出每个操作所涉及的算法。
4、调试分析：
（1）调试过程中所遇到的问题及解决方法；
（2）算法的时空分析；
（3）经验与体会。
5、用户使用说明：说明如何使用你的程序，详细列出每一步操作步骤。
6、测试结果：列出对于给定的输入所产生的输出结果。
若有可能，测试随输入规模的
增长所用算法的实际运行时间的变化。
数据结构上机报告-范例
intDelete_Sq(SqList &L, ElemType x) //删除找到的第一个元素x
intDeleteAll_Sq(SqList &L,ElemType x) //删除所有值为x的元素
intListDelete_Sq(SqList &L,inti,int&e) //删除第i个元素
intLocateElem_Sq(SqList L, ElemType e) //查找元素e，若存在，返回位置，否则返回0
voidMergeList_Sq(SqList La,SqList Lb,SqList &Lc) //合并两个有序表
基本要求
1.实现顺序表的基本操作，包括顺序表的初始化、第i个元素前插入一个新的元素、删除第i个元素、查找某元素、顺序表的销毁。
2.写一个函数，建立并显示含有n个整数的顺序表
3.写一个函数，实现对有序表（非递减）插入一个元素的功能
4.写一个函数，实现两个有序（非递减）表合并生成新的有序表的功能
5.编写一个界面友好的测试程序，能够对各种边界条件进行测试，验证上述算法的正确性。
《数据结构》上机报告
2011年月日
姓名：
学号：
班级：
得分：
试验题目
顺序表
实验目的
理解顺序表的逻辑结构和存储结构，熟练掌握顺序表的相关操作。
问题描述
顺序表是指采用顺序存储结构的线性表，它利用内存中的一片连续存储区域存放表中的所有元素。可以根据需要对表中的所有数据进行访问，元素的插入和删除可以在表中的任何位置进行。
《数据结构》上机作业——实验报告（五）[推荐]
![《数据结构》上机作业——实验报告（五）[推荐]](https://img.taocdn.com/s3/m/b4e8d97ec950ad02de80d4d8d15abe23482f032f.png)
《数据结构》上机作业——实验报告（五）[推荐]第一篇：《数据结构》上机作业——实验报告(五)[推荐]“计算机软件技术基础”课程实验报告（五）实验名称：排序算法班级_______ 姓名__________ 学号______实验日期：实验机时：3 学时实验成绩：-----------------一.实验目的：1、掌握主要排序算法的思想和实现技术。
二.实验内容：1、设计一程序，要求：输入学生“软件技术基础”课的成绩（学号、姓名、平均成绩、总学分）；按总学分对学生数据进行排序。
（要求：实现任选3种排序算法）三.程序：1、程序规范（输入数据、功能、输出数据）2、设计分析（数据表示、算法）3、C源代码（电子版）四.程序调试：第二篇：《数据结构》上机作业——实验报告(六)“计算机软件技术基础”课程实验报告（六）实验名称：数据库及SQL语言班级_______ 姓名__________ 学号______实验日期：实验机时：3 学时实验成绩：-----------------一.实验目的：1、学习数据库设计的一般过程及相关技术；2、学习access数据库管理系统；3、掌握数据库的输入、查询、更新操作。
二.实验内容：1、需求陈述：某校图书馆要建立一个图书数据管理系统。
该图书馆的图书（书名、分类号、作者、出版社）存放在不同的借阅室（室名），读者（姓名、系名、类别）在书架上找到所需图书后，可以到服务台办理借阅（借阅时间）。
设计要求：λ分析需求，建立数据库的概念模型；λ将概念模型转换为关系模型（注意：是否需要作规范化处理）；λ写出创建基本表的SQL语句；λ写出以下查询要求的SQL语句：（1）所有“高等数学习题集”书的信息；（2）读者“李林”借了什么书？（3）“社会学原理”在哪个借阅室？2、在access数据库管理系统中建立所设计的关系表；3、向各表中输入一组实验数据（元组）（注意：关系完整性）；4、对数据库进行查询。
三.实验结果：1、实体-关系图；2、数据库表；3、创建基本表的语句；4、查询语句。
数据结构与算法上机实验报告参考模板
数据结构与算法B上机实验报告第1次2011-10-02 顺序表的实现和基本操作第2次2011-10-29 二叉树的实现和递归遍历第3次2011-11-23 内部排序第4次2011-12-dd 实现图从邻接矩阵到邻接表存储转化第一次线性表数据结构一、上机实习题目线性链表操作——插入、删除、合并、排序、查找二数据结构设计（算法设计）源程序（#include <iostream>#define MaxSize 100using namespace std;typedef int ElemType;class SeqList{ElemType list[MaxSize];int length;public:SeqList() {length=0;}void SeqListSort(int i,ElemType x);void SeqListCreat(int n);void SeqListInset(int i,ElemType x);void SeqListDelete(int i);void SeqListMerge();int GetLength(){return length;}int SeqListFind(ElemType x);int SeqListIsEmpty();void SeqListPrint();}Mylist1,Mylist2;//创建顺序表void SeqList::SeqListCreat(int n){ElemType x;cout<<"请输入数据元素:";for (int i=0;i<n;i++){cin>>x;list[i]=x;length++;}}//对顺序表进行排序void SeqList::SeqListSort(int i,ElemType x) {for(int k=0;k<length;k++){for(i=k+1;i<=length;i++){if(list[k]>list[i]){x=list[k];list[k]=list[i];list[i]=x;}}}}//在顺序表L中的第i个位置插入新元素x void SeqList::SeqListInset(int i,ElemType x) {int k;if(length>=MaxSize)cout<<"表已满，无法插入！"<<endl;else if(i<0||i>length)cout<<"参数i不合理！"<<endl;else{for (k=length;k>=i;k--){list[k]=list[k-1];}list[i-1]=x;length++;}}//删除第i个位置的数据元素void SeqList::SeqListDelete(int i){int k;if(!SeqListIsEmpty())cout<<"表已空，无法删除！"<<endl;else if(i<0||i>length)cout<<"参数i不合理！"<<endl;elsefor(k=i-1;k<length;k++)list[k]=list[k+1];length--;}//查找元素x在表中的位置int SeqList::SeqListFind(ElemType x) {int i=0;while(i<length&&list[i]!=x)i++;if(i>length)return -1;elsereturn i+1;}//判断顺序表是否为空int SeqList::SeqListIsEmpty(){if(length<=0)return 0;else return 1;}//将顺序表显示在屏幕上void SeqList::SeqListPrint(){if(!SeqListIsEmpty())cout<<"空表！"<<endl;elsefor(int i=0;i<length;i++)cout<<list[i]<<" ";cout<<endl;}int main(){SeqList Mylist1,Mylist2;int i,n,flag=1,select;ElemType x;cout<<"1. 建立顺序表\n";cout<<"2. 对顺序表进行排序\n";cout<<"3. 求x数值的位置\n";cout<<"4. 在第i个位置插入新元素x\n"; cout<<"5. 删除第i个位置上的数值\n"; cout<<"6. 将两个顺序表合并\n";cout<<"7. 退出\n";cout<<endl;while (flag){cout<<"请选择操作：";cin>>select;switch(select){case 1:cout<<"请输入顺序表1的长度：";cin>>n;Mylist1.SeqListCreat(n);cout<<"你所输入的顺序表1为：";Mylist1.SeqListPrint();cout<<"请输入顺序表2的长度：";cin>>n;Mylist2.SeqListCreat(n);cout<<"你所输入的顺序表2为：";break;case 2:cout<<"请选择所要排序的顺序表1或2："; cin>>n;if(n==1){Mylist1.SeqListSort(i,x);cout<<"排序后的顺序表1为:";Mylist1.SeqListPrint();}else{Mylist2.SeqListSort(i,x);cout<<"排序后的顺序表2为:";Mylist2.SeqListPrint();}break;case 3:cout<<"请输入x的值：";cin>>x;i=Mylist1.SeqListFind(x);if(i!=-1) cout<<"x的位置为："<<i<<endl;else cout<<"没有找到！";break;case 4:cout<<"请输入要插入的元素的位置和数值x："; cin>>i>>x;cout<<"插入后的顺序表为:";Mylist1.SeqListPrint();break;case 5:cout<<"请输入要删除的元素的位置：";cin>>i;Mylist1.SeqListDelete(i);cout<<"删除后的顺序表为：";Mylist1.SeqListPrint();break;case 6:cout<<"合并后的顺序表为：\n";Mylist1.SeqListPrint();Mylist2.SeqListPrint();break;case 7:flag=0;break;}}}三运行结果为：四、上机环境和使用语言（计算机程序实现）Visual C++。
《数据结构》上机实验要求
《数据结构》课程实验内容与要求一、课程简介本课程着重讲述①线性结构、树型结构、图等典型数据结构的逻辑特点、存储结构及其相应的基本算法。
②各种查找算法③典型内部排序算法。
二、实验的作用、地位和目的数据结构是一门技术基础课，通过实验深刻理解各种逻辑结构、存储结构的特性，培养为实际问题分析其数据对象、基本操作，选择逻辑结构、存储结构灵活应用基本算法，设计出具有专业水准的应用程序的能力。
三、实验方式与要求①首先要求学生在课下完成问题分析、算法设计，基本完成程序设计。
②实验时，每位学生使用一台微机，独立调试，完成程序。
③程序调试好后，由指导教师检测运行结果，并要求学生回答相关的问题。
教师评出检查成绩。
④学生记录程序的输入数据，运行结果及源程序。
⑤在一周内完成实验报告。
四、考核方式与实验报告要求实验成绩由指导教师根据学生的实验完成情况、源程序质量、回答问题情况、实验报告质量、实验纪律等方面给分。
学生在实验后的一周内提交实验报告。
实验报告首页按学校统一印刷的实验报告模版书写。
实验报告中应包括如下内容：☐实验内容按任课教师下达的实验任务填写（具体实验题目和要求）；☐实验过程与实验结果应包括如下主要内容：算法设计思路简介算法描述：可以用自然语言、伪代码或流程图等方式算法的实现和测试结果：包括算法运行时的输入、输出，实验中出现的问题及解决办法等☐源程序清单与实验结果或其它说明可打印，并装订在实验报告首页之后。
☐实验报告雷同者，本次实验成绩为0分或雷同实验报告平分得分五、实验的软硬件环境硬件环境：PⅡ以上微型计算机软件环境：Windows98/2000, VC++6.0或turbo C六、实验内容安排实验一线性表应用实验时间：2012年3月16日，7-8节（地点：7-215）实验目的：理解线性表的逻辑特点；掌握顺序表、链表存储结构，以及线性表的基本操作，如插入、删除、查找，以及线性表合并等操作在顺序存储结构和链式存储结构上的实现算法，并能够在实际问题背景下的灵活运用线性表来解决问题，实现相应算法。
数据结构上机实验(两次共五题).
数据结构上机实验（两次共五题）
1、约瑟夫环：将编号为1，2，…，n的n个人按顺时针方向围坐一圈，每人持
有一个密码（正整数）。
一开始任选一个正整数作为报数上限值m，从第一个开始按顺时针方向自1开始报数，报到m时停止报数。
报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。
试设计一个程序求出出列顺序。
设m 的初值为20，密码为：3，1，7，2，4，8，4。
2、编一程序：①建立一个数据域为1至10的带头结点的链表；
②将此链表就地逆转。
3、编写构造Huffman树和Huffman编码的程序。
已知：字符a，b，c，d，e，f，g的权值分别为{4，10，8，5，3，1，2}
4、编一程序算出教材中图7.30（p185）的关键路径
5、一程序实现堆排序。
已知输入关键字序列为：49，38，65，97，76，13，27，48
要求输出每趟排序的结果。
数据结构上机实验报告
{ while (i<S.size() && j<P.size())//当找到或者找到头时循环结束 { if (S[i] == P[j]) { i++; j++;} else{ i = i - j + 1; j = 0; }//失配时从下一位继续找 } if (j == P.size()){//找到就输出这一行 cout << "第" << linenumb << "行" << S << endl； }
}
3. 主程序的伪码 ：
void main(){ cout << "请输入文件名" << endl; cin >> filename;
ifstream infile(filename.c_str()); cout << "请输入待查找的字符串" << endl; cin >> P; while (getline(infile, S))//读完所有行结束 {
linenumb++; Find(S, P, linenumb); } infile.close(); } int Find(string S, string P, int linenumb) { int i = 0, j = 0; while (i<S.size() && j<P.size())//当找到或者找到头时循环结束 { if (S[i] == P[j]) {
数据结构上机实验指导书
计算机系第一部分数据结构课程实验概述一．实验目的《数据结构》是计算机专业的主干课程和必修课程之一，其目的是让大家学习、分析和研究数据对象特征，掌握数据组织方法和计算机的表示方法，以便选择合适的数据逻辑结构和存储结构，设计相应的运算操作，把现实世界中的问题转化为计算机内部的表示与处理的方法，要求掌握算法的时间、空间复杂度分析基本技术，培养良好的程序设计风格，掌握进行复杂程序设计的技能。
在计算机科学领域，尤其是在系统软件和应用软件的设计和应用中要用到各种数据结构，因此，掌握数据结构对提高软件设计和程序编制水平有很大的帮助。
二．实验要求2.1实验步骤设计步骤的规范不但可以培养学生科学的工作方法和作风，而且还能有效地减少错误，提高工作效率。
因此必须严格执行良好的实验步骤规范（包括上机操作规范）。
本课程实验的基本步骤是：2.1.1问题分析充分地分析和理解问题本身，明确问题要求做什么。
对问题的描述应避开算法和所涉及的数据类型，而是对所需完成的任务作出明确的回答。
例如；输入、输出数据的类型、值的范围以及形式等。
同时为调试程序准备好测试数据，包含合法的输入数据和非法形式输入的数据。
2.1.2设计和编码设计即是对问题描述中涉及的操作对象定义相应的数据类型，定义主程序模块和各抽象数据类型；定义相应的存储结构并写出各过程和函数的伪码算法。
在这个过程中，要综合考虑系统功能，使得系统结构清晰、合理、简单和易于调试。
编码即把详细设计的结果进一步求精为程序设计语言程序，写出源程序。
对程序中的疑问应作出记号，以便上机时注意解决。
每个明确的功能模块程序一般不超过60行，程序的每一行不得超过60个字符，否则要进一步划分。
2.1.3上机前程序静态检查上机前程序静态检查可有效提高调试效率，减少上机调试程序时的无谓错误。
静态检查主要有两种途径：用一组测试数据手工执行程序；通过阅读或给别人讲解自己的程序而深入全面地理解程序逻辑。
把程序中的明显错误事先排除。
《数据结构》上机实验报告—利用栈实现迷宫求解
《数据结构》上机实验报告—利用栈实现迷宫求解实验目的：掌握栈的基本操作和迷宫求解的算法，并能够利用栈实现迷宫求解。
实验原理：迷宫求解是一个常见的路径问题，其中最常见的方法之一是采用栈来实现。
栈是一种先进后出的数据结构，适用于这种类型的问题。
实验步骤：1.创建一个迷宫对象，并初始化迷宫地图。
2.创建一个栈对象，用于存储待探索的路径。
3.将起点入栈。
4.循环执行以下步骤，直到找到一个通向终点的路径或栈为空：a)将栈顶元素出栈，并标记为已访问。
b)检查当前位置是否为终点，若是则路径已找到，结束。
c)检查当前位置的上、下、左、右四个方向的相邻位置，若未访问过且可以通行，则将其入栈。
5.若栈为空，则迷宫中不存在通向终点的路径。
实验结果：经过多次实验，发现利用栈实现迷宫求解的算法能够较快地找到一条通向终点的路径。
在实验中，迷宫的地图可通过一个二维数组表示，其中0表示可通行的路径，1表示墙壁。
实验结果显示，该算法能够正确地找出所有可行的路径，并找到最短路径。
实验结果还显示，该算法对于大型迷宫来说，解决速度相对较慢。
实验总结：通过本次实验，我掌握了利用栈实现迷宫求解的算法。
栈作为一种先进后出的数据结构，非常适合解决一些路径的问题。
通过实现迷宫求解算法，我深入了解了栈的基本操作，并学会运用栈来解决实际问题。
此外，我还了解到迷宫求解是一个复杂度较高的问题，对于大型迷宫来说，解决时间较长。
因此，在实际应用中需要权衡算法的速度和性能。
在今后的学习中，我将进一步加深对栈的理解，并掌握其他数据结构和算法。
我还将学习更多的路径算法，以便更好地解决迷宫类问题。
掌握这些知识将有助于我解决更加复杂的问题，并提升编程能力。
数据结构上机实验报告
数据结构上机实验报告1. 实验目的本次实验旨在通过编写程序，掌握和理解常见的数据结构及其应用。
2. 实验环境与工具- 操作系统：Windows 10- 开发语言：C++- 集成开发环境（IDE）：Visual Studio Code3. 实验内容及步骤3.1 线性表操作演示程序设计与分析步骤：a) 设计一个线性表类，并包含以下基本功能：i) 初始化线性表；ii) 插入元素到指定位置；iii) 删除指定位置的元素；iv) 获取指定位置处的元素值。
b）使用该线性表类进行一系列测试，验证各个功能是否正常运行。
记录并分析每个函数调用所消耗时间以评估算法效率。
3.2 栈和队列综合应用设计与模拟步骤:a）根据给出问题需求，在已有栈、队列等相关代码基础上完成如下任务：i）利用两个堆栈来模拟浏览器前进后退功能;ii）使用循环链式存储结构表示双向链队, 并对其进行初始化、入队、出队等操作。
b). 运行以上代码片段，并输出相应结果。
同时分析算法的时间复杂度和空间复杂度。
4. 实验结果与讨论a) 线性表操作演示程序设计与分析实验结果：- 初始化线性表所需时间为X秒；- 插入元素到指定位置平均耗时Y毫秒；- 删除指定位置的元素平均耗时Z毫秒。
b）栈和队列综合应用设计与模拟实验结果：i) 浏览器前进后退功能测试：共浏览N个网页，前进M 次、后退K次。
运行总体消耗时间T1;ii) 双向链队初始化、入队、出对等操作测试: 共进行P 组数据处理, 运行总体消耗时间T2.5. 结论通过本次上机实验，我们掌握了线性表及其相关基本操作，并且成功完成了栈和队列在特定场景下的应用。
同时，在代码编写过程中也深刻理解并评估了各种算法效率。
6. 致谢感谢老师们给予我宝贵意见以及同学们之间相互交流合作提供支持。
7. 附件8. 法律名词及注释在此处添加涉及到的法律名词或术语，并提供简要注释。
20111-《数据结构集中上机》任务书
《数据结构集中上机》任务书一、教学目的及基本要求1．了解并掌握数据结构的设计方法，具备初步的独立分析和设计能力；2．初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能；3．提高综合运用所学的理论知识和方法独立分析和解决问题的能力；4．训练用系统的观点和软件开发一般规范进行软件开发，培养软件工作者所应具备的科学的工作方法和作风。
二、进程安排本次集中上机总学时为16学时，总共分为三次。
时间内容学时备注3周下达任务书，讲解任务安排，选题。
2 指导教师将自己联系方式QQ、电子邮箱等告知学生以便答疑。
3-13周1．问题分析和任务定义。
2．逻辑设计。
逻辑设计的结果应写出每个抽象数据类型的定义(包括数据结构的描述和每个基本操作的功能说明)，各个主要模块的算法，并画出模块之间的调用关系图。
3．物理设计。
定义相应的存储结构并写出各函数的伪码算法。
4．详细设计的结果是对数据结构和基本操作作出进一步的求精，写出数据存储结构的类型定义，写出函数形式的算法框架。
5．程序编码。
6．程序调试与测试。
7．结果分析。
程序运行结果包括正确的输入及其输出结果和含有错误的输入及其输出结果。
算法的时间、空间复杂性分析。
8．编写设计报告。
12通过自主学习、教师指导和答疑的方式课下开放机房完成设计调试工作14周1．检查：●运行程序；●介绍设计的思路与方法；●对教师提出的相关问题进行回答。
2．提交内容：●程序源代码。
●报告以电子文档的形式进行提交。
2其中：S331机房周末开放。
三、要求1、在后面的课题表中列出了多个设计课题，每个课题都有相应的要求或说明。
学生首先要了解设计的任务，仔细阅读各题的设计要求，然后根据自己的基础和能力情况从中选择一题。
若学生对课题表以外的相关课题较感兴趣，希望选作课程设计的课题时，应征得指导教师的认可，并写出明确的设计要求和说明。
2 、关于设计的总要求：在设计时，要严格按照题意要求独立进行设计，不能随意更改。
《数据结构》实验1实验报告
南京工程学院实验报告<班级>_<学号>_<实验X>.RAR文件形式交付指导老师。
一、实验目的1.熟悉上机环境，进一步掌握语言的结构特点。
2.掌握线性表的顺序存储结构的定义及实现。
3.掌握线性表的链式存储结构——单链表的定义及实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
二、实验内容1.顺序线性表的建立、插入及删除。
2.链式线性表的建立、插入及删除。
三、实验步骤1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2.利用前面的实验先建立一个顺序表L={21，23，14，5，56，17，31}，然后在第i个位置插入元素68。
3.建立一个带头结点的单链表，结点的值域为整型数据。
要求将用户输入的数据按尾插入法来建立相应单链表。
四、程序主要语句及作用程序1的主要代码(附简要注释)public struct sequenlist{public const int MAXSIZE=1024; /*最大值为1024*/public elemtype[] vec;public int len; /* 顺序表的长度 */public sequenlist( int n){vec=new elemtype[MAXSIZE ];len = n;}};class Program{static void Main(string[] args){sequenlist list1 = new sequenlist(5);for (int i = 0; i < 5; i++){list1.vec[i] = i;}for (int i = 0; i < 5; i++){Console.Write("{0}---", list1.vec[i]) ;}Console.WriteLine("\n");Console.WriteLine("表长：{0}\n",list1.len );Console.ReadKey();}}程序2的主要代码(附简要注释)public void insertlist(int i, int x){if (len >= MAXSIZE)throw new Exception("上溢"); /*长度大于最大值则抛出异常*/if (i < 1 || i > len + 1)throw new Exception("位置");/插入位置小于1或大于len+1则抛出插入位置错误的异常for (int j = len; j >= i; j--)vec[j] = vec[j - 1]; //注意第j个元素存在数组下标为j-1处vec[i - 1] = x;len++;}};class Program{static void Main(string[] args){sequenlist list2 = new sequenlist(7);list2.vec[0] = 21;list2.vec[1] = 23;list2.vec[2] = 14;list2.vec[3] = 5;list2.vec[4] = 56;list2.vec[5] = 17;list2.vec[6] = 31;Console.Write("请输入第i个位置插入元素：");int loc =Convert.ToInt32( Console.ReadLine());Console.Write("请输入第{0}个位置插入的元素：", loc);int ele = Convert.ToInt32(Console.ReadLine());Console.WriteLine("插入前的线性表：");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");list2.insertlist(loc, ele);Console.WriteLine("插入后的线性表：");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");Console.ReadKey();}}程序3的主要代码(附简要注释)class Node{private int num;public int Num{set { num = value; }/输入值get { return num; }/获得值}private Node next;public Node Next{set { next = value; }get { return next; }}}class Pp{static void Main(string[] args){Node head;Node tempNode, tempNode1;int i;head = new Node();Console.WriteLine("输入六项数据：\n");Console.Write("输入第1项数据:");head.Num = Convert.ToInt32(Console.ReadLine());head.Next = null;tempNode = head;for (i = 1; i < 6; i++){tempNode1 = new Node();Console.Write("输入第{0}项数据:",i+1);tempNode1.Num = Convert.ToInt32(Console.ReadLine());/插入项转换为整形数值 tempNode1.Next = null;tempNode.Next = tempNode1;tempNode = tempNode.Next;}Console.WriteLine("线性表:");tempNode = head;for (i = 0; i < 6; i++){Console.Write("{0}", tempNode.Num);if (i < 5){Console.Write("--");}tempNode = tempNode.Next;}Console.ReadKey();}}五、程序运行结果截图程序1程序2程序3六、收获，体会及问题(写得越详细、越个性化、越真实越好，否则我不知道你做这个实验的心路历程，也就无法充分地判断你是否是独立完成的这个实验、你是否在做这个实验时进行了认真仔细地思考、通过这个实验你是否在实践能力上得到了提高)这次试验刚开始做时完全不知道从哪下手，才刚上了几节课，对于线性表、链式表都不是理解的很透彻，不知道用哪个软件编写程序。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构上机实验
实验一：以单链表表示集合，设计算法建立先后输入的两个集合的差。
说明：已知两个集合A和B，集合A-B中包含所有属于集合A而不属于集合B 的元素。
步骤：1.首先建立A和B的单链表
2.然后对集合B中的每个元素x，在A中查找，若存在和x相同的元素，则从该链表中删除。
3.打印A-B，进行验证。
实验二：建立一个二叉树，并进行先序和中序遍历。
（递归和非递归算法）
步骤1.补充元素0建立一个满二叉树，存储到一维数组
2.利用递归算法建立二叉树，注意零的元素处置
3．进行递归、非递归的中序和先序遍历。
打印结果。
实验三：先从键盘输入26个字母生成无序数组，对数组排序后，再从键盘输入一个字符进行折半查找。
实验四：为一个图（maxnode＝20）建立一个邻接表、编写深度遍历和广度遍历算法并给出遍历结果。
报告要求
●简述每一部分的对象、目的和要求；
●画出算法(程序)的流程图；
●附源程序清单；
●实验的收获：遇到的问题以及解决的办法、方法的优缺点、对本实验的要求和建议；忌空、大话简述每一部分。
●报告统一采用A4打印纸打印或手写，左侧装订。
●对源程序的功能块做适当注释。
●其他未尽事项按写报告的一般要求进行。
●另：附源程序光盘（一个班刻一张，每个同学的程序放在一个以学号和姓名命名(如：030710101张××)的文件夹中），并在报告里说明程序数据要求。