2014年数据结构实验报告_王钟铭2012213651

合集下载

数据结构实验报告_实验报告_

数据结构实验报告_实验报告_

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

数据结构实验报告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一.实验内容:实现哈夫曼编码的生成算法。

数据结构实验报告一

数据结构实验报告一

数据结构实验报告一数据结构实验报告一一、引言数据结构是计算机科学中非常重要的一门课程,它研究的是数据的组织、存储和管理方式。

在本次实验中,我们将学习并实践一些常用的数据结构,包括数组、链表和栈。

通过实验,我们将深入理解这些数据结构的原理和应用。

二、实验目的本次实验的目的是通过编写代码实现一些常用的数据结构,并测试它们的功能和性能。

通过实际操作,我们将掌握这些数据结构的基本操作和使用方法。

三、实验过程1. 数组数组是一种线性数据结构,它由一组连续的存储单元组成。

在本次实验中,我们将实现一个动态数组,它可以根据需要自动调整大小。

我们首先定义一个数组类,包含插入、删除和查找等基本操作。

然后,我们编写测试代码,验证数组的功能和性能。

2. 链表链表是另一种常用的数据结构,它由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。

在本次实验中,我们将实现一个单向链表。

我们首先定义一个节点类,然后定义一个链表类,包含插入、删除和查找等基本操作。

最后,我们编写测试代码,验证链表的功能和性能。

3. 栈栈是一种特殊的线性数据结构,它只能在一端进行插入和删除操作。

栈的特点是后进先出(LIFO)。

在本次实验中,我们将实现一个栈。

我们首先定义一个栈类,包含入栈、出栈和查看栈顶元素等基本操作。

然后,我们编写测试代码,验证栈的功能和性能。

四、实验结果通过实验,我们成功实现了动态数组、单向链表和栈的基本操作。

我们编写了测试代码,并对这些数据结构的功能和性能进行了验证。

实验结果表明,这些数据结构在不同场景下都有很好的表现,并且可以满足我们的需求。

五、实验总结本次实验让我们更加深入地理解了数据结构的原理和应用。

通过实际编写代码并进行测试,我们掌握了数组、链表和栈等常用数据结构的基本操作和使用方法。

实验过程中,我们遇到了一些问题,但通过不断的调试和优化,最终成功解决了这些问题。

通过本次实验,我们不仅提高了编程能力,也增强了对数据结构的理解和应用能力。

数据结构课程设计实验报告

数据结构课程设计实验报告

《数据结构》实验报告◎实验题目: 数据结构课程设计(无向连通网的问题求解)◎实验目的:通过本次课程设计,掌握无向连通网的性质,熟悉其关于最短哈密尔顿回路以及最短路径的求解。

◎实验内容:对于具有n(n>=10)个顶点的无向连通网,设计一个算法(1)找出网中最短的哈密尔顿回路;(2)找出任意两个顶点之间的最短路径,须经过指定1个或2个顶点。

一、需求分析1.本演示程序中,输入的无向连通网为任意给定的,输入时应该给定无向连通网的大小、范围,即顶点数以及边数,而输出有三个问题的求解答案,分别输出其路径及权值大小。

2.本演示程序为人机对话,用户可以按照提示进行输入,然后选择需要求解的问题,则有结果输出。

3.程序执行的命令包括:(1)构建无向连通网(2)选择求解问题序号(3)第一个为求解最短哈密顿回路(3)第二个为求解任意两点之间的最短路径,须经过指定1个顶点(4)第三个为求解任意两点之间的最短路径,须经过指定2个顶点(5)结束4.测试数据:(1)请输入顶点数和边数(输入格式为:顶点数,边数):11,17(2)请输入顶点信息(输入格式为:顶点号):0 1 2 3 4 5 6 7 8 9 10(3)请输入每条边对应的两个顶点号及其权值(输入格式为:顶点,顶点,权值:):0,6,50,7,40,4,31,4,11,6,81,3,22,4,62,3,32,10,73,5,85,10,35,9,86,7,17,8,47,9,68,9,29,10,6(4)请选择操作:<1>如果选择输入为1,结果为:最短哈密尔顿回路为:0->6->7->8->9->5->10->2->3->1->4->0权值为:5+1+4+2+8+3+7+3+2+1+3=39<2>如果选择输入为2,结果为:请输入指定起始点:0请输入指定终点:6请输入路径经过指定的顶点:10输出路径是:0->4->2->10->9->7->6起始点为0终点为6的经过指定点10的最短路径为:29<3>如果选择输入为3,结果为:请输入指定起始点:4请输入指定终点:1请输入路径经过指定的顶点一:8请输入路径经过指定的顶点二:3输出路径是:4->1->3->1->6->7->8->7->6->1起始点为4终点为1的经过指定点一8以及指定点二3的最短路径为:31<4>如果选择输入为0,结果为:结束.二概要设计为了实现上述操作,无向连通网用邻接矩阵存储结构,解决哈密顿回路问题时应用栈。

数据结构实验报告实验

数据结构实验报告实验

湖南师范大学工程与设计学院数据结构实验报告姓名:张荣年级:2013级专业:应用电子技术教育学号:2013180323任课教师:肖柳明开课时间:2014~2015学年第二学期一、算法基本思想:二、结构定义://顺序表结构体的定义typedef struct{ElemType *elem;int length;int listsize;}Sqlist;//链表结构体的定义typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;三、算法描述:四、程序清单:Status InitList_Sq(Sqlist &L) { //构造一个空的线性表LL.elem = (ElemType *) malloc (LIST_INIT_SIZE * sizeof(ElemType) ); //产生头结点,并使L指向此节点if(!L.elem) exit( OVERFLOW ); //存储分配失败L.length=0; //空表长度为0L.listsize = LIST_INIT_SIZE;//初始存储容量return OK;}//输入顺序表AStatus ListInsert_Sq ( Sqlist &L, int i, ElemType e ){//在顺序线性表L中第i个位置之前插入新的元素e,//i的合法值为1≤i≤ListInsert_Sq(L)+1ElemType *newbase, *p, *q;if(i<1 || i>L.length+1) return ERROR; //i值不合法if(L.length>=L.listsize){ //当前存储空间已满,增加分配newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));if(!newbase) exit(OVERFLOW); //存储分配失败L.elem = newbase; //新基址L.listsize += LISTINCREMENT; } //增加存储容量q = &(L.elem[i-1]); //q为插入位置for( p = &(L.elem[L.length-1]); p >= q; --p)*(p+1)=*p; //插入位置及之后的元素右移*q = e; //插入e++L.length; //表长曾1return OK; }//显示顺序表AStatus ListDisplay(Sqlist A){int i=0;while(i < A.length) {printf("%4d", A.elem[i]);i++; }return OK; }//顺序表排序void Mergelist_Sq(Sqlist &La, Sqlist &Lb, Sqlist &Lc) {//已知顺序线性表La和Lb的元素值按非递减排列//归并La和Lb得到新的顺序线性表Lc,Lc的元素值也按非递减排列ElemType *pa, *pb, *pc, *pa_last, *pb_last;pa = La.elem;pb = Lb.elem;Lc.listsize = Lc.length = La.length + Lb.length;Lc.elem = (ElemType*) malloc (Lc.listsize * sizeof(ElemType)); //分配Lc.listsize的存储空间pc = Lc.elem;if(!Lc.elem) exit(OVERFLOW); //存储分配失败pa_last = La.elem + La.length - 1;pb_last = Lb.elem + Lb.length - 1;while( pa <= pa_last && pb <= pb_last){ //归并if(*pa <= *pb) *pc++ = *pa++;else *pc++ = *pb++;}while(pa <= pa_last) *pc++ = *pa++; //插入La的剩余元素while(pb <= pb_last) *pc++ = *pb++; //插入Lb的剩余元素}//构造链表BStatus InitList_L(LinkList &L){L= (LinkList)malloc(sizeof(LNode));L->next=NULL;return OK; }Status ListInsert_L(LinkList &L,int i,ElemType e){ //在带头结点的单链线性表L中第i 个位置之前插入元素eLinkList p,s;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;} //寻找i-1个节点if(!p||j>i-1) return ERROR; //i小于1或者大于表长+1s=(LinkList)malloc(sizeof(LNode)); //生成新节点s->data=e;s->next=p->next; //插入L中p->next=s;return OK;}//显示链表Bvoid Display_L(LinkList L){LinkList p=L->next;if(!p) printf("此链表为空!");while(p){printf("%4d",p->data);p=p->next;printf(" ");}printf("\n"); }//链表排序void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc){//已知单链线性表La和Lb的元素按非递减排列。

数据结构课程实验报告

数据结构课程实验报告

数据结构课程实验报告一、实验目的。

本次实验旨在通过对数据结构课程所学知识的应用,加深对数据结构相关算法和数据操作的理解,提高学生的编程能力和实际应用能力。

二、实验内容。

1. 实现顺序表、链表、栈、队列等数据结构的基本操作;2. 设计并实现数据结构相关算法,如查找、排序等;3. 进行实验数据的输入、输出和结果展示;4. 对实验结果进行分析和总结。

三、实验过程。

1. 针对顺序表、链表、栈、队列等数据结构,首先进行了相关操作的实现。

在实现过程中,需要考虑数据结构的特点和操作规则,确保操作的正确性和高效性。

2. 针对数据结构相关算法,如查找、排序等,设计并实现了相应的算法。

在实现过程中,需要考虑算法的时间复杂度和空间复杂度,确保算法的效率和稳定性。

3. 进行了实验数据的输入、输出和结果展示。

通过编写测试用例,对实现的数据结构和算法进行了测试,验证其正确性和可靠性。

4. 对实验结果进行了分析和总结。

通过对实验数据和测试结果的分析,总结了实验中遇到的问题和解决方法,以及实验的收获和体会。

四、实验结果。

经过实验测试,实现的数据结构和算法均能正确运行并得到预期的结果。

通过实验,加深了对数据结构相关知识的理解,提高了编程能力和实际应用能力。

五、实验总结。

本次实验使我对数据结构相关知识有了更深入的理解,同时也提高了我的编程能力和实际应用能力。

在未来的学习和工作中,我将继续努力,不断提升自己的能力,为将来的发展打下坚实的基础。

六、实验感想。

通过本次实验,我深刻感受到了数据结构在实际应用中的重要性,也意识到了自己在数据结构方面的不足之处。

在今后的学习和工作中,我将更加努力地学习和应用数据结构知识,不断提高自己的能力,为未来的发展做好充分的准备。

七、参考文献。

1. 《数据结构与算法分析》。

2. 《C语言程序设计》。

3. 《数据结构课程实验指导书》。

以上就是本次数据结构课程实验的报告内容,希望能对大家有所帮助。

感谢您的阅读!。

《数据结构》 实验报告4

《数据结构》 实验报告4

xxx实验报告课程名称数据结构实验名称实验四排序操作系部班级姓名学号实验时间2012 年12月10日时分~时分地点机位评语指导教师:成绩一、实验目的1. 掌握常用的排序方法,并掌握用高级语言实现排序算法的方法;2. 深刻理解排序的定义和各种排序方法的特点,并能加以灵活应用;3. 了解各种方法的排序过程及其时间复杂度的分析方法。

二、实验内容统计成绩:给出n个学生的考试成绩表,每条信息由姓名和分数组成,试设计一个算法:(1)按分数高低次序,打印出每个学生在考试中获得的名次,分数相同的为同一名次;(2)按名次列出每个学生的姓名与分数。

三、实验步骤1. 定义结构体。

2. 定义结构体数组。

3. 定出主程序,对数据进行排序。

四、程序主要语句及作用1. 程序原代码如下:#include <string.h>#include "stdio.h"#include <malloc.h>#include <conio.h>typedef struct BSTNODE{int data;struct BSTNODE *lchild;struct BSTNODE *rchild;}BSTNODE;BSTNODE* initBST(int n, BSTNODE *p){if(p==NULL){p=(BSTNODE*)malloc(sizeof(BSTNODE));p->lchild=NULL;p->rchild=NULL;p->data=n;}else if(n>p->data)p->rchild=initBST(n,p->rchild);elsep->lchild=initBST(n,p->lchild);return p;}void inorder(BSTNODE *BT){if(BT!=NULL){inorder(BT->lchild);printf("%d ",BT->data);inorder(BT->rchild);}}BSTNODE *search_btree(BSTNODE *root,int key) { if (!root){printf("Emptu btree\n"); return root; }while(root->data!=key){ if(key<root->data)root=root->lchild;elseroot=root->rchild;if(root==0){ printf("Search Failure\n");break ;}} /* while(root->info!=key) */if (root !=0)printf("Successful search\n key=%d\n",root->data);return root ;} /* *search_btree(root,key) */int main(){BSTNODE *p=NULL;int i,n,sd;int a[100];printf("enter the number of nodes:");scanf("%d",&n);printf("enter the number of the tree:");for(i=0;i<n;i++){scanf("%d",&a[i]);p=initBST(a[i],p);}inorder(p);printf("\n please input search data:");scanf("%d",&sd);search_btree(p,sd);getch();return 1;}2. 运行结果截图:五、总结体会本次试验让我学习到了很多也认识到了自己的不足:1.大部分的时间都用在了编程上,主要是因为C语言掌握的问题,C语言基础不好特别是对于C语言中链表的一些定义和基本操作不够熟练,导致在编程过程中还要不断的拿着c语言的教材查找,所以今后还要对C语言多练习,多动手,多思考。

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

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

实验报告(一)一、实验目的: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。

河南自考数据结构实验报告

河南自考数据结构实验报告

河南省高等教育自学考试实验报告册计算机及应用专业(本科段)《数据结构》姓名准考证号所属地市实验地点实验日期 2实验总成绩指导教师签名实验单位(实验室)意见:主考院校审核意见:河南科技大学自学考试办公室2014 年9 月21 日目录一、试验报告要求------------------------------------------------ 1二、实验一:单链表的操作------------------------------------ 2三、实验二:图的遍历操作------------------------------------ 6四、实验三:数据查找-------------------------------------------9五、实验四:排序------------------------------------------------ 11实验报告要求1、实验报告应包括以下内容:(1)程序清单(2)实验结果(3)分析与讨论2、实验报告应写明实验名称、班号、实验者姓名、学号、将实验报告整理装订好,按指导教师规定的时间上交。

基本实验方法本实验环节要求学生能够顺利完成《数据库原理》、《数据结构》、《操作系统》、《面向对象程序设计》及门课程的实验操作实验所用器件、设备的简单介绍所有实验在586以上的微机上进行,运行环境为VFP、C语言、C++语言和windows、linux 操作系统。

实验一单链表的操作一、实验学时:2学时二、实验目的:熟悉数据库在链式存储结构下各种算法的实现。

三、实验设备:本实验在586以上的微机上进行,运行环境为TurboC语言。

四、样例:(参看《实践性环节培训与考核基本要求》p2)五、实验内容:功能:●建立一个数据域存放的是字符串的单链表;●输入一个指定的字符串,插入到单链表的指定位置;●删除单链表中制定的字符串;●遍历单链表。

输入要求:输入N个字符串(长度小于6),建立含有N个节点的单链表,要求输入的字符串不重复。

数据结构实验报告

数据结构实验报告

数据结构实验报告一、实验目的数据结构是计算机科学中的重要基础课程,通过实验可以更深入地理解和掌握数据结构的概念、原理和应用。

本次实验的主要目的包括:1、熟悉常见的数据结构,如链表、栈、队列、树和图等。

2、掌握数据结构的基本操作,如创建、插入、删除、遍历等。

3、提高编程能力和解决实际问题的能力,能够运用合适的数据结构解决具体的问题。

二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 2019。

三、实验内容1、链表的实现与操作单向链表的创建、插入和删除节点。

双向链表的实现和基本操作。

循环链表的特点和应用。

2、栈和队列的实现栈的后进先出特性,实现入栈和出栈操作。

队列的先进先出原则,完成入队和出队功能。

3、树的操作二叉树的创建、遍历(前序、中序、后序)。

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

4、图的表示与遍历邻接矩阵和邻接表表示图。

深度优先搜索和广度优先搜索算法的实现。

四、实验步骤及结果1、链表的实现与操作单向链表:首先,定义了链表节点的结构体,包含数据域和指向下一个节点的指针域。

通过创建链表头节点,并使用循环依次插入新节点,实现了链表的创建。

插入节点时,根据指定位置找到插入点的前一个节点,然后修改指针完成插入操作。

删除节点时,同样找到要删除节点的前一个节点,修改指针完成删除。

实验结果:成功创建、插入和删除了单向链表的节点,并正确输出了链表的内容。

双向链表:双向链表节点结构体增加了指向前一个节点的指针。

创建、插入和删除操作需要同时维护前后两个方向的指针。

实验结果:双向链表的各项操作均正常,能够双向遍历链表。

循环链表:使链表的尾节点指向头节点,形成循环。

在操作时需要特别注意循环的边界条件。

实验结果:成功实现了循环链表的创建和遍历。

2、栈和队列的实现栈:使用数组或链表来实现栈。

入栈操作将元素添加到栈顶,出栈操作取出栈顶元素。

实验结果:能够正确进行入栈和出栈操作,验证了栈的后进先出特性。

数据结构实验报告

数据结构实验报告

数据结构课程设计报告设计题目:N皇后问题学生姓名:学生学号:专业班级:信息与计算科学2班学院名称:数学与计量经济学院同组人姓名:指导老师:2014 年9月 5 日目录1 需求分析 (1)1.1 问题描述 (1)1.2 输入数据要求 (1)1.3 输出数据要求 (1)2概要设计 (1)2.1 总体设计思路................................................................................... 错误!未定义书签。

2.2 抽象数据类型定义........................................................................... 错误!未定义书签。

3详细设计 (3)3.1 数据类型定义 (3)3.2 非递归模块实现方法 (4)3.2.1.算法思想 (4)3.2.2.伪码算法 (4)3.3 递归模块实现方法 (5)3.3.1.算法思想 (5)3.3.2.伪码算法 (5)4测试结果及分析 (6)总结 (6)1 需求分析1.1问题描述N皇后问题是由十九世纪著名数学家高斯1850年首次提出:在8X8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法,演变至今成为回溯法典型例题。

N皇后问题的规则:在n×n格的棋盘上放置彼此不受攻击的n个皇后。

按照国际象棋的规则,皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

n后问题等价于在n ×n格的棋盘上放置n个皇后,任何2个皇后不放在同一行或同一列或同一斜线上。

1.2输入数据要求输入数据n表示一共放置的皇后数,因此n必须满足时正整数。

1.3输出数据要求用n元组x[1:n]表示n后问题的解。

其中,x[i]表示皇后i放在棋盘上的第i行的第x[i]列。

用result[n+1][n+1]记录所有可行方案。

数据结构实验报告四

数据结构实验报告四

甘肃政法学院本科生实验报告()姓名:学院:\专业:班级:13级实验课程名称:数据结构实验日期:2014年5月30日指导教师及职称:实验成绩:开课时间:2013-2014学年第二学期甘肃政法学院实验管理中心印制实验题目树形结构小组合作否姓名班级学号一、实验目的8.1实现图的邻接矩阵和邻接表储存8.2实现图的遍历算法8.3求所有深度优先遍历序列8.4用图搜索方法求解迷宫问题8.5求有向图的简单路径8.6求无向图的深度优先生成树和广度优先生成树8.7用普利姆算法求最小生成树8.8采用克鲁斯卡尔算法求最小生成树8.9采用狄克斯特拉算法求有向带权图的最短路径8.10采用弗洛伊德算法求有向带权图的最短路径二.实验环境安装了Windows7操作系统,并且安装了Microsoft Visual C++6.0。

三、实验内容与步骤1、安装Microsoft Visual C++6.0。

2打开Microsoft Visual C++6.0四实验过程:8.1实现图的邻接矩阵和邻接表储存编写一个程序algo8-1,实现不带权图和带权图的邻接矩阵与邻接表的相互转化算法、输出邻接矩阵与邻接表的运算并在此基础上设计一个主程序完成如下功能:(1)建立如图所示的有向G邻接矩阵,并输出之;(2)由有向图G的邻接矩阵产生邻接表,并输出之;(3)再由(2)的邻接表产生相应的邻接矩阵,并输出之○1新建工程○2选择“Hello,world!程序”○3选择Fileview○4复制algo8-1和Graph到工程文件中。

○5把主文件大开,用exp8-1的内容覆盖到主文件○6由于main()函数被重复定义所以需要备注,把algo8-1中主函数备注掉,并且手动引入#include“algo8-1.cpp”。

○7运行程序,如下图:输入代码如下:8.2实现图的遍历算法编写一个程序algo8-2,实现实现图的遍历算法并在此基础上设计一个exp8-2.cpp程序完成如下功能:(1)输出有向图G从丁丁点0开始的深度优先遍历序列(递归算法)(2)输出有向图G从丁丁点0开始的深度优先遍历序列(非递归算法)(3)输出有向图G从丁丁点0开始的广度优先遍历序列(4)○1新建工程○2选择“Hello,world!程序”○3选择Fileview○4复制algo8-1和algo8-2和Graph到工程文件中。

数据结构实验报告及心得体会

数据结构实验报告及心得体会

数据结构实验报告及心得体会一、实验背景和目的本次实验的目的是通过设计和实现常见的数据结构,来加深对数据结构的理解,并能够熟练运用。

实验中使用的数据结构有栈、队列和链表,通过这些数据结构的设计和应用,能够更好地掌握数据结构的原理和应用。

二、实验过程1. 栈的设计和实现在本次实验中,我设计了一个基于数组的栈,用于存储数据。

首先,我定义了一个栈类,包含栈的容量、栈顶指针和存储数据的数组。

然后,我实现了入栈、出栈和判断栈空、栈满的操作。

在测试阶段,我编写了一些测试用例,验证栈的功能和正确性。

2. 队列的设计和实现在本次实验中,我设计了一个基于链表的队列。

首先,我定义了一个队列类,包含队列的头指针和尾指针。

然后,我实现了入队、出队和判断队列空、队列满的操作。

在测试阶段,我编写了一些测试用例,验证队列的功能和正确性。

3. 链表的设计和实现在本次实验中,我设计了一个能够存储任意数据类型的单链表。

首先,我定义了一个链表类,包含链表的头指针和尾指针。

然后,我实现了插入、删除和查找节点的操作。

在测试阶段,我编写了一些测试用例,验证链表的功能和正确性。

三、实验结果和分析通过本次实验,我成功设计和实现了栈、队列和链表这三种常见的数据结构。

在测试阶段,我对这些数据结构进行了充分的测试,验证了它们的功能和正确性。

在测试过程中,我发现栈和队列在实际应用中具有很大的作用。

例如,在计算表达式的过程中,可以利用栈来实现中缀表达式转后缀表达式的功能;在操作系统中,可以利用队列来实现进程的调度。

此外,在实验过程中,我还进一步加深了对数据结构的理解。

通过设计和实现数据结构,我学会了如何根据问题的需求选择合适的数据结构,并能够运用数据结构解决实际问题。

在实现过程中,我遇到了一些问题,例如链表的插入和删除操作需要考虑前后指针的变化,但通过不断的实践和思考,最终成功解决了这些问题。

同时,我还注意到数据结构的时间复杂度和空间复杂度对算法的性能有着重要的影响,因此在设计数据结构时需要充分考虑这些因素。

数据结构实验报告2014S1

数据结构实验报告2014S1

递推方法:
附言:
1.本次实验所有文件(实验报告、源程序)放在以“班级学号姓名-数据结构与算法
实验S1”为名称的文件夹中注意,学号放在名称前面,再打包成.rar的压缩格式。

2.报告下周交,不得超过二周。

在实验室上传或以附件形式发到我的邮箱:
bbwhs@,主题标注“数据结构实验报告S1”字样。

3.实验无论是否成功请不要互相抄袭,如实验不成功仍可以附以各种说明和分析以及
不成功的图片,找出解决方案后下次再修改。

报告在老师评阅后仍允许同学们再次
修定重交。

每个实验以最好结果计分,抄袭者0分。

数据结构实验报告

数据结构实验报告

《数据结构》实验报告◎实验题目:合并两个链表,设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也同样是有序循环链表。

数据结构实验报告

数据结构实验报告
cout<<"'M'------Show this menu."<<endl;
cout<<"'B'------Build up tree: read character set and frequency of each character, build up hfm tree."<<endl;
cout<<"'T'------Trace the tree: PreOrder and InOrder the BTree."<<endl;
HfmTree<int> hfm;
HfmNode* ht;
HfmCode* hc;
char s[1000];
repeat1:
cout<<endl;
cout<<"Please input your chioce: "; cin>>choice;
cout<<endl;
if(choice=='b' || choice=='B')
cout<<"Allocating the complete."<<endl;
cout<<"---------------------------------------------------------------"<<endl;
cout<<"Please input all the elementary codes: "<<endl;

数据结构 实验报告

数据结构 实验报告

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

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

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

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

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

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

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

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

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

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

3. 栈:栈是一种后进先出(LIFO)的数据结构,类似于弹夹中的子弹。

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

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

4. 队列:队列是一种先进先出(FIFO)的数据结构,类似于排队等候的人群。

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

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

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

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

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

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

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

院系:计算机科学学院专业:软件工程年级: 12级课程名称:数据结构学号: 2012213651 姓名:王钟铭指导教师:宋中山2014年 5月 7 日年级 2012级班号 01 学号2012213651专业软件工程姓名王钟铭实验名称一元稀疏多项式计算器设计实验类型设计型综合型创新型√实验目的或要求1. 练习使用链表等常见的线性结构2. 熟练掌握数据结构中基本算法的设计和使用3. 有基本的输入输出设计实验原理(算法流程图或者含注释的源代码)#include<stdio.h>#include<malloc.h>#include<iostream.h>typedef struct Polynode{float coef; //系数int exp; //指数struct Polynode *next;}*Poly,Polynode; //Poly为结点指针类型void Insert(Poly p,Poly head){if(p->coef==0) //系数为0时释放结点 free(p);else{Poly q1,q2;q1=head;q2=head->next;while(q2&&p->exp<q2->exp){//后移查找插入位置q1=q2;q2=q2->next;}if(q2&&p->exp==q2->exp){//将指数相同的相合并q2->coef+=p->coef;free(p);实验原理(算法流程图或者含注释的源代码) if(!q2->coef) //系数为0时释放结点{q1->next=q2->next;free(q2);}}else{p->next=q2;q1->next=p;}}}//InsertPoly CreateList(Poly head,int m){//建立一个头指针为head、项数为m的一元多项式int i;Poly p;Polynode *q;p=head=(Poly)malloc(sizeof(struct Polynode));head->next=NULL;for(i=0;i<m;i++){p=(Poly)malloc(sizeof(struct Polynode));//建立新结点以接收数据 cout<<"请输入第"<<i+1<<"项的系数与指数: ";cin>>p->coef>>p->exp;Insert(p,head); //调用Insert函数插入结点}q=head->next;while(q!=NULL){cout<<"系数:"<<q->coef<<"\t"<<"指数 : "<<q->exp<<endl;q=head->next;}return head;}//CreatePolyvoid DestroyList(Poly p){//销毁多项式pPoly q1,q2;if(p->next!=NULL){q1=p->next;q2=q1->next;实验原理(算法流程图或者含注释的源代码)while(q1->next){free(q1);q1=q2;//指针后移q2=q2->next;}}}int OutputList(Poly P){//输出多项式Poly q=P->next;int flag=1;//项数计数器if(!q){//若多项式为空,输出0cout<<" 0 "<<endl;return(0);}while (q){if(q->coef>0&&flag!=1) //系数大于0且不是第一项cout<<"+";if(q->coef!=1&&q->coef!=-1)//系数非1或-1的普通情况 {cout<<q->coef;if(q->exp==1)cout<<"X";else if(q->exp)cout<<"X^"<<q->exp;}else{if(q->coef==1){if(!q->exp)cout<<"1";else if(q->exp==1)cout<<"X";else if(q->exp)cout<<"X^"<<q->exp;}if(q->coef==-1)实验原理(算法流程图或者含注释的源代码) if(!q->exp) cout<<"-1";else if(q->exp==1) cout<<"-X";else cout<<"-X^"<<q->exp;}}q=q->next;flag++;}//whilecout<<endl;return(0);}//OutputPolyint compare(Poly a,Poly b){if(a&&b){if(!b||a->exp>b->exp) return 1;else if(!a||a->exp<b->exp) return -1;else return 0;}else if(!a&&b) return -1;//a多项式已空,但b多项式非空 else return 1;//b多项式已空,但a多项式非空}//comparePoly AddPoly(Poly pa,Poly pb){//求解并建立和多项式a+b,返回其头指针Poly qa=pa->next;Poly qb=pb->next;Poly headc,hc,qc;hc=(Poly)malloc(sizeof(struct Polynode));//建立头结点 hc->next=NULL;headc=hc;while(qa||qb){qc=(Poly)malloc(sizeof(struct Polynode));switch(compare(qa,qb)){case 1:{qc->coef=qa->coef;qc->exp=qa->exp;qa=qa->next;break;实验原理(算法流程图或者含注释的源代码) case 0:{qc->coef=qa->coef+qb->coef;qc->exp=qa->exp;qa=qa->next;qb=qb->next;break;}case -1:{qc->coef=qb->coef;qc->exp=qb->exp;qb=qb->next;break;}}//switchif(qc->coef!=0){qc->next=hc->next;hc->next=qc;hc=qc;}else free(qc);//当相加系数为0时,释放该结点}//whilereturn headc;}//AddPolyPoly SubtractPoly(Poly pa,Poly pb){//求解并建立和多项式a-b,返回其头指针Poly qa=pa->next;Poly qb=pb->next;Poly headc,hc,qc;hc=(Poly)malloc(sizeof(struct Polynode));//建立头结点 hc->next=NULL;headc=hc;while(qa||qb){qc=(Poly)malloc(sizeof(struct Polynode));switch(compare(qa,qb)){case 1:{qc->coef=qa->coef;qc->exp=qa->exp;实验原理(算法流程图或者含注释的源代码) qa=qa->next;break;}case 0:{qc->coef=qa->coef-qb->coef;qc->exp=qa->exp;qa=qa->next;qb=qb->next;break;}case -1:{qc->coef=-qb->coef;qc->exp=qb->exp;qb=qb->next;break;}}//switchif(qc->coef!=0){qc->next=hc->next;hc->next=qc;hc=qc;}else free(qc);//当相减系数为0时,释放该结点}//whilereturn headc;}//AddPolyPoly MultiplyPoly(Poly pa,Poly pb){//求解并建立积多项式a*b,返回其头指针Poly hf,pf;Poly qa=pa->next;Poly qb=pb->next;hf=(Poly)malloc(sizeof(struct Polynode));//建立头结点 hf->next=NULL;for(qa=pa->next;qa;qa=qa->next){for(qb=pb->next;qb;qb=qb->next){pf=(Poly)malloc(sizeof(struct Polynode));pf->coef=qa->coef*qb->coef;pf->exp=qa->exp+qb->exp;实验原理(算法流程图或者含注释的源代码) Insert(pf,hf);//调用Insert函数以合并指数相同的项}}return hf;}//MultiplyPolyvoid DevicePoly(Poly pa,Poly pb){//求解并建立商多项式a/b,返回其头指针Poly hf,pf,temp1,temp2;Poly qa=pa->next;Poly qb=pb->next;hf=(Poly)malloc(sizeof(struct Polynode));//建立头结点,存储商hf->next=NULL;pf=(Poly)malloc(sizeof(struct Polynode));//建立头结点,存储余数 pf->next=NULL;temp1=(Poly)malloc(sizeof(struct Polynode));temp1->next=NULL;temp2=(Poly)malloc(sizeof(struct Polynode));temp2->next=NULL;temp1=AddPoly(temp1,pa);while(qa!=NULL&&qa->exp>=qb->exp){temp2->next=(Poly)malloc(sizeof(struct Polynode));temp2->next->coef=(qa->coef)/(qb->coef);temp2->next->exp=(qa->exp)-(qb->exp);Insert(temp2->next,hf);pa=SubtractPoly(pa,MultiplyPoly(pb,temp2));qa=pa->next;temp2->next=NULL;}pf=SubtractPoly(temp1,MultiplyPoly(hf,pb));cout<<"商是:";OutputList(hf);cout<<"余数是:";OutputList(pf);}//DevicePolyfloat ValuePoly(Poly head,float x){//输入x值,计算并返回多项式的值Poly p;int i;float sum=0,t;for(p=head->next;p;p=p->next)实验原理(算法流程图或者含注释的源代码) {t=1;for(i=p->exp;i!=0;){if(i<0){t/=x;i++;}//指数小于0,进行除法else{t*=x;i--;}//指数大于0,进行乘法}sum+=p->coef*t;}return sum;}//ValuePolyPoly Derivative(Poly head){//求解并建立a的导函数多项式,并返回其头指针Poly q=head->next,p1,p2,hd;hd=p1=(Poly)malloc(sizeof(struct Polynode));//建立头结点 hd->next=NULL;while(q){if(q->exp!=0){ //该项不是常数项时p2=(Poly)malloc(sizeof(struct Polynode));p2->coef=q->coef*q->exp;p2->exp=q->exp-1;p2->next=p1->next;//尾插法插入结点p1->next=p2;p1=p2;}else if(q->exp==0) //该项为常数项break;q=q->next;}return hd;}//Dervativeint main(){int m,n,flag=0;float x;Poly pa=0,pb=0,pc,pd,pe,pf;//定义各式的头指针,pa与pb在使用前付初值NULL cout<<"请输入a的项数:" ;cin>>m;pa=CreateList(pa,m);//建立多项式acout<<"请输入b的项数:" ;cin>>n;pb=CreateList(pb,n);//建立多项式a//输出菜单cout<<"****************************************************************** ***"<<endl;cout<<" 1.输出多项式a和b 2.建立多项式a+b 3.建立多项式a-b"<<endl;cout<<" 4.建立多项式a*b 5.建立多项式a/b"<<endl;cout<<" 6.计算多项式a在x处的值 7.求多项式a的导函数 8.退出程序"<<endl;cout<<"****************************************************************** ***"<<endl;for(;;flag=0){cout<<"执行操作为:" ;cin>>flag;if(flag==1){cout<<"多项式a为:";OutputList(pa);cout<<"多项式b为:";OutputList(pb);continue;}if(flag==2){pc=AddPoly(pa,pb);cout<<"多项式a+b为:";OutputList(pc);DestroyList(pc);continue;}if(flag==3){pd=SubtractPoly(pa,pb);cout<<"多项式a-b为:";OutputList(pd);DestroyList(pd);continue;if(flag==4){pe=MultiplyPoly(pa,pb);cout<<"多项式a*b为:";OutputList(pe);DestroyList(pe);continue;}if(flag==5){DevicePoly(pa,pb);continue;}if(flag==6){cout<<"请输入x的值:x=";cin>>x;cout<<"多项式a的值为:"<<ValuePoly(pa,x)<<endl; continue;}if(flag==7){pf=Derivative(pa);cout<<"多项式a的导函数为:";OutputList(pf);DestroyList(pf);continue;}if(flag==8)break;if(flag<1||flag>8)cout<<"输入错误!!!请重新选择!!";continue;}DestroyList(pa);DestroyList(pb);return 0;}以(x+x^3)+(-x-x^3)=0为测试数据测试图如下:实验结果分析及心得体会1.体会了链表结构的定义和操作过程2.进一步加深了自己对于线性表结构的了解3.锻炼了自己的常用算法的设计能力4.对于自己的抽象思维和逻辑思维能力有所提高成绩评定教师签名:年月日年级 2012级班号 01 学号2012213651专业软件工程姓名王钟铭实验名称算数表达式求值演示实验类型设计型综合型创新型√实验目的或要求1. 学习栈的使用2. 掌握算法表达式的核心算法3. 加强自己的逻辑思维能力实验原理(算法流程图或者含注释的源代码)#include <iostream>#include <stack>using namespace std;int Operate(int x,char op,int y) //四则运算符的运算定义{switch(op){case'+': return x+y;case'-': return x-y;case'*': return x*y;case'/': return x/y;}}char Precede(char op1,char op2) //判断符号的优先级{if(((op1=='+'||op1=='-')&&(op2=='+'||op2=='-'||op2==')'||op2=='#'))||((op1= ='*'||op1=='/')&&(op2=='+'||op2=='-'||op2=='*'||op2=='/'||op2==')'||op2=='# ')))return '>';if((op1=='('&&op2==')')||(op1=='#'&&op2=='#'))return '=';elsereturn '<';}void Tonumber(char &c,stack<int> &OPND) //转化为数字{int number=0;if(((c-'0')>=0&&(c-'0')<=9)){while(((c-'0')>=0&&(c-'0')<=9))实验原理(算法流程图或者含注释的源代码) {number=number*10+(c-'0');cin>>c;}OPND.push(number);}}int main(){stack<char> OPTR;stack<int> OPND;//设OPTR和OPND分别为运算符栈和运算数栈OPTR.push('#'); //出栈时的结尾判断char c,op1,op2,op;int x,y,temp=1;cout<<"输入表达式,以'#'结束:";cin>>c;while(c!='#'||OPTR.top()!='#'){Tonumber(c,OPND);if(c!='+'&&c!='-'&&c!='*'&&c!='/'&&c!='('&&c!=')'&&c!='#') {OPND.push(c);cin>>c;}else{op1=OPTR.top();op2=c;switch(Precede(op1,op2)){case '<': //栈顶元素优先级低OPTR.push(c);cin>>c;break;case '=': //脱括号并接受下一个字符OPTR.pop();cin>>c;break;case '>': op=OPTR.top(); //退栈并将运算结果入栈OPTR.pop();x=OPND.top();实验原理(算法流程图或者含注释的源代码) OPND.pop();y=OPND.top();OPND.pop();OPND.push(Operate(y,op,x));int a=OPND.top();break;}}}cout<<"计算结果是:"<<OPND.top()<<endl; return 0;}实验原理(算法流程图或者含注释的源代码)实验原理(算法流程图或者含注释的源代码)实验结果分析及心得体会1.体会了栈结构的定义和操作过程2.进一步加深了自己对于栈结构的了解3.锻炼了自己的常用算法的设计能力4.对于自己的抽象思维和逻辑思维能力有所提高成绩评定教师签名:年月日年级 2012级班号 01 学号2012213651专业软件工程姓名王钟铭实验名称创建二叉树并按要求进行显示实验类型设计型综合型创新型√实验目的或要求1、创建一棵二叉树2、无递归实现两棵树的拷贝操作3、将二叉树桉树的形状输出到界面上实验原理(算法流程图或者含注释的源代码)#include<stdlib.h>#include <stdio.h>#include <string.h>#include<stack>#include<queue>typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;typedef BiTree QElemType; // 设队列元素为二叉树的指针类型BiTree Create(BiTree T){//该算法实现创建二叉树的过程char ch;ch=getchar();if(ch=='#')T=NULL;else{if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))printf("Error!");T->data=ch;T->lchild=Create(T->lchild);T->rchild=Create(T->rchild);}return T;}void CopyBiTree(BiTree T, BiTree &TT)//把T复制到TT之中/* 基于层次遍历的非递归复制二叉链表 */{QElemType p;queue<QElemType> t2,tt2;if(!T)TT=NULL;else{实验原理(算法流程图或者含注释的源代码)t2.push(T);//将T节点复制到t2之中if(!(TT=(BiTNode*)malloc(sizeof(BiTNode))))exit(-2);p=TT;p->data=T->data;//复制根节点到p之中p->lchild=p->rchild=NULL;tt2.push(p);//把根节点复制下来while(!t2.empty()){t2.push(T);//DeQueue(t2,T);tt2.push(p);//DeQueue(tt2,p);if(T->lchild){t2.push(T->lchild);//EnQueue(t2,T->lchild);if(!(p->lchild=(BiTNode*)malloc(sizeof(BiTNode))))exit(-2);p->lchild->data=T->lchild->data;p->lchild->lchild=p->lchild->rchild=NULL;tt2.push(p->lchild);//EnQueue(tt2,p->lchild);}if(T->rchild){t2.push(T->rchild);//EnQueue(t2,T->rchild);if(!(p->rchild=(BiTNode*)malloc(sizeof(BiTNode))))exit(-2);p->rchild->data=T->rchild->data;p->rchild->lchild=p->rchild->rchild=NULL;tt2.push(p->rchild);//EnQueue(tt2,p->rchild);}}} }void PreOrder_Nonrecursive(BiTree T)//先序遍历二叉树的非递归算法{stack<BiTree> S;S.push(T); //根指针进栈while(!StackEmpty(S)){while(Gettop(S,p)&&p){visit(p->data);push(S,p->lchild);} //向左走到尽头pop(S,p);if(!StackEmpty(S)){pop(S,p);push(S,p->rchild); //向右一步}}//while}//PreOrder_Nonrecursive实验原理(算法流程图或者含注释的源代码)int ExchangeBiTree(BiTree& T)//交换一棵二叉树的左右子树{BiTree p;if(T){p=T->lchild;T->lchild=T->rchild;T->rchild=p;//p为中间变量来实现二者之间的交换ExchangeBiTree(T->lchild);//交换T的左孩子的左右子树ExchangeBiTree(T->rchild);//交换T的右孩子的左右子树}return 1;}void Show_BiTree(BiTree T,int i)//按树状打印输出二叉树的元素,i表示结点所在层次,初次调用时i=0{if(T->rchild) Show_BiTree(T->rchild,i+1);for(j=1;j<=i;j++) printf(" "); //打印i个空格以表示出层次printf("%c\n",T->data); //打印T元素,换行if(T->lchild) Show_BiTree(T->rchild,i+1);}//Print_BiTree//分析:该递归算法实际上是带层次信息的中序遍历,只不过按照题目要求,顺序为先右后左.main(){BiTree T;T=Create(T);printf("the result is:\n");Show_BiTree(T,0)Printf(“\n”):printf("the xiangxu is:\n");PreOrder_Nonrecursive(T);printf("\n");}实验结果分析及心得体会1.体会了二叉树结构的定义和操作过程2.进一步加深了自己对于二叉树结构的了解3.锻炼了自己的常用算法的设计能力成绩评定教师签名:年月日。

相关文档
最新文档