《数据结构》2012级实验报告模板..

数据结构实验报告想必学计算机专业的同学都知道数据结构是一门比较重要的课程，那么，下面是小编给大家整理收集的数据结构实验报告，供大家阅读参考。

数据结构实验报告1一、实验目的及要求1)掌握栈和队列这两种特殊的线性表，熟悉它们的特性，在实际问题背景下灵活运用它们。

本实验训练的要点是“栈”和“队列”的观点;二、实验内容1) 利用栈，实现数制转换。

2) 利用栈，实现任一个表达式中的语法检查(选做)。

3) 编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列);三、实验流程、操作步骤或核心代码、算法片段顺序栈：Status InitStack(SqStack &S){S.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemTyp e));if(!S.base)return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status DestoryStack(SqStack &S){free(S.base);return OK;}Status ClearStack(SqStack &S){S.top=S.base;return OK;}Status StackEmpty(SqStack S){if(S.base==S.top)return OK;return ERROR;}int StackLength(SqStack S){return S.top-S.base;}Status GetTop(SqStack S,ElemType &e){if(S.top-S.base>=S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemTyp e));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;Status Push(SqStack &S,ElemType e){if(S.top-S.base>=S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemTyp e));if(!S.base)return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,ElemType &e){if(S.top==S.base)return ERROR;e=*--S.top;return OK;}Status StackTraverse(SqStack S){ElemType *p;p=(ElemType *)malloc(sizeof(ElemType));if(!p) return ERROR;p=S.top;while(p!=S.base)//S.top上面一个...p--;printf("%d ",*p);}return OK;}Status Compare(SqStack &S){int flag,TURE=OK,FALSE=ERROR; ElemType e,x;InitStack(S);flag=OK;printf("请输入要进栈或出栈的元素："); while((x= getchar)!='#'&&flag) {switch (x){case '(':case '[':case '{':if(Push(S,x)==OK)printf("括号匹配成功!\n\n"); break;case ')':if(Pop(S,e)==ERROR || e!='('){printf("没有满足条件\n");flag=FALSE;}break;case ']':if ( Pop(S,e)==ERROR || e!='[')flag=FALSE;break;case '}':if ( Pop(S,e)==ERROR || e!='{')flag=FALSE;break;}}if (flag && x=='#' && StackEmpty(S)) return OK;elsereturn ERROR;}链队列：Status InitQueue(LinkQueue &Q) {Q.front =Q.rear=(QueuePtr)malloc(sizeof(QNode));if (!Q.front) return ERROR;Q.front->next = NULL;return OK;}Status DestoryQueue(LinkQueue &Q) {while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}return OK;}Status QueueEmpty(LinkQueue &Q){if(Q.front->next==NULL)return OK;return ERROR;}Status QueueLength(LinkQueue Q){int i=0;QueuePtr p,q;p=Q.front;while(p->next){i++;p=Q.front;q=p->next;p=q;}return i;}Status GetHead(LinkQueue Q,ElemType &e) {QueuePtr p;p=Q.front->next;if(!p)return ERROR;e=p->data;return e;}Status ClearQueue(LinkQueue &Q){QueuePtr p;while(Q.front->next ){p=Q.front->next;free(Q.front);Q.front=p;}Q.front->next=NULL;Q.rear->next=NULL;return OK;}Status EnQueue(LinkQueue &Q,ElemType e) {QueuePtr p;p=(QueuePtr)malloc(sizeof (QNode));if(!p)return ERROR;p->data=e;p->next=NULL;Q.rear->next = p;Q.rear=p; //p->next 为空return OK;}Status DeQueue(LinkQueue &Q,ElemType &e) {QueuePtr p;if (Q.front == Q.rear)return ERROR;p = Q.front->next;e = p->data;Q.front->next = p->next;if (Q.rear == p)Q.rear = Q.front; //只有一个元素时(不存在指向尾指针) free (p);return OK;}Status QueueTraverse(LinkQueue Q){QueuePtr p,q;if( QueueEmpty(Q)==OK){printf("这是一个空队列!\n");return ERROR;}p=Q.front->next;while(p){q=p;printf("%d<-\n",q->data);q=p->next;p=q;}return OK;}循环队列：Status InitQueue(SqQueue &Q){Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType)); if(!Q.base)exit(OWERFLOW);Q.front=Q.rear=0;return OK;}Status EnQueue(SqQueue &Q,QElemType e){if((Q.rear+1)%MAXQSIZE==Q.front)return ERROR;Q.base[Q.rear]=e;Q.rear=(Q.rear+1)%MAXQSIZE;return OK;}Status DeQueue(SqQueue &Q,QElemType &e){if(Q.front==Q.rear)return ERROR;e=Q.base[Q.front];Q.front=(Q.front+1)%MAXQSIZE;return OK;}int QueueLength(SqQueue Q){return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;}Status DestoryQueue(SqQueue &Q){free(Q.base);return OK;}Status QueueEmpty(SqQueue Q) //判空{if(Q.front ==Q.rear)return OK;return ERROR;}Status QueueTraverse(SqQueue Q){if(Q.front==Q.rear)printf("这是一个空队列!");while(Q.front%MAXQSIZE!=Q.rear){printf("%d<- ",Q.base[Q.front]);Q.front++;}return OK;}数据结构实验报告2一.实验内容：实现哈夫曼编码的生成算法。

《数据结构》实验报告◎实验题目：合并两个链表，设A与B分别为两个带有头结点的有序循环链表（所谓有序是指链接点按数据域值大小链接，本题不妨设按数据域值从小到大排列），list1和list2分别为指向两个链表的头指针。

请写出将这两个链表合并为一个带头结点的有序循环链表的算法。

◎实验目的：使用顺序表的创建、插入、删除，合并等操作编写关于数据结构的程序。

◎实验内容：写出相关程序并上机调试、通过。

一、需求分析1.本程序以用户和计算机的对话方式执行，在计算机终端要求输入两组域值从小到大排列的链表数据，终端显示“第一个链表”时，用户输入第一个链表的元素，终端显示“第二个链表”时，用户输入第二个链表的元素，按回车键结束输入；2.输入两组数据后，输出一个形式为两个链表中元素合并成一个链表并且其中元素按照递增的顺序排列；3.此程序能够把两个带有头结点的有序循环链表合并为一个带头结点的有序循环链表；4.程序执行的命令包括：（1）构造含有n个元素的循环链表，（2）输入数据，（3）将输入的数据做成有序循环链表，（4）合并两个链表，（5）输出新生成的链表，（6）结束。

5.测试数据示例请输入两个循环链表，以回车键结束：第一个链表：1 5 9 18第二个链表：2 3 6 11合并两个链表输出为：1 2 3 5 6 9 11 18Press any key to continue二、概要设计1.基本操作本程序，用单向有序循环链表作为存储结构。

（1）OrderInsertList(OrdCircList*,int)有序的在链表中插入元素（2）CombineTwoOrderList(OrdCircList*,OrdCircList*,OrdCircList*) 合并两个有序循环链表到新的链表中（3）PrintList(OrdCircList*)输出循环链表2.模块调用图主程序模块创建带头结点的循环链表模块将输入的元素有序的插入链表模块合并两个有序循环链表到新的链表中模块输出链表模块三、详细设计1.结点类型：typedef struct List{int num;struct List *next;} OrdCircList;2.每个模块：（1）主函数：int main(void){char c = '0';int num,sum;OrdCircList *LA,*LB,*LC; //定义头指针OrdCircList *temp;//初始化头指针LA = LB = LC = NULL;OrdCircList list_1,list_2,list_3; //定义3个头结点//将头指针指向结点LA = &list_1;LB = &list_2;LC = &list_3;//初始化头结点list_1.num=list_2.num=list_3.num=0;//将头结点的next指针指向本身list_1.next = LA;list_2.next = LB;list_3.next = LC;printf("请输入两个循环链表,以回车键结束:\n");printf("第一个链表: ");do{c=getchar();if(c!=' ' && c!='\n'){sum=0; //用于计算一位或多位数时的和//将一个或多个字符转换成一个整数while(c!=' ' && c!='\n'){//atoi操作对象时以'\0'为结束符的字符串char a[2];a[0]=c;a[1]='\0';num=atoi(a);if(sum==0){sum=num;}else{sum=sum*10;sum=sum+num;}c=getchar(); //获取下一个字符，以判断一个整数的结束}OrderInsertList(LA,sum);}}while(c!='\n');//PrintList(LA);printf("第二个链表: ");do{c=getchar();if(c!=' ' && c!='\n'){sum=0; //用于计算一位或多位数时的和//将一个或多个字符转换成一个整数while(c!=' ' && c!='\n'){//atoi操作对象时以'\0'为结束符的字符串char a[2];a[0]=c;a[1]='\0';num=atoi(a);if(sum==0){sum=num;}else{sum=sum*10;sum=sum+num;}c=getchar(); //获取下一个字符，以判断一个整数的结束}OrderInsertList(LA,sum);}}while(c!='\n');//PrintList(LB);CombineTwoOrderList(LA,LB,LC);printf("合并两个链表输出为：");PrintList(LC);//释放掉申请的内存空间temp=LC;while(temp->next!=LC){temp=temp->next;}if(temp!=LC){temp->next=NULL; //让LC链表表尾空即让链表不循环方便释放temp=LC->next;free(temp);}return 0;}（2）归并递增的两个链表la、lb，得到新链表lc：void CombineTwoOrderList(OrdCircList *la,OrdCircList *lb,OrdCircList *lc){OrdCircList* cur_a,*cur_b,*cur_c,*temp;cur_a=la->next;cur_b=lb->next;cur_c=lc->next;while(la->num!=0 && lb->num!=0){//比较cur_a和cur_b大小，并作出if(cur_a->num>cur_b->num){lb->next=cur_b->next;lb->num--; //链表的结点数减一cur_c->next=cur_b;lc->num++; //链表数的结点加一cur_c=cur_c->next; //cur_c指向尾部的结点cur_b=lb->next; //将cur_b指向被处理好的结点的下一个结点}else{la->next=cur_a->next;la->num--; //链表的结点数减一cur_c->next=cur_a;lc->num++; //链表数的结点加一cur_c=cur_c->next; //cur_c指向尾部的结点cur_a=la->next; //将cur_b指向被处理好的结点的下一个结点}}//链表刚好都为空if(la->num==0 && lb->num==0)cur_c->next=lc ;//让链表lc循环if(la->num!=0)//链表a不为空时{temp=cur_a;while(temp->next!=la)//当temp指向la链表的头结点时结束{temp=temp->next;}//把la链表除头结点外的结点并入链表lc中cur_c->next=cur_a;temp->next=lc;lc->num+=la->num;la->num=0; //la链表只剩头结点其num必须为0la->next=la; //让链表la变成只有头结点的循环链表}if(lb->num!=0)//链表a不为空时{temp=cur_b;while(temp->next!=lb)//当temp指向lb链表的头结点时结束{temp=temp->next;}//把la链表除头结点外的结点并入链表lc中cur_c->next=cur_b;temp->next=lc;lc->num+=lb->num; //将lc链表的变正确了lb->num=0; //lb链表只剩头结点其num必须为0lb->next=lb; //让链表lb变成只有头结点的循环链表}}（3）有序的在链表中插入元素：void OrderInsertList(OrdCircList *head,int num){int count=0;OrdCircList *newnode,*cur,*pre; //建立三个指针cur=pre=head;newnode=NULL;newnode =(struct List *) malloc(sizeof(OrdCircList)); //申请一块空间作为新结点//如果申请空间失败if(!newnode){printf("Application memory failure!\n");exit(-1);}newnode->next = NULL;newnode->num = num;if(head->num==0) //只有头结点时{newnode->next = head->next;head->next = newnode;head->num++;count++;}else{cur=cur->next; //链表不为空时cur指针指向head指针的下一个while((count==0)&&(cur->num<=newnode->num)){if(cur->next==head){newnode->next=cur->next;cur->next=newnode;head->num++;count++;}else{pre=cur;cur=cur->next;}}if(count==0){newnode->next = cur;pre->next = newnode;head->num++;}}}（4）循环链表的输出：void PrintList(OrdCircList*head){OrdCircList *print;print = head;if(head->num==0) //链表为空时printf("This is a empty list!\n");else{while(print->next!=head) //以print指针指向头结点为结束{printf("%d ",print->next->num);print = print->next;}printf("\n");}}3.完整函数：//合并两个有序的循环链表#include<stdio.h>#include<stdlib.h>typedef struct List{int num;struct List *next;} OrdCircList;void OrderInsertList(OrdCircList*,int); //有序地在链表中插入元素void PrintList(OrdCircList*); //输出循环链表//合并两个有序循环链表到新的链表中void CombineTwoOrderList(OrdCircList*,OrdCircList*,OrdCircList*);int main(void){char c = '0';int num,sum;OrdCircList *LA,*LB,*LC; //定义头指针OrdCircList *temp;//初始化头指针LA = LB = LC = NULL;OrdCircList list_1,list_2,list_3; //定义3个头结点//将头指针指向结点LA = &list_1;LB = &list_2;LC = &list_3;//初始化头结点list_1.num=list_2.num=list_3.num=0;//将头结点的next指针指向本身list_1.next = LA;list_2.next = LB;list_3.next = LC;printf("请输入两个循环链表,以回车键结束:\n");printf("第一个链表: ");do{c=getchar();if(c!=' ' && c!='\n'){sum=0; //用于计算一位或多位数时的和//将一个或多个字符转换成一个整数while(c!=' ' && c!='\n'){//atoi操作对象时以'\0'为结束符的字符串char a[2];a[0]=c;a[1]='\0';num=atoi(a);if(sum==0){sum=num;}else{sum=sum*10;sum=sum+num;}c=getchar(); //获取下一个字符，以判断一个整数的结束}OrderInsertList(LA,sum);}}while(c!='\n');//PrintList(LA);printf("第二个链表: ");do{c=getchar();if(c!=' ' && c!='\n'){sum=0; //用于计算一位或多位数时的和//将一个或多个字符转换成一个整数while(c!=' ' && c!='\n'){//atoi操作对象时以'\0'为结束符的字符串char a[2];a[0]=c;a[1]='\0';num=atoi(a);if(sum==0){sum=num;}else{sum=sum*10;sum=sum+num;}c=getchar(); //获取下一个字符，以判断一个整数的结束}OrderInsertList(LA,sum);}}while(c!='\n');//PrintList(LB);CombineTwoOrderList(LA,LB,LC);printf("合并两个链表输出为：");PrintList(LC);//释放掉申请的内存空间temp=LC;while(temp->next!=LC){temp=temp->next;}if(temp!=LC){temp->next=NULL; //让LC链表表尾空即让链表不循环方便释放temp=LC->next;free(temp);}return 0;}void OrderInsertList(OrdCircList *head,int num){int count=0;OrdCircList *newnode,*cur,*pre; //建立三个指针cur=pre=head;newnode=NULL;newnode =(struct List *) malloc(sizeof(OrdCircList)); //申请一块空间作为新结点//如果申请空间失败if(!newnode){printf("Application memory failure!\n");exit(-1);}newnode->next = NULL;newnode->num = num;if(head->num==0) //只有头结点时{newnode->next = head->next;head->next = newnode;head->num++;count++;}else{cur=cur->next; //链表不为空时cur指针指向head指针的下一个while((count==0)&&(cur->num<=newnode->num)){if(cur->next==head){newnode->next=cur->next;cur->next=newnode;head->num++;count++;}else{pre=cur;cur=cur->next;}}if(count==0){newnode->next = cur;pre->next = newnode;head->num++;}}}void PrintList(OrdCircList*head){OrdCircList *print;print = head;if(head->num==0) //链表为空时printf("This is a empty list!\n");else{while(print->next!=head) //以print指针指向头结点为结束{printf("%d ",print->next->num);print = print->next;}printf("\n");}}void CombineTwoOrderList(OrdCircList *la,OrdCircList *lb,OrdCircList *lc){OrdCircList* cur_a,*cur_b,*cur_c,*temp;cur_a=la->next;cur_b=lb->next;cur_c=lc->next;while(la->num!=0 && lb->num!=0){//比较cur_a和cur_b大小，并作出if(cur_a->num>cur_b->num){lb->next=cur_b->next;lb->num--; //链表的结点数减一cur_c->next=cur_b;lc->num++; //链表数的结点加一cur_c=cur_c->next; //cur_c指向尾部的结点cur_b=lb->next; //将cur_b指向被处理好的结点的下一个结点}else{la->next=cur_a->next;la->num--; //链表的结点数减一cur_c->next=cur_a;lc->num++; //链表数的结点加一cur_c=cur_c->next; //cur_c指向尾部的结点cur_a=la->next; //将cur_b指向被处理好的结点的下一个结点}}//链表刚好都为空if(la->num==0 && lb->num==0)cur_c->next=lc ;//让链表lc循环if(la->num!=0)//链表a不为空时{temp=cur_a;while(temp->next!=la)//当temp指向la链表的头结点时结束{temp=temp->next;}//把la链表除头结点外的结点并入链表lc中cur_c->next=cur_a;temp->next=lc;lc->num+=la->num;la->num=0; //la链表只剩头结点其num必须为0la->next=la; //让链表la变成只有头结点的循环链表}if(lb->num!=0)//链表a不为空时{temp=cur_b;while(temp->next!=lb)//当temp指向lb链表的头结点时结束{temp=temp->next;}//把la链表除头结点外的结点并入链表lc中cur_c->next=cur_b;temp->next=lc;lc->num+=lb->num; //将lc链表的变正确了lb->num=0; //lb链表只剩头结点其num必须为0lb->next=lb; //让链表lb变成只有头结点的循环链表}}四、使用说明、测试分析及结果1.运行界面 Microsoft Visual C++2.测试结果五、实验总结1.此实验要求生成一个新的有序循环链表，重点在于将两个循环链表la、lb合并得到新链表lc，并使lc也同样是有序循环链表。

数据结构实验报告数据结构实验报告实验目的本实验旨在通过实践，加深对数据结构的理解，掌握数据结构的基本操作，并学会运用数据结构解决实际问题。

实验背景数据结构是计算机科学中非常重要的基础知识，它是研究各种数据结构及其相应算法的学科。

数据结构可以提供对数据的组织、存储和管理方式，从而有效地支持计算机程序的设计和运行。

实验内容本实验主要包括以下几个方面的内容：1. 线性表的操作- 插入操作：向线性表的指定位置插入元素。

- 删除操作：从线性表中删除指定位置的元素。

- 查找操作：在线性表中查找指定元素。

- 遍历操作：依次访问线性表中的所有元素。

2. 栈的应用- 中缀表达式转后缀表达式：将带有括号的中缀表达式转换为无括号的后缀表达式。

- 后缀表达式求值：根据后缀表达式计算其值。

3. 队列的应用- 模拟打印任务：根据打印任务的到达时间和执行时间，模拟打印机的工作过程。

4. 递归的应用- 计算斐波那契数列：通过递归函数计算斐波那契数列的第n 项值。

实验步骤根据实验内容，进行以下步骤：1. 线性表的操作1. 初始化线性表。

2. 实现插入操作，并在指定位置插入元素。

3. 实现删除操作，并从指定位置删除元素。

4. 实现查找操作，并根据指定元素在线性表中查找。

5. 实现遍历操作，并依次访问线性表中的所有元素。

2. 栈的应用1. 实现中缀表达式转后缀表达式的函数，并进行测试。

2. 实现后缀表达式求值的函数，并进行测试。

3. 队列的应用1. 实现模拟打印任务的函数，并根据指定的打印任务进行测试。

4. 递归的应用1. 实现计算斐波那契数列的递归函数，并计算第n项的值。

实验结果经过上述步骤的实现和测试，得到以下实验结果：- 线性表的操作：插入、删除、查找和遍历操作均得到正确的结果。

- 栈的应用：中缀表达式转后缀表达式和后缀表达式求值的函数均能正确运行。

- 队列的应用：模拟打印任务的函数能够按照指定的顺序执行打印任务。

- 递归的应用：计算斐波那契数列的递归函数能够正确计算任意一项的值。

数据结构实验报告姓名：学号：专业：班级：指导教师：实验时间：实验地点：（实验题目）1.实验内容和要求实验一顺序表实验实验要求1、顺序表结构定义，算法的实现以库文件方式实现，库文件名统一为seqList.h；2、实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件工程要求；3、程序有适当的注释。

实验任务编写算法实现下列问题的求解。

<1>求顺序表中第i个元素（函数），若不存在，报错。

实验测试数据基本要求：第一组数据：顺序表长度n≥10，i分别为5，n，0，n+1，n+2第二组数据：顺序表长度n=0，i分别为0，2<2>在第i个结点前插入值为x的结点。

实验测试数据基本要求：第一组数据：顺序表长度n≥10，x=100, i分别为5,n,n+1,0,1,n+2第二组数据：顺序表长度n=0，x=100，i=5<3>删除顺序表中第i个元素结点。

实验测试数据基本要求：第一组数据：顺序表长度n≥10，i分别为5,n,1,n+1,0第二组数据：顺序表长度n=0， i=5<4>在一个递增有序的顺序表L中插入一个值为x的元素，并保持其递增有序特性。

实验测试数据基本要求：顺序表元素为（10,20,30,40,50,60,70,80,90,100）,x分别为25，85，110和8<5>将顺序表Ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），分别放入新的顺序表中，然后原表和新表元素同时输出到屏幕上，以便对照求解结果。

实验测试数据基本要求：第一组数据：顺序表元素为（1,2,3,4,5,6,7,8,9,10,20,30,40,50,60）第二组数据：顺序表元素为（10,20,30,40,50,60,70,80,90,100）<6>求两个递增有序顺序表L1和L2中的公共元素，放入新的顺序表L3中。

实验测试数据基本要求：第一组第一个顺序表元素为（1，3，6，10，15，16，17，18，19，20）第二个顺序表元素为（1，2，3，4，5，6，7，8，9，10，18，20，30）第二组第一个顺序表元素为（1，3，6，10，15，16，17，18，19，20）第二个顺序表元素为（2，4，5，7，8，9，12，22）第三组第一个顺序表元素为（）第二个顺序表元素为（1，2，3，4，5，6，7，8，9，10）实验二单链表实验实验要求1、本次实验中的链表结构均为带头结点的单链表；2、链表结构定义，算法实现放入库文件“linkList.h”；3、运算和变量命名直观易懂，并有相应的注释。

数据结构实验报告
，可以加上括号属性。

随着信息技术和互联网的迅猛发展，数据结构在信息技术和计算机科学的发展
中发挥着重要的作用。

数据结构实验中，经常使用链表、树等数据结构，掌握并学习它们结构的特点，更好的解决实际的数据问题。

首先，链表是一种动态结构，以结构体的形式组织数据。

它由一系列由一个个节点组成，并由指针链接起来，节点中包含两个部分：一部分是存储数据，一部分是指针，指向下一个节点。

此外，链表可以实现插入、删除数据，只需要改变指针指向，操作简单，查询时间复杂度只有 $O(n)$，空间复杂度 $O(1)$ ，比较方便。

其次，树是一种静态的数据结构，由节点构成，由节点间的链接关系形成，可
以有效地存储、管理大量的数据。

例如我们常见的B+树和NR－tree，多用于文件
索引，查询和储存具有一定的结构的信息，能够更快地查找符合特征的数据，比顺序查找、二分查找都要快，其时间复杂度为 $O(logn)$。

最后，数据结构实验把学习理论知识和实践编程结合起来，充分发挥了树和链
表的优势，在计算机科学领域有着深刻的影响。

前面所介绍的数据结构实验为我们在互联网工程中做出更好的贡献提供了可靠的参考。

中原工学院《数据结构》实验报告学院：计算机学院专业：计算机科学与技术班级：计科112姓名：康岩岩学号：201100814220 指导老师：高艳霞2012-11-22实验五图的基本操作一、实验目的1、使学生可以巩固所学的有关图的基本知识。

2、熟练掌握图的存储结构。

3、熟练掌握图的两种遍历算法。

二、实验内容[问题描述]对给定图，实现图的深度优先遍历和广度优先遍历。

[基本要求]以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。

以用户指定的结点为起点，分别输出每种遍历下的结点访问序列。

【测试数据】由学生依据软件工程的测试技术自己确定。

三、实验前的准备工作1、掌握图的相关概念。

2、掌握图的逻辑结构和存储结构。

3、掌握图的两种遍历算法的实现。

四、实验报告要求1、实验报告要按照实验报告格式规范书写。

2、实验上要写出多批测试数据的运行结果。

3、结合运行结果，对程序进行分析。

【设计思路】【代码整理】#include "stdafx.h"#include <iostream>#include <malloc.h>using namespace std;typedef int Status;#define OK 1#define ERROR 0#define OVERFLOW -1#define MAX_SIZE 20typedef enum{DG,DN,UDG,UDN}Kind;typedef struct ArcNode{int adjvex; //顶点位置struct ArcNode *nextarc; //下一条弧int *info; //弧信息};typedef struct{char info[10]; //顶点信息ArcNode *fistarc; //指向第一条弧}VNode,AdjList[MAX_SIZE];typedef struct{AdjList vertices;int vexnum,arcnum; //顶点数，弧数int kind; //图的种类，此为无向图}ALGraph;//这是队列的节点，仅用于广度优先搜索typedef struct Node{int num;struct Node* next;};//队列的头和尾typedef struct{Node * front;Node *rear;}PreBit;int LocateV ex(ALGraph G,char info[]);//定位顶点的位置Status addArcNode(ALGraph &G,int adjvex); //图中加入弧Status CreatGraph(ALGraph&G);//创建图的邻接表Status DFSTraverse(ALGraph G);//深度优先搜索Status BFSTraverse(ALGraph G);//广度优先搜索Status DFS(ALGraph G,int v);//深度优先搜索中的数据读取函数，用于递归bool visited[MAX_SIZE]; // 访问标志数组//初始化队列Status init_q(PreBit&P_B){P_B.front=P_B.rear=(Node*)malloc(sizeof(Node));if(!P_B.front){exit(OVERFLOW);}P_B.front->next=NULL;}//将数据入队Status en_q(PreBit & P_B,int num){Node *p=(Node*)malloc(sizeof(Node));if(!p){exit(OVERFLOW);}p->num=num;p->next=NULL;P_B.rear->next=p;P_B.rear=p;return OK;}//出队Status de_q(PreBit & P_B){if(P_B.front==P_B.rear){return ERROR;}Node* p=P_B.front->next;P_B.front->next=p->next;if(P_B.rear==p){P_B.rear=P_B.front;}free(p);return OK;}Status CreatGraph(ALGraph&G){cout<<"请输入顶点数目和弧数目"<<endl;cin>>G.vexnum>>G.arcnum;//依次输入顶点信息for(int i=0;i<G.vexnum;i++){cout<<"请输入顶点名称"<<endl;cin>>G.vertices[i].info;G.vertices[i].fistarc=NULL;}//依次输入弧信息for(int k=1;k<=G.arcnum;k++){char v1[10],v2[10]; //用于表示顶点名称的字符数组int i,j; //表示两个顶点的位置BACK: //返回点cout<<"请输入第"<<k<<"条弧的两个顶点"<<endl;cin>>v1>>v2;i=LocateV ex(G,v1); //得到顶点v1的位置j=LocateV ex(G,v2); //得到顶点v2的位置if(i==-1||j==-1){ //头信息不存在则返回重输cout<<"不存在该节点!"<<endl;goto BACK; //跳到BACK 返回点}addArcNode(G,i); //将弧的顶点信息插入表中addArcNode(G,j);}return OK;}//倒序插入弧的顶点信息Status addArcNode(ALGraph &G,int adjvex){ArcNode *p; //弧节点指针p=(ArcNode*)malloc(sizeof(ArcNode));p->adjvex=adjvex;p->nextarc=G.vertices[adjvex].fistarc;//指向头结点的第一条弧G.vertices[adjvex].fistarc=p; //头结点的第一条弧指向p，即将p作为头结点的第一条弧return OK;}//定位顶点的位置int LocateV ex(ALGraph G,char info[]){for(int i=0;i<G.vexnum;i++){if(strcmp(G.vertices[i].info,info)==0){ //头结点名称与传入的信息相等，证明该头节点存在return i; //此时返回位置}}return -1;}//深度优先搜索Status DFSTraverse(ALGraph G){for(int v=0;v<G.vexnum;v++){visited[v]=false;}char v1[10];int i;BACK:cout<<"请输入首先访问的顶点"<<endl;cin>>v1;i=LocateV ex(G,v1);if(i==-1){cout<<"不存在该节点!"<<endl;goto BACK;}DFS(G,i);return OK;}//深度优先搜索递归访问图Status DFS(ALGraph G,int v){visited[v]=true;cout<<G.vertices[v].info<<" ";//输出信息ArcNode *p;p=G.vertices[v].fistarc; //向头节点第一条while(p) //当弧存在{if(!visited[p->adjvex]){DFS(G,p->adjvex); //递归读取}p=p->nextarc;}return OK;}//广度优先搜索Status BFSTraverse(ALGraph G){for(int v=0;v<G.vexnum;v++){visited[v]=false;}char v1[10];int v;BACK:cout<<"请输入首先访问的顶点"<<endl;cin>>v1;v=LocateV ex(G,v1);if(v==-1){cout<<"不存在该节点!"<<endl;goto BACK;}PreBit P_B;init_q(P_B);ArcNode *p;visited[v]=true;cout<<G.vertices[v].info<<" ";//输出信息en_q(P_B,v); //将头位置v入队while(P_B.front!=P_B.rear){//当队列不为空时，对其进行访问int w=P_B.front->next->num;//读出顶点位置de_q(P_B);//顶点已经访问过，将其出队列p=G.vertices[w].fistarc;//得到与顶点相关的第一条弧while(p){if(!visited[p->adjvex]){en_q(P_B,p->adjvex);//将弧入队，但不读取，只是将其放在队尾}p=p->nextarc;}}return OK;}int _tmain(int argc, _TCHAR* argv[]){ALGraph G;CreatGraph(G);cout<<"深度优先搜索图:"<<endl;DFSTraverse(G);cout<<endl;cout<<"广度优先搜索图:"<<endl;BFSTraverse(G);cout<<endl;system("pause");return 0;}。

数据结构实习总结【篇一：数据结构实训总结】这次课程设计的心得体会通过实习我的收获如下1、巩固和加深了对数据结构的理解，提高综合运用本课程所学知识的能力。

2、培养了我选用参考书，查阅手册及文献资料的能力。

培养独立思考，深入研究，分析问题、解决问题的能力。

3、通过实际编译系统的分析设计、编程调试，掌握应用软件的分析方法和工程设计方法。

4、通过课程设计，培养了我严肃认真的工作作风，逐步建立正确的生产观念、经济观念和全局观念。

从刚开始得觉得很难，到最后把这个做出来，付出了很多，也得到了很多，以前总以为自己对编程的地方还不行，现在，才发现只要认真做，没有什么不可能。

编程时要认真仔细，出现错误要及时找出并改正，（其中对英语的要求也体现出来了，因为它说明错误的时候都是英语）遇到问题要去查相关的资料。

反复的调试程序，最好是多找几个同学来对你的程序进行调试并听其对你的程序的建议，在他们不知道程序怎么写的时候完全以一个用户的身份来用对你的用户界面做一些建议，正所谓当局者迷旁观者清，把各个注意的问题要想到；同时要形成自己的编写程序与调试程序的风格，从每个细节出发，不放过每个知识点，注意与理论的联系和理论与实践的差别。

另外，要注意符号的使用，注意对字符处理，特别是对指针的使用很容易出错且调试过程是不会报错的，那么我们要始终注意指针的初始化不管它怎么用以免不必要麻烦。

通过近两周的学习与实践，体验了一下离开课堂的学习，也可以理解为一次实践与理论的很好的连接。

特别是本组所做的题目都是课堂上所讲的例子，在实行之的过程中并不是那么容易事让人有一种纸上谈兵的体会，正所谓纸上得来终觉浅绝知此事要躬行。

实训过程中让我们对懂得的知识做了进一步深入了解，让我们的理解与记忆更深刻，对不懂的知识与不清楚的东西也做了一定的了解，也形成了一定的个人做事风格。

通过这次课程设计，让我对一个程序的数据结构有更全面更进一步的认识，根据不同的需求，采用不同的数据存储方式，不一定要用栈，二叉树等高级类型，有时用基本的一维数组，只要运用得当，也能达到相同的效果，甚至更佳，就如这次的课程设计，通过用for 的多重循环，舍弃多余的循环，提高了程序的运行效率。

工商学院数据结构实验报告年级2012 学号2012007554 姓名刘怡然成绩专业电气实验地点B3-401 指导教师许文强实验项目模拟停车场管理程序的设计与实现实验日期2013.11.7一、实验目的本实验的目的是进一步理解栈和队列的逻辑结构和存储结构，进一步提高使用理论知识指导解决实际问题的能力。

二、实验问题描述设停车厂只有一个可停放几辆汽车的狭长通道，且只有一个大门可供汽车进出。

汽车在停车场内按车辆到达的先后顺序依次排列，若车场内已停满几辆汽车，则后来的汽车只能在门外的便道上等候，一旦停车场内有车开走，则排在便道上的第一辆车即可进入；当停车场内某辆车要离开时，由于停车场是狭长的通道，在它之后开入的车辆必须先退出车场为它让路，待该车辆开出大门，为它让路的车辆再按原次序进入车场。

在这里假设汽车不能从便道上开走，试设计这样一个停车厂模拟管理程序。

为了以下描述的方便，停车厂的停车场用“停车位”进行叙述，停车厂的便道用“便道”进行叙述。

三、实验步骤1、实验问题分析使用两个栈和一个队列。

分别为停车栈和辅助栈，队列为便道，当有车来时先进入停车场，没有空位时不能进入，停入便道。

当停车场有车要开出时，判断它的后面有没有车，没有直接开出，否则将后面的车挪入辅助栈将目标车开出。

再将辅助栈车按次序挪回停车栈。

此时判断便道上是否有车等待，有就将便道上的车按先到先出的次序停入停车场。

2、功能（函数）设计V oid Main(); 菜单stopping *init_stopping(); 初始化停车栈buffer *init_buff(); 初始化辅助栈pavement *init_pavement(); 初始化便道int car_come(stopping *s,pavement *q); 有来车int car_leave(int pos,stopping *s,buffer *b,pavement *q); 有车开走int stop_to_buff(int pos,stopping *s,buffer *b); 停车栈挪向辅助栈int buff_to_stop(stopping *s,buffer *b); 辅助栈挪向停车栈int pave_to_stop(stopping *s,pavement *q); 便道队列挪向停车栈int car_disp(stopping *s,pavement *q); 显示停车情况void Now(stopping *s,pavement *q); 实时统计停车数量四、实验结果（程序）及分析1、实验主要代码car.h#pragma oncetypedef struct{char license_plate[10]; //车牌号char state; //状态}car;Buffer.h#include"car.h"#include"stopping.h"typedef struct{car bufferx[MAX_STOP]; /*各汽车信息的存储空间*/int top; /*用来指示栈顶位置的静态指针*/}buffer;Pavement.h#include"car.h"#define MAX_PA VE 100 /*便道不限制停放车辆的数目，设为足够大*/ typedef struct{car pave[MAX_PA VE]; /*各汽车信息的存储空间*/int front,rear; /*用来指示队头和队尾位置的静态指针*/}pavement;Stopping.h#pragma once#include"car.h"#define MAX_STOP 5typedef struct{car stop[MAX_STOP]; /*各汽车信息的存储空间*/int top; /*用来指示栈顶位置的静态指针*/ }stopping;Main.cpp#include "buffer.h"#include "car.h"#include "pavement.h"#include "stopping.h"#include "iostream.h"#include "conio.h"#include "stdio.h"#include <stdlib.h>stopping *init_stopping();buffer *init_buff();pavement *init_pavement();int car_come(stopping *s,pavement *q);int car_leave(int pos,stopping *s,buffer *b,pavement *q);int stop_to_buff(int pos,stopping *s,buffer *b);int buff_to_stop(stopping *s,buffer *b);int pave_to_stop(stopping *s,pavement *q);int car_disp(stopping *s,pavement *q);void Now(stopping *s,pavement *q);void main(){int pos;stopping s;buffer b;pavement q;s=*init_stopping();b=*init_buff();q=*init_pavement();char c;for(;;){system("cls");printf("\n ________________ ");printf("\n ---------------------------| 停车场管理系统|------------------------");printf("\n ^^^^^^^^^^^^^^^^ \n\n");cout<<" ||--------------------------按0键结束程序----------------------||"<<endl;cout<<" ||--------------------------按1键有车进入----------------------||"<<endl;cout<<" ||--------------------------按2键有车离开----------------------||"<<endl;cout<<" ||--------------------------按3键显示情况----------------------||"<<endl;Now(&s,&q);c=getch();if(c=='0')break;switch(c){case '1':car_come(&s,&q);getch();break;case '2':cout<<"请输入开出车辆位置：";cin>>pos;car_leave(pos,&s,&b,&q);getch();break;case '3':car_disp(&s,&q);getch();break;}}}void Now(stopping *s,pavement *q){printf("当前实时车辆统计：停车场----%d辆便道----%d辆\n",s->top+1,q->rear-q->front); }stopping *init_stopping(){stopping *s;s=new stopping;if(!s)return NULL;else{s->top=-1;return s;}}buffer *init_buff(){buffer *b;b=new buffer;if(!b)return NULL;else{b->top=-1;return b;}}pavement *init_pavement() {pavement *q;q=new pavement;q->front=q->rear=-1;return q;}int car_come(stopping *s,pavement *q){car *c;c=new car;cout<<"请输入汽车牌照号：";cin>>c->license_plate;c->state='i';if(s->top==MAX_STOP-1){c->state='s';q->rear++;q->pave[q->rear]=*c;cout<<"停车位满！汽车"<<c->license_plate<<"停入便道。

《数据结构与算法》实验报告专业班级姓名学号实验项目实验一二叉树的应用实验目的1、进一步掌握指针变量的含义及应用。

2、掌握二叉树的结构特征，以及各种存储结构的特点及使用范围。

3、掌握用指针类型描述、访问和处理二叉树的运算。

实验内容题目1:编写一个程序，采用一棵二叉树表示一个家谱关系。

要求程序具有如下功能：（1）用括号表示法输出家谱二叉树，（2）查找某人的所有儿子，（3）查找某人的所有祖先。

算法设计分析（一）数据结构的定义为了能够用二叉树表示配偶、子女、兄弟三种关系，特采用以下存储关系，则能在二叉树上实现家谱的各项运算。

二叉树型存储结构定义为：typedef struct SNODE{char name[MAX]; //人名struct SNODE *left; //指向配偶结点struct SNODE *right; //指向兄弟或子女结点}FNODE;（二）总体设计实验由主函数、家谱建立函数、家谱输出函数、儿子查找函数、祖先查找函数、结点定位函数、选择界面函数七个函数共同组成。

其功能描述如下：（1）主函数：统筹调用各个函数以实现相应功能void main()（2）家谱建立函数：与用户交互建立家族成员对应关系void InitialFamily(FNODE *&head) //家谱建立函数（3）家谱输出函数：用括号表示法输出家谱输出形式为：父和母（子1和子妻1（孙1），子2和子妻2（孙2））void PrintFamily(FNODE *head) //家谱输出函数（4）儿子查找函数：在家谱中查找到某人所有的子女并输出，同时也能辨别出其是否为家族成员与是否有子女void FindSon(FNODE *b,char p[]) //儿子查找函数（5）祖先查找函数：在家谱中查找到某人所有的祖先并输出，同时也能辨别出其是否为家族中成员。

int FindAncestor(FNODE *head,char son[ ]) //祖先查找函数（6）结点定位函数：在家谱中找到用户输入人名所对应的结点。

《数据结构》实验报告专业_____________年级_____________学号_____________学生姓名_____________指导老师_____________华中师范大学信息管理系编I 实验要求1．每次实验中有若干习题，每个学生至少应该完成其中的两道习题。

2．上机之前应作好充分的准备工作，预先编好程序，经过人工检查无误后，才能上机，以提高上机效率。

3．独立上机输入和调试自己所编的程序，切忌抄袭、拷贝他人程序。

4．上机结束后，应整理出实验报告。

书写实验报告时，重点放在调试过程和小节部分，总结出本次实验中的得与失，以达到巩固课堂学习、提高动手能力的目的。

II 实验内容实验一线性表【实验目的】1．熟悉VC环境，学习如何使用C语言实现线性表的两种存储结构。

2．通过编程、上机调试，进一步理解线性表的基本概念,熟练运用C语言实现线性表基本操作。

3．熟练掌握线性表的综合应用问题。

【实验内容】1．一个线性表有n个元素（n<MAXSIZE, MAXSIZE指线性表的最大长度），且递增有。

现有一元素x要插入到线性表的适当位置上，并保持线性表原有的顺序不变。

设计程序实现。

要求：采用顺序存储表示实现；采用链式存储表示方法实现；比较两种方法的优劣。

2. 从单链表中删除指定的元素x，若x在单链表中不存在，给出提示信息。

要求：①指定的值x由键盘输入；②程序能处理空链表的情况。

3．设有头结点的单链表，编程对表中的作一值只保留一个结点，删除其余值相同的结点。

要求：①该算法用函数（非主函数）实现；②在主函数中调用创建链表的函数创建一个单链表，并调用该函数，验证算法的正确性。

4．已知非空单链表第一个结点由head指出，请写一算法，交换p所指结点与其下一个结点在链表中的位置。

要求：①该算法用函数Reverse(head,p)实现，其中head为表头指针，p指向要交换的结点；②在主函数中调用创建链表的函数创建一个单链表，并调用该函数，验证算法的正确性。

上海理工大学光电信息与计算机工程学院《数据结构》实验报告专业学生姓名学号年级指导教师成绩：教师签字：报告格式要求1、正文字体中文为宋体，五号，行距为固定值18磅，西文为Times New Rome, 五号，行距为固定值18磅。

2、章节标题为加粗宋体，小三号，段前段后各18磅，行距为单倍行距。

3、打印时需双面打印。

目录实验1 顺序表的基本操作 (4)实验2 单链表的基本操作 (5)实验3 栈和队列的基本操作 (6)实验4 二叉树的基本操作 (7)实验5 图的基本操作 (8)实验6 查找 (9)实验7 排序 (10)实验1 顺序表的基本操作一、实验目的编程实现顺序表的创建、插入和删除。

（为方便测试，其中元素定义为：typedef int Elemtype）二、实验软硬件要求硬件：一台安装了windows操作系统的计算机。

软件：三、实验内容实验一：题目名称1、算法描述2、算法的框架结构3、主要源程序代码实验二：题目名称四、实验结果（写出运行程序后的结果截图）实验一的结果截图实验二的结果截图实验2 单链表的基本操作一、实验目的编程实现单链表的创建、插入和删除。

（为方便测试，其中元素定义为：typedef int Elemtype）二、实验软硬件要求硬件：一台安装了windows操作系统的计算机。

软件：三、实验内容（需写出源程序）四、实验结果（写出运行程序后的结果截图）实验3 栈和队列的基本操作一、实验目的编程实现顺序栈和顺序队列的创建，并能实现入栈、出栈、入队和出队等算法。

（为方便测试，其中元素定义为：typedef int Elemtype）二、实验软硬件要求硬件：一台安装了windows操作系统的计算机。

软件：三、实验内容（需写出源程序）四、实验结果（写出运行程序后的结果截图）实验4 二叉树的基本操作一、实验目的利用二叉链表方法编程实现建立二叉树，以及二叉树的前序和中序遍历算法。

（为方便测试，其中元素定义为：typedef int Elemtype）二、实验软硬件要求硬件：一台安装了windows操作系统的计算机。

《数据结构》实验报告模板(附实例)---实验一线性表的基本操作实现实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现，其中以熟悉各种链表的操作为重点。

2、巩固高级语言程序设计方法与技术，会用线性链表解决简单的实际问题。

二、实验内容√ 1、单链表的表示与操作实现 ( * )2、约瑟夫环问题3、Dr.Kong的艺术品三、实验要求1、按照数据结构实验任务书，提前做好实验预习与准备工作。

2、加“*”题目必做，其他题目任选；多选者并且保质保量完成适当加分。

3、严格按照数据结构实验报告模板和规范，及时完成实验报告。

四、实验步骤（说明：依据实验内容分别说明实验程序中用到的数据类型的定义、主程序的流程以及每个操作（成员函数）的伪码算法、函数实现、程序编码、调试与分析、总结、附流程图与主要代码）㈠、数据结构与核心算法的设计描述（程序中每个模块或函数应加注释，说明函数功能、入口及出口参数）1、单链表的结点类型定义/* 定义DataType为int类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;2、初始化单链表LinkedList LinkedListInit( ){ // 每个模块或函数应加注释，说明函数功能、入口及出口参数 }3、清空单链表void LinkedListClear(LinkedList L){// 每个模块或函数应加注释，说明函数功能、入口及出口参数}4、检查单链表是否为空int LinkedListEmpty(LinkedList L){ …. }5、遍历单链表void LinkedListTraverse(LinkedList L){….}6、求单链表的长度int LinkedListLength(LinkedList L){ …. }7、从单链表表中查找元素LinkedList LinkedListGet(LinkedList L,int i){ //L是带头结点的链表的头指针，返回第 i 个元素 }8、从单链表表中查找与给定元素值相同的元素在链表中的位置LinkedList LinkedListLocate(LinkedList L, DataType x){ …… }9、向单链表中插入元素void LinkedListInsert(LinkedList L,int i,DataType x) { // L 为带头结点的单链表的头指针，本算法// 在链表中第i 个结点之前插入新的元素 x}10、从单链表中删除元素void LinkedListDel(LinkedList L,DataType x){ // 删除以 L 为头指针的单链表中第 i 个结点 }11、用尾插法建立单链表LinkedList LinkedListCreat( ){ …… }㈡、函数调用及主函数设计（可用函数的调用关系图说明）㈢程序调试及运行结果分析㈣实验总结五、主要算法流程图及程序清单1、主要算法流程图：2、程序清单（程序过长，可附主要部分）说明：以后每次实验报告均按此格式书写。

本科生实验报告（二）姓名:学院:专业:班级:实验课程名称: 数据结构实验日期: 2013年 5月 25 日指导教师及职称:实验成绩:开课时间：2012～2013 学年第二学期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++;[j][i]=k;}}}void main(){int n,i,j;int a[MaxLen][MaxLen];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");}}运行结果：6.2：如果矩阵A中存在这样的一个元素A[i][j]满足条件：A[i][j]是第i行中值最小的元素，且又是第j列中值最大的元素，则称为该矩阵的一个马鞍点。

设计一个程序exp6-2.cpp 计算出m*n的矩阵A的所有马鞍点。

主程序如下：6.3：已知A和B为两个n*n阶的对称矩阵，输入时，对称矩阵只输入下三角形元素，存入一维数组，如图6.5所示（对称矩阵M存储在一维数组A中），设计一个程序exp6-3.cpp 实习如下功能：（1）求对称矩阵A和B的和。

（2）求对称矩阵A和B的乘积。

A:图6.5 对称矩阵的存储转换形式主程序如下：#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]){int i,j;for (i=0;i<N;i++)printf("a+b:\n");disp2(c1);printf("a×b:\n");disp2(c2);printf("\n");}运行结果：6.4：：假设n*n的稀疏矩阵A采用三元组表示，设计一个程序exp6-4.cpp实现如下功能：（1）生成如下两个稀疏矩阵矩阵的三元组a和b:（2）输出a转置矩阵的三元组；（3）输出a+b的三元组；（4）输出a*b的三元组。

实验报告（一）一、实验目的：1．掌握VC6.0开发环境下C/C++程序的编辑、编译和运行。

2．通过实验回顾复习C语言中关于结构体、指针等知识的应用。

3．了解学习数据结构的主要方法和课程的主要知识框架。

二、实验环境：个人电脑、Windows XP、VC6.0或以上版本。

三、实验内容、程序代码、程序测试运行界面1．设计一个程序，输出所有小于等于n（n为一个大于2的正整数）的素数。

要求：（1）每行输出10个素数；（2）尽可能采用较优的算法。

2．编写一个程序，计算任一输入的正整数的各位数字之和，并分析算法的时间复杂度。

3．编写一个程序，判断一个字符串是否为“回文”（顺读和倒读都一样的字符串称为“回文”），并分析算法的时间复杂度。

四、心得体会与建议实验报告（二）一、实验目的：1．熟练掌握线性表的顺序存储结构的概念及各种基本操作的C语言实现。

2．熟练掌握线性表的链式存储结构中的单链表的概念及各种基本操作的C 语言实现。

3．了解双向链表及循环链表的基本操作。

二、实验环境：个人电脑、Windows XP、VC6.0或以上版本。

三、实验内容、程序代码、程序测试运行界面1．编写一个程序，实现顺序表的各种基本运算（假设顺序表的元素类型为char），并在此基础上设计一个程序完成如下功能：（1）初始化顺序表L；（2）采用尾插法依次插入元素a，b，c，d，e；（3）输出顺序表L；（4）输出顺序表L长度；（5）判断顺序表L是否为空；（6）输出顺序表L的第3个元素；（7）输出元素a的位置；（8）在第4个位置上插入元素f；（9）输出顺序表L；（10）删除L的第3个元素；（11）输出顺序表L；（12）释放顺序表L。

程序代码如下：程序运行结果如下：2．编写一个程序，实现单链表的各种基本运算（假设单链表的元素类型为char），并在此基础上设计一个程序，完成如下功能：（1）初始化单链表h；（2）采用尾插法依次插入元素a，b，c，d，e；（3）输出单链表h；（4）输出单链表h长度；（5）判断单链表h是否为空；（6）输出单链表h的第3个元素；（7）输出元素a的位置；（8）在第4个位置上插入元素f；（9）输出单链表h；（10）删除h的第3个元素；（11）输出单链表h；（12）释放单链表h。

深 圳 大 学 实 验 报 告课程名称： 数据结构实验与课程设计 实验项目名称： 实验一：顺序表的应用 学院： 计算机与软件学院 专业： 指导教师： **报告人： 文成 学号： ********** 班级： 5 实验时间： 2012-9-17实验报告提交时间： 2012-9-24教务部制一、实验目的与要求：目的：1.掌握线性表的基本原理2.掌握线性表地基本结构3.掌握线性表地创建、插入、删除、查找的实现方法要求：1.熟悉C++语言编程2.熟练使用C++语言实现线性表地创建、插入、删除、查找的实现方法二、实验内容：Problem A: 数据结构——实验1——顺序表例程Description实现顺序表的创建、插入、删除、查找Input第一行输入顺序表的实际长度n第二行输入n个数据第三行输入要插入的新数据和插入位置第四行输入要删除的位置第五行输入要查找的位置Output第一行输出创建后，顺序表内的所有数据，数据之间用空格隔开第二行输出执行插入操作后，顺序表内的所有数据，数据之间用空格隔开第三行输出执行删除操作后，顺序表内的所有数据，数据之间用空格隔开第四行输出指定位置的数据Sample Input611 22 33 44 55 66888 352Sample Output11 22 33 44 55 6611 22 888 33 44 55 6611 22 888 33 55 6622HINT第i个位置是指从首个元素开始数起的第i个位置，对应数组内下标为i-1的位置Problem B: 数据结构——实验1——顺序表的数据交换Description实现顺序表内的元素交换操作Input第一行输入n表示顺序表包含的·n个数据第二行输入n个数据，数据是小于100的正整数第三行输入两个参数，表示要交换的两个位置第四行输入两个参数，表示要交换的两个位置Output第一行输出创建后，顺序表内的所有数据，数据之间用空格隔开第二行输出执行第一次交换操作后，顺序表内的所有数据，数据之间用空格隔开第三行输出执行第二次交换操作后，顺序表内的所有数据，数据之间用空格隔开注意加入交换位置的合法性检查，如果发现位置不合法，输出error。

数据结构实验报告顺序表(此⽂档为word格式，下载后您可任意编辑修改！)江西理⼯⼤学软件学院计算机类课程实验报告课程名称：数据结构班级：姓名：学号：江西理⼯⼤学软件学院实验⼆：顺序表2012年11⽉10⽇⼀. 实验⽬的掌握顺序表的逻辑结构、存储结构、以及操作。

⼆. 问题描述线性表是由n(n≥0)个元素（结点）a1, a2, …, a n组成的有限序列，其中a i中的i称为该数据元素的位置（序号），n为数据元素的个数（表的长度），当n等于0时称为空表。

按逻辑次序依次把数据元素存放在⼀组连续的地址存储单元⾥的线性表称为顺序表。

在这⾥，我们通过C++中的动态数组来实现顺序表的存放，并通过建⽴顺序表类实现它的各种操作。

三. 实验要求实现顺序表的三个框架操作：随机⽣成，⽤已有顺序表初始化另⼀个顺序表，输⼊顺序表。

以及⼗个基本操作：在第i个元素之前插⼊元素，判断是否为空，求元素个数，取第i个元素，查找第⼀个与e满⾜compare()关系的元素，返回元素的前驱，返回后继，删除第i个元素，把⼀个顺序表赋值给另⼀个顺序表，置空顺序表。

四. 实验环境3323机房OS：WxpC环境：1、TC2.02、VC++ 6.0 五．运⾏结果程序开始界⾯1.随机⽣成顺序表（元素值为0到99之间的整数）2. ⽤已有的顺序表初始化另⼀个顺序表3. 输⼊顺序表基本操作：1.在第i个元素之前插⼊⼀个元素2. 判断顺序表是否为空3. 求顺序表中元素的个数4. 取第i个元素5. 查找第⼀个与之满⾜compare()关系的元素序号6. 返回某元素的前驱7. 返回某元素的后继8. 删除第i个元素9. 把⼀个顺序表复制给另⼀个顺序表10. 把顺序表置空11.顺序表的运⽤六．实验⼼得熟悉最基本的数据类型——顺序表，同时我们让我们熟练C++的基本操作，模板的使⽤，以及模块化的设计思想。

同时也运⽤顺序表做⼀些简单的运⽤，⽐如顺序表的并交差运算，学⽣管理系统等等。

数据结构实验报告数据结构实验报告背景介绍：数据结构是计算机科学中的重要概念，它涉及到如何组织和存储数据，以及如何在数据中进行操作和检索。

在本次实验中，我们将学习并实践几种常见的数据结构，包括数组、链表、栈和队列。

实验目的：通过本次实验，我们的目标是深入了解数据结构的基本概念和操作，并通过编写代码来实现和应用这些数据结构。

通过实践，我们将能够更好地理解数据结构在实际问题中的应用和效果。

实验过程：1. 数组：数组是一种线性数据结构，它由一系列相同类型的元素组成，这些元素在内存中是连续存储的。

我们首先学习了如何创建和初始化数组，并实现了一些常见的数组操作，如插入、删除和查找元素。

通过编写代码，我们能够更好地理解数组的特点和使用方法。

2. 链表：链表是另一种常见的线性数据结构，与数组不同，链表中的元素在内存中并不连续存储，而是通过指针相互连接。

我们学习了单向链表和双向链表的实现，并实现了插入、删除和查找元素的操作。

链表的灵活性使其在某些情况下比数组更加适用。

3. 栈：栈是一种后进先出（LIFO）的数据结构，类似于弹夹中的子弹。

我们学习了如何使用数组和链表来实现栈，并实现了入栈和出栈的操作。

栈在计算机科学中有广泛的应用，例如函数调用、表达式求值等。

4. 队列：队列是一种先进先出（FIFO）的数据结构，类似于排队等候的人群。

我们学习了如何使用数组和链表来实现队列，并实现了入队和出队的操作。

队列在操作系统、网络通信等领域中有着重要的应用。

实验结果与讨论：通过本次实验，我们成功地实现了数组、链表、栈和队列这几种常见的数据结构，并能够熟练地进行插入、删除和查找等操作。

我们还通过编写一些实际问题的代码，验证了这些数据结构在解决实际问题中的有效性和效率。

结论：数据结构是计算机科学中的重要基础概念，通过本次实验，我们深入了解了几种常见的数据结构，并通过编写代码实现了这些数据结构的基本操作。

这将为我们今后在算法设计和程序开发中提供坚实的基础，并帮助我们更好地理解和解决实际问题。

大学数据结构实验报告模板一、实验目的数据结构实验是计算机相关专业课程中的重要实践环节，通过实验可以加深对数据结构理论知识的理解，提高编程能力和解决实际问题的能力。

本次实验的主要目的包括：1、掌握常见数据结构（如数组、链表、栈、队列、树、图等）的基本操作和实现方法。

2、学会运用数据结构解决实际问题，培养算法设计和分析能力。

3、提高程序设计的规范性和代码质量，培养良好的编程习惯。

4、熟悉编程语言（如C、C+＋、Java 等）的开发环境和调试技巧。

二、实验环境1、操作系统：＿____2、编程语言：＿____3、开发工具：＿____三、实验内容（一）线性表的实现与操作1、顺序表的实现定义顺序表的数据结构。

实现顺序表的初始化、插入、删除、查找等基本操作。

2、链表的实现定义链表的数据结构（单链表、双向链表或循环链表）。

实现链表的创建、遍历、插入、删除等操作。

（二）栈和队列的实现与应用1、栈的实现定义栈的数据结构。

实现栈的入栈、出栈、栈顶元素获取等操作。

利用栈解决括号匹配、表达式求值等问题。

2、队列的实现定义队列的数据结构。

实现队列的入队、出队、队头元素获取等操作。

利用队列实现广度优先搜索、任务调度等应用。

（三）树的实现与遍历1、二叉树的实现定义二叉树的数据结构（二叉链表或顺序存储）。

实现二叉树的创建、前序遍历、中序遍历、后序遍历。

2、二叉搜索树的实现实现二叉搜索树的插入、删除、查找操作。

3、平衡二叉树（如 AVL 树）的实现（选做）理解平衡二叉树的平衡调整算法。

实现平衡二叉树的插入和删除操作，并保持树的平衡。

（四）图的表示与遍历1、图的邻接矩阵和邻接表表示定义图的数据结构（邻接矩阵或邻接表）。

实现图的创建和初始化。

2、图的深度优先遍历和广度优先遍历实现图的深度优先遍历和广度优先遍历算法。

应用图的遍历解决最短路径、连通性等问题。

（五）排序算法的实现与性能比较1、常见排序算法的实现实现冒泡排序、插入排序、选择排序、快速排序、归并排序等算法。