考研 期末 数据结构+实验报告+线性表及其应用(多项式相加、相乘)等教材
数据结构线性表的基本操作及应用实验报告
实验日期2010.4.19 教师签字成绩实验报告【实验名称】第二章线性表的基本操作及应用【实验目的】（1）熟练掌握线性表的基本操作的实现；（2）以线性表的各种操作（建立、插入、删除等）的实现为重点；（3）通过本次实验加深对C语言的使用（特别是函数的参数调用、指针类型的应用和链表的建立等各种基本操作）。
【实验内容】1.顺序表的基本操作（顺序表的插入、访问、删除操作）#include <stdio.h>#include <stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -1typedef int ElemType;typedef int Status;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct{ElemType *elem;int length;int listsize;}SqList;Status InitList_Sq(SqList *L){int i,n;L->elem = (ElemType * )malloc(LIST_INIT_SIZE*sizeof(ElemType));if (! L->elem) exit (OVERFLOW);printf("您希望您的顺序表有几个元素: ");scanf("%d",&n);printf("\n");printf("输入您的%d个元素，以构建顺序表: \n",n);for(i=1;i<=n;i++)scanf("%d",&L->elem[i-1]);L->length = n;L->listsize = LIST_INIT_SIZE;return OK;}//InitList_SqStatus PrintList_Sq(SqList L){int i;printf("顺序表中的元素为：");for (i=1;i<=L.length;i++)printf("%d ",L.elem[i-1]);printf("\n");return OK;}//PrintList_Sqint ListInsert_Sq(SqList* L,int i,ElemType x) //对顺序表进行插入操作{int j;if (L->length==L->listsize){printf("\t\t\t顺序表已满");return 0;}else{if (i<1||i>L->length){printf("\t\t\t位置不合法");return 0;}else{for(j=L->length-1;j>=i-1;--j)L->elem[j+1]=L->elem[j];L->elem[i-1]=x;L->length++;return 1;}}}int ListDelete_Sq(SqList* L,int i) //对顺序表进行删除操作{int j;if (i<1||i>L->length){printf("\t\t\t不存在第i个元素");return 0;}else{for (j=i-1;j<L->length;j++){L->elem[j]=L->elem[j+1];}L->length--;return 1;}}int LocateElem(SqList *L, int i) {if(i<1||i>L->length)return ERROR;else return L->elem[i-1];}int scan(){int choose;printf("选择要执行的基本操作:\n1.插入元素；2.删除元素；3.访问元素.\n");printf("输入其他值退出程序……\n");scanf("%d",&choose);return(choose);}void main(){SqList L;ElemType e;int i;int quit=0;if (InitList_Sq(&L)==OVERFLOW)printf("分配失败，退出程序！");printf("输出程序中的元素\n");PrintList_Sq(L);while(!quit)switch(scan()){case 1:printf("\n请输入你所需要插入的位置和你要插入的元素:");printf("\n请输入i和e的值:");scanf("%d%d",&i,&e);if (ListInsert_Sq(&L,i,e)==OK) PrintList_Sq(L);break;case 2:printf("\n请输入你所需要删除元素的位置:");scanf("%d",&i);if(ListDelete_Sq(&L,i)==OK) PrintList_Sq(L);break;case 3:printf("请输入所要查找元素的位置:\n");scanf("%d",&i);if(LocateElem(&L,i))printf("该位置元素的值为:%d!\n",LocateElem(&L,i));else printf("该位置的元素不存在!\n");break;default:quit=1;printf("操作结束!");printf("\n");}}2.单向链表的基本操作（单向链表的插入、删除、查找以及并表操作）#include<stdio.h>#include<malloc.h>typedef int ElemType;#define OK 1#define ERROR 0#define flag 0typedef struct LNode{ElemType data;struct LNode *next;} LNode,*LinkList;LinkList InitLinkList(){LinkList L;L=(LinkList)malloc(sizeof(LNode));L->next=NULL;return L;}LinkList LocateLinkList(LinkList L,int i){LinkList p;int j;p=L->next;j=1;while(p!=NULL&&j<i){p=p->next; j++;}if (j==i)return p;else return NULL;}void LinkListInsert(LinkList L, int i, ElemType e)//插入元素{LinkList p,s;int j;j=1;p=L;while(p&&j<i){p=p->next;j++;}if(p==NULL||j>i)printf("插入位置不正确\n");else {s=(LNode *)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;printf("%d已插入到链表中\n",e);}}void LinkListDelete(LinkList L,int i) //删除元素{LinkList p,q;int j;j=1;p=L;while(p->next&&j<i){p=p->next;j++;}if(p->next==NULL)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;free(q);printf("第%d个元素已从链表中删除\n",i);}}LinkList CreatLinkList( )//建立单向链表{LinkList L=InitLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n"); scanf("%d",&e);while (e!=flag){p=(LinkList)malloc(sizeof(LNode));p->data=e;r->next=p;r=p;scanf("%d",&e);}r->next=NULL;return L;}int LinkListLength(LinkList L){LinkList p;int j;p=L->next;j=0;while(p!=NULL){j++;p=p->next;}return j;}void LinkListPrint(LinkList L){LinkList p;p=L->next;if(p==NULL) printf("单链表为空表\n");else{printf("链表中的元素为:\n");while(p!=NULL){printf("%d ",p->data);p=p->next;}}printf("\n");}void Mergelist_L(LinkList La,LinkList Lb,LinkList Lc) {LNode *pa,*pb,*pc,*p;pa=La->next;pb=Lb->next;Lc=La;pc=Lc;while(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else {pc->next=pb;pc=pb;pb=pb->next;}}pc->next=pa?pa:pb;p=Lc->next;printf("合并结果:");while(p) {printf("%4d",p->data);p=p->next;}free(Lb);}int scan(){int d;printf("请选择你所要执行的单向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素;4.两个单向链表的合并.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){ LinkList La,Lb,Lc;int quit=0;int i,locate;ElemType e;LinkList L,p;L=CreatLinkList();while(!quit)switch(scan()){case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);LinkListInsert(L,i,e);LinkListPrint(L);break;case 2:if(LinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);LinkListDelete(L,i);}LinkListPrint(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;case 4:La=CreatLinkList();Lb=CreatLinkList();Mergelist_L( La, Lb, Lc);printf("\n");break;default:quit=1;printf("操作结束!");printf("\n");}}3.单向循环链表的基本操作（单向链表的插入、删除、查找操作）#include<stdio.h>#include<malloc.h>typedef int ElemType;#define OK 1#define ERROR 0#define flag 0typedef struct LNode{ElemType data;struct LNode *next;} LNode,*LinkList;LinkList InitLinkList(){LinkList L;L=(LinkList)malloc(sizeof(LNode));L->next=L;return L;}LinkList LocateLinkList(LinkList L,int i){LinkList p;int j;p=L->next;j=1;while(p!=L&&j<i){p=p->next; j++;}if (j==i)return p;else return NULL;}void LinkListInsert(LinkList L, int i, ElemType e)//插入元素{LinkList p,s;int j;j=1;p=L;while(p->next!=L&&j<i){p=p->next;j++;}if(p==L||j>i)printf("插入位置不正确\n");else {s=(LNode *)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;printf("%d已插入到链表中\n",e);}}void LinkListDelete(LinkList L,int i) //删除元素{LinkList p,q;int j;j=1;p=L;while(p->next!=L&&j<i){p=p->next;j++;}if(p->next==L)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;free(q);printf("第%d个元素已从链表中删除\n",i);}}LinkList CreatLinkList( )//建立单向链表{LinkList L=InitLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n"); scanf("%d",&e);while (e!=flag){p=(LinkList)malloc(sizeof(LNode));p->data=e;r->next=p;r=p;scanf("%d",&e);}r->next=L;return L;}int LinkListLength(LinkList L){LinkList p;int j;p=L->next;j=0;while(p!=L){j++;p=p->next;}return j;}void LinkListPrint(LinkList L){LinkList p;p=L->next;printf("链表中的元素为:\n");while(p!=L){printf("%d ",p->data);p=p->next;}printf("\n");}int scan(){int d;printf("请选择你所要执行的单向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){int quit=0;int i;ElemType e;LinkList L,p;L=CreatLinkList();while(!quit)switch(scan()){case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);LinkListInsert(L,i,e);LinkListPrint(L);break;case 2:if(LinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);LinkListDelete(L,i);}LinkListPrint(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;default:quit=1;printf("操作结束!");printf("\n");}}4.双向链表的基本操作（双向链表的插入、删除、查找以及并表操作）#include<stdio.h>#include<malloc.h>#define flag 0typedef int status;typedef int ElemType;typedef struct DuLNode{ElemType data;struct DuLNode *prior;struct DuLNode *next;}DuLNode,*DuLinkList;DuLinkList InitDuLinkList(){DuLinkList L;L=(DuLinkList)malloc(sizeof(DuLNode));L->next=L->prior=NULL;return L;}DuLinkList CreatDuLinkList(){DuLinkList L=InitDuLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n");scanf("%d",&e);while (e!=flag){p=(DuLinkList)malloc(sizeof(DuLNode));p->data=e;r->next=p;p->prior=r->next;r=p;scanf("%d",&e);}r->next=NULL;return L;}void ListInsert_DuL(DuLinkList L, int i, ElemType e){ DuLinkList p,s;int j;j=1;p=L;while(p&&j<i){p=p->next;j++;}if(p==NULL||j>i)printf("插入位置不正确\n");else {s=(DuLinkList)malloc(sizeof(DuLNode));s->data=e;s->next=p->next; p->next->prior=s;s->prior=p; p->next=s;printf("%d已插入到双向链表中\n",e); }}void ListDelete_DuL(DuLinkList L,int i) //删除元素{DuLinkList p,q;int j;j=1;p=L;while(p->next&&j<i){p=p->next;j++;}if(p->next==NULL)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;q->next->prior=p;free(q);printf("第%d个元素已从链表中删除\n",i); }}void LinkListPrint_DuL(DuLinkList L){DuLinkList p;p=L->next;if(p==NULL) printf("双链表为空表\n");else{printf("链表中的元素为:\n");while(p!=NULL){printf("%d ",p->data);p=p->next;}}printf("\n");}int DuLinkListLength(DuLinkList L){DuLinkList p;int j;p=L->next;j=0;while(p!=NULL){j++;p=p->next;}return j;}DuLinkList LocateDuLinkList(DuLinkList L,int i) {DuLinkList p;int j;p=L->next;j=1;while(p!=NULL&&j<i)p=p->next; j++;}if (j==i)return p;else return NULL;}void Mergelist_L(DuLinkList La,DuLinkList Lb,DuLinkList Lc){DuLNode *pa,*pb,*pc,*p;pa=La->next;pb=Lb->next;Lc=La;pc=Lc;while(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else {pc->next=pb;pc=pb;pb=pb->next;}}pc->next=pa?pa:pb;p=Lc->next;printf("合并结果:");while(p) {printf("%4d",p->data);p=p->next;}free(Lb);}int scan(){int d;printf("请选择你所要执行的双向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素;4.两个双向链表的合并.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){int quit=0;int i;ElemType e;DuLinkList L,p;DuLinkList La,Lb,Lc;L=CreatDuLinkList();while(!quit){switch(scan())case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);ListInsert_DuL(L,i,e);LinkListPrint_DuL(L);break;case 2:if(DuLinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);ListDelete_DuL(L,i);}LinkListPrint_DuL(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateDuLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;case 4:La=CreatDuLinkList();Lb=CreatDuLinkList();Mergelist_L( La, Lb, Lc);printf("\n");break;default:quit=1;printf("操作结束!");printf("\n");}}5.双向循环链表的基本操作（双向循环链表的插入、删除以及访问操作）#include<stdio.h>#include<malloc.h>#define flag 0typedef int status;typedef int ElemType;typedef struct DuLNode{ElemType data;struct DuLNode *prior;struct DuLNode *next;}DuLNode,*DuLinkList;DuLinkList InitDuLinkList(){DuLinkList L;L=(DuLinkList)malloc(sizeof(DuLNode));L->next=L; L->prior=L;return L;}DuLinkList CreatDuLinkList(){DuLinkList L=InitDuLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n"); scanf("%d",&e);while (e!=flag){p=(DuLinkList)malloc(sizeof(DuLNode));p->data=e;r->next=p;p->prior=r->next;r=p;scanf("%d",&e);}r->next=L; L->prior=r;return L;}void ListInsert_DuL(DuLinkList L, int i, ElemType e){ DuLinkList p,s;int j;j=1;p=L;while(j<i){p=p->next;j++;}if(j>i)printf("插入位置不正确\n");else {s=(DuLinkList)malloc(sizeof(DuLNode));s->data=e;s->next=p->next; p->next->prior=s;s->prior=p; p->next=s;printf("%d已插入到双向循环链表中\n",e); }}void ListDelete_DuL(DuLinkList L,int i) //删除元素{DuLinkList p,q;int j;j=1;p=L;while(p->next!=L&&j<i){p=p->next;j++;}if(p->next==L)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;q->next->prior=p;free(q);printf("第%d个元素已从双向循环链表中删除\n",i); }}void LinkListPrint_DuL(DuLinkList L){DuLinkList p;p=L->next;if(p->next==L) printf("双链表为空表\n");else{printf("链表中的元素为:\n");while(p!=L){printf("%d ",p->data);p=p->next;}}printf("\n");}int DuLinkListLength(DuLinkList L){DuLinkList p;int j;p=L->next;j=0;while(p->next!=L){j++;p=p->next;}return j;}DuLinkList LocateDuLinkList(DuLinkList L,int i){DuLinkList p;int j=1;p=L->next;while(p->next!=L&&j<i){p=p->next; j++;}if (j==i)return p;else return NULL;}int scan(){int d;printf("请选择你所要执行的双向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){ int quit=0;int i,locate;ElemType e;DuLinkList L,p;L=CreatDuLinkList();while(!quit)switch(scan()){case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);ListInsert_DuL(L,i,e);LinkListPrint_DuL(L);break;case 2:if(DuLinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);ListDelete_DuL(L,i);}LinkListPrint_DuL(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateDuLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;default:quit=1;printf("操作结束!");printf("\n");}}【小结讨论】1.通过实验，我加深了对C的工作环境及其基本操作，进一步掌握了基本函数的调用以及使用方法。
数据结构实验报告
数据结构实验报告数据结构实验报告引言：数据结构是计算机科学中的重要概念，它研究如何组织和存储数据，以便更高效地进行操作和处理。
在本次实验中，我们将探索几种常见的数据结构，并通过实际操作来加深对其原理和应用的理解。
一、线性表线性表是最简单的数据结构之一，它由一系列具有相同数据类型的元素组成，这些元素按照线性的顺序排列。
我们在实验中使用了顺序表和链表两种实现方式。
1.1 顺序表顺序表是一种基于数组的实现方式，它将元素按照顺序存储在连续的内存空间中。
我们通过实验发现，顺序表在随机访问和插入删除操作方面具有较好的性能，但当元素数量超过数组容量时，需要进行扩容操作，而且插入和删除元素时需要移动其他元素，效率较低。
1.2 链表链表是一种基于指针的实现方式，它将元素存储在不连续的内存空间中，并通过指针将这些元素连接起来。
链表在插入删除操作方面具有较好的性能，但随机访问元素时需要遍历整个链表，效率较低。
我们通过实验发现，单向链表和双向链表在不同场景下有不同的应用优势。
二、栈和队列栈和队列是两种常见的线性数据结构，它们都具有特定的操作规则。
2.1 栈栈是一种后进先出（Last In First Out，LIFO）的数据结构，类似于现实生活中的弹夹。
我们通过实验发现，栈在递归、表达式求值和括号匹配等场景下有广泛的应用。
2.2 队列队列是一种先进先出（First In First Out，FIFO）的数据结构，类似于现实生活中的排队。
我们通过实验发现，队列在模拟系统、任务调度和缓冲区管理等场景下有广泛的应用。
三、树和图树和图是两种非线性的数据结构，它们通过节点和边的连接关系来表示数据之间的关系。
3.1 树树是一种层次结构的数据结构，它由根节点和若干子树组成。
我们通过实验发现，二叉树、平衡二叉树和堆在搜索、排序和优先级队列等场景下有广泛的应用。
3.2 图图是一种由节点和边组成的数据结构，它可以表示各种复杂的关系。
我们通过实验发现，图在社交网络、路径规划和最小生成树等场景下有广泛的应用。
数据结构线性表多项式加减实验报告
数据结构实验报告实验名称：实验一——线性表日期：2013年10月28日1．实验要求实验目的1、熟悉C++语言的基本编程方法，掌握集成编译环境的调试方法2、学习指针、模板类、异常处理的使用3、掌握线性表的操作的实现方法4、学习使用线性表解决实际问题的能力实验内容利用线性表实现一个一元多项式Polynomialf(x) = a0 + a1x + a2x2 + a3x3+ … + a n x nPolynomial的结点结构如下：struct term{float coef; //系数int expn; //指数};要求：1、能够实现一元多项式的输入和输出2、能够进行一元多项式相加3、能够进行一元多项式相减4、能够计算一元多项式在x处的值5、能够计算一元多项式的导数（选作）6、能够进行一元多项式相乘（选作）7、编写测试main()函数测试线性表的正确性2. 程序分析考虑到数据结构的实现，因为多项式是线性结构因此选择线性表，而本次实验中涉及到多项式的加减，要进行节点的添加或者删除，用顺序表显然不能满足要求，而且由于不知道多项式的项数，很容易造成空间的浪费，当两个多项式指数相差很远时，操作要移动很多项，步骤很麻烦繁琐。
综上，我选择了单链表，每个节点有三个部分，分别储存系数、指数、和指针，这样在计算加减或者指数不等时，只需要简单的摘连加链即可，而且不会造成空间的太多浪费。
每次利用尾插法将结点插入基准多项式。
2.1 存储结构本次实验采取的多项式加减算法是将一个多项式作为基准，把另一个多项式加到基准多项式中去，求和后的多项式仍然存储在第一个线性表中，因此用单链表的数据结构更为方便。
单链表存储结构在本次实验中，因为形式的特殊性，每个节点如下图表示：空链表 非空链表其中每个结点前两个分别储存float 型系数coef 和int 型指数expn ，第三个作为指针指向下一个节点（不是最后一个结点时，否则为NUll ）2.2 关键算法分析1、输入多项式自然语言描述：1) 指定多项式的项数n2) 建立一个叫term 的struct 结构类型，用来储存指定多项式的系数和指数的数据。
算法与数据结构实验报告实验一 完成多项式的相加运算
实验一：完成多项式的相加运算（验证性、4学时）一、实验目的完成多项式的相加、相乘运算。
（1）掌握线性表的插入、删除、查找等基本操作设计与实现（2）学习利用线性表提供的接口去求解实际问题（3）熟悉线性表的的存储方法二、实验内容设计一个一元多项式的简单计算程序，其基本功能有：（1）输入并建立多项式；（2）输出多项式；（3）多项式的相加运算。
利用单链表实现。
三、算法描述及实验步骤1描述1、创建两个单链表A、B，分别调用CreatePolyn（）；2、输出多项式，分别调用PrintPolyn（）；3、多项式相加运算AddPolyn（）。
2算法流程图4 65inputA-B inputA-B inputA-B end3代码(注释)#include<stdio.h>#include<malloc.h>#include<math.h>typedef struct Polynomial{float coef;//系数变量int exp;//指数变量struct Polynomial *next;//定义next指针}*Polyn,Polynomial; //Polyn为结点指针类型void Insert(Polyn p,Polyn h) //插入新的结点p{if(p->coef==0) free(p); //系数为0的话释放结点else{Polyn q1,q2;q1=h;q2=h->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;}}}//Insertint f(float x)//判断输入是否为整形{float a;a=x-(long int)x;if(a==0&&x==fabs(x))return 1;elsereturn 0;}Polyn CreatePolyn(Polyn head,int m) //建立一个头指针为head、项数为m的一元多项式{int i;Polyn p;p=head=(Polyn)malloc(sizeof(struct Polynomial));head->next=NULL;for(i=0;i<m;i++){p=(Polyn)malloc(sizeof(struct Polynomial));//建立新结点以接收数据printf("please input NO.%d coef and exp:",i+1);scanf("%f %d",&p->coef,&p->exp);while(!f(p->coef)&&!f(p->exp)){printf("输入有错，请重新输入: ");scanf("%f %d",&p->coef,&p->exp);}Insert(p,head); //调用Insert函数插入结点}return head;}//CreatePolynvoid DestroyPolyn(Polyn p) //销毁多项式p{Polyn q1,q2;q1=p->next;q2=q1->next;while(q1->next){free(q1);q1=q2;//指针后移q2=q2->next;}}void PrintPolyn(Polyn P)//输出多项式{Polyn q=P->next;int flag=1; //项数计数器if(!q) //若多项式为空，输出0{putchar('0');printf("\n");return;}while (q){if(q->coef>0&&flag!=1) putchar('+'); //系数大于0且不是第一项if(q->coef!=1&&q->coef!=-1) //系数非1或-1的普通情况{printf("%g",q->coef);if(q->exp==1) putchar('X');else if(q->exp) printf("X^%d",q->exp);}else{if(q->coef==1){if(!q->exp) putchar('1');else if(q->exp==1) putchar('X');else printf("X^%d",q->exp);}if(q->coef==-1){if(!q->exp) printf("-1");else if(q->exp==1) printf("-X");else printf("-X^%d",q->exp);}}q=q->next;flag++;}//whileprintf("\n");}//PrintPolynint compare(Polyn a,Polyn 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多项式非空}//comparePolyn AddPolyn(Polyn pa,Polyn pb)//求解并建立多项式A+B，返回其头指针{Polyn qa=pa->next;Polyn qb=pb->next;Polyn headc,hc,qc;hc=(Polyn)malloc(sizeof(struct Polynomial)); //建立头结点hc->next=NULL;headc=hc;while(qa||qb){qc=(Polyn)malloc(sizeof(struct Polynomial));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;}//AddPolynPolyn SubtractPolyn(Polyn pa,Polyn pb){//求解并建立多项式A-B，返回其头指针Polyn h=pb;Polyn p=pb->next;Polyn pd;while(p){ //将pb的系数取反p->coef*=-1;p=p->next;}pd=AddPolyn(pa,h);for(p=h->next;p;p=p->next) //恢复pb的系数p->coef*=-1;return pd;}//SubtractPolynPolyn MultiplyPolyn(Polyn pa,Polyn pb){//求解并建立多项式A*B，返回其头指针Polyn hf,pf;Polyn qa=pa->next;Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点hf->next=NULL;for(;qa;qa=qa->next){for(qb=pb->next;qb;qb=qb->next){pf=(Polyn)malloc(sizeof(struct Polynomial));pf->coef=qa->coef*qb->coef;pf->exp=qa->exp+qb->exp;Insert(pf,hf);//调用Insert函数以合并指数相同的项}}return hf;}//MultiplyPolynvoid DevicePolyn(Polyn pa,Polyn pb){//求解并建立多项式A/B，返回其头指针Polyn hf,pf,af,temp1,temp2,q;Polyn qa=pa->next;Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点,存储商hf->next=NULL;pf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点，存储余数pf->next=NULL;temp1=(Polyn)malloc(sizeof(struct Polynomial));temp1->next=NULL;temp2=(Polyn)malloc(sizeof(struct Polynomial));temp2->next=NULL;temp1=AddPolyn(temp1,pa);while(qa!=NULL&&qa->exp>=qb->exp){temp2->next=(Polyn)malloc(sizeof(struct Polynomial));temp2->next->coef=(qa->coef)/(qb->coef);temp2->next->exp=(qa->exp)-(qb->exp);Insert(temp2->next,hf);pa=SubtractPolyn(pa,MultiplyPolyn(pb,temp2));qa=pa->next;temp2->next=NULL;}pf=SubtractPolyn(temp1,MultiplyPolyn(hf,pb));pb=temp1;printf("the quotient is :");PrintPolyn(hf);printf("the remainder is :");PrintPolyn(pf);}//DevicePolynint main(){int m,n,flag=0;float x;Polyn pa=0,pb=0,pc,pd,pe,pf;//定义各式的头指针，pa与pb在使用前付初值NULL printf("please input A number:");scanf("%d",&m);pa=CreatePolyn(pa,m);//建立多项式Aprintf("please input B number:");scanf("%d",&n);pb=CreatePolyn(pb,n);//建立多项式B//输出菜单printf("**********************************************\n");printf("choise：\n\t1.Output A and B\n\t2.CreatePolyn A+B\n");printf("\t3.CreatePolyn A-B\n\t4.CreatePolyn A*B\n");printf("\t5.CreatePolynA/B\n\t6.Return\n**********************************************\n");for(;;flag=0){printf("choise");scanf("%d",&flag);if(flag==1){printf("多项式A：");PrintPolyn(pa);printf("多项式B：");PrintPolyn(pb);continue;}if(flag==2){pc=AddPolyn(pa,pb);printf("多项式A+B：");PrintPolyn(pc);DestroyPolyn(pc);continue;}if(flag==3){pd=SubtractPolyn(pa,pb);printf("多项式A-B：");PrintPolyn(pd);DestroyPolyn(pd);continue;}if(flag==4){pf=MultiplyPolyn(pa,pb);printf("多项式a*b：");PrintPolyn(pf);DestroyPolyn(pf);continue;}if(flag==5){DevicePolyn(pa,pb);continue;}if(flag==6) break;if(flag<1||flag>6) printf("Error\n");continue;}//forDestroyPolyn(pa);DestroyPolyn(pb);return 0;}一、调试过程一次调试二次调试二、实验结果测试数据（1）多项式A:3x^4+11x^3+21x^2多项式B:2x^5+11x^4+12x^3+7x实验结果（1）多项式A+B=2x^5+14x^4+23x^3+21x^2+7x多项式A-B=-2x^5-8^4-x^3+21x^2-7x多项式A*B=6x^9+55x^8+199x^7+363x^6+273x^5+77x^4+147x^3多项式A/B=0实验截图（1）测试数据（2）：多项式A:2x^3+5x^-3多项式B:9x^2+6x^-2+11x^-3实验结果（2）：多项式A+B=2x^3+9x^2+6x^-2+16x^-3多项式A-B=2x^3-9x^2-6x^(-2)=16x^(-3)多项式A*B=18x^5+12x+22+45x^(-1)+30x^(-5)+55x^(-6)多项式A/B=0.222222x实验截图（2）：测试数据（3）多项式A:-x^7+3x^5多项式B:x^7-4x6%+7x^3实验结果（3）多项式A+B=-x^5+7x^3多项式A-B=-2x^7+7x^5-7x^3多项式A*B=-x^14+7x^12-19x^10+21x^8多项式A/B=-1实验截图（3）：三、总结1.在熟悉VC6.0环境的同时，对单链表的存储格式有了深刻的理解；2.复习C++语法的同时，对刚学的线性表进行综合性理解和表达，与之前所学融合。
(完整版)数据结构线性表的应用实验报告
实验报告课程名称____数据结构上机实验__________ 实验项目______线性表的应用 ____________实验仪器________PC机___________________系别_____电子信息与通信学院___专业________ ___班级/学号______ __学生姓名______ ___________实验日期_______________________成绩_______________________指导教师_______________________实验一.线性表的应用1.实验目的：掌握线性链表的存储、运算及应用。
利用链表实现一元多项式计算。
2.实验内容：1)编写函数，实现用链表结构建立多项式；2)编写函数，实现多项式的加法运算；3)编写函数，实现多项式的显示；4)测试：编写主函数，它定义并建立两个多项式，显示两个多项式，然后将它们相加并显示结果。
变换测试用的多项式，检查程序的执行结果。
选做内容：修改程序，选择实现以下功能：5)多项式求值：编写一个函数，根据给定的x值计算并返回多项式f(x)的值。
测试该函数（从终端输入一个x的值，调用该函数并显示返回结果）。
6)多项式相减：编写一个函数，求两个多项式相减的多项式。
7)多项式相乘：编写一个函数，求两个多项式的乘积多项式。
3.算法说明：1)多项式的建立、显示和相加算法见讲义。
可修改显示函数，使输出的多项式更符合表达规范。
2)多项式减法：同次项的系数相减（缺项的系数是0）。
例如a(x)=-5x2+2x+3，b(x)= -4x3+3x，则a(x)-b(x)=4x3-5x2-x+3。
提示：a(x)-b(x) = a(x)+(-b(x))。
3)多项式乘法：两个多项式的相乘是“系数相乘，指数相加”。
算法思想是用一个多项式中的各项分别与另一个多项式相乘，形成多个多项式，再将它们累加在一起。
例如，a(x)=-5x2+2x+3，b(x)=-4x3+3x，则a(x)*b(x) = (-4x3)*(-5x2+2x+3)+(3x)*(-5x2+2x+3)= (20x5-8x4-12x3) + (-15x3+6x2+9x) =20x5-8x4-27x3+6x2+9x。
数据结构《线性表的应用》实验报告
实验报告——线性表应用一、实验目的用单链表储存一元多项式，并实现两个多项式的相加运算。
二、实验内容1.先创建链表，存储多项式；2.输出多项式；3.两个多项式相加；4.输出多项式。
三、程序代码#include <stdio.h>#include <stdlib.h>#include <math.h>//一元多项式链式储存的节点结构typedef struct Polynode{float coef;int exp;struct Polynode * next;} Polynode , * Polylist;//建立一元多项式的链表Polylist polycreate(){Polynode * head,* rear,* s;float c;int e;head=(Polynode* )malloc(sizeof(Polynode));rear=head;scanf("%f,%d",&c,&e);while(c!=0){s=(Polynode * )malloc(sizeof(Polynode));s->coef=c;s->exp=e;rear->next=s;rear=s;scanf("%f,%d",&c,&e);}rear->next=NULL;return(head);}//输出多项式void print(Polynode*L){Polynode*p;p=L->next;printf("a=");if(p&&p->coef!=0)printf("%.2f*x^%d",p->coef,p->exp);while(p->next!=NULL){if((p->next->coef)>0&&p)printf("+");elseprintf("-");p=p->next;printf("%.2f*x^%d",fabs(p->coef),p->exp);}}//多项式相加void polyadd(Polylist polya,Polylist polyb){Polynode*p,*q,*tail,*temp;int sum;p=polya->next;q=polyb->next;tail=polya;while (p!=NULL&&q!=NULL){if(p->exp<q->exp){tail ->next=p; tail=p;p=p->next;}else if (p->exp==q->exp);{sum=p->coef+q->coef;if(sum!=0){p->coef=sum;tail->next=p;tail=p;p=p->next;temp=q;q=q->next;free(temp);}else{temp=p;p=p->next;free(temp);temp=q;q=q->next;free(temp);}}{tail ->next=q;tail=q;q=q->next;}}if(p!=NULL)tail->next=p;elsetail->next=q;}void main(){Polynode*a,*b;printf("输入a的系数和指数:\n");a = polycreate();print(a);printf("\n");printf("输入b的系数和指数:\n");b = polycreate();print(b);printf("\n");polyadd(a,b);printf("两个多项式的和为:\n");print(a);}四、实验结果五、实验过程中遇到的问题及处理方法程序运行时，在中文状态下输入“，”回车后就不能再输入了，应在英文状态下输入“,”。
数据结构实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中重要的基础课程，通过本次实验，旨在深入理解和掌握常见数据结构的基本概念、操作方法以及在实际问题中的应用。
具体目的包括：1、熟练掌握线性表（如顺序表、链表）的基本操作，如插入、删除、查找等。
2、理解栈和队列的特性，并能够实现其基本操作。
3、掌握树（二叉树、二叉搜索树）的遍历算法和基本操作。
4、学会使用图的数据结构，并实现图的遍历和相关算法。
二、实验环境本次实验使用的编程环境为具体编程环境名称，编程语言为具体编程语言名称。
三、实验内容及步骤（一）线性表的实现与操作1、顺序表的实现定义顺序表的数据结构，包括数组和表的长度等。
实现顺序表的初始化、插入、删除和查找操作。
2、链表的实现定义链表的节点结构，包含数据域和指针域。
实现链表的创建、插入、删除和查找操作。
（二）栈和队列的实现1、栈的实现使用数组或链表实现栈的数据结构。
实现栈的入栈、出栈和栈顶元素获取操作。
2、队列的实现采用循环队列的方式实现队列的数据结构。
完成队列的入队、出队和队头队尾元素获取操作。
（三）树的实现与遍历1、二叉树的创建以递归或迭代的方式创建二叉树。
2、二叉树的遍历实现前序遍历、中序遍历和后序遍历算法。
3、二叉搜索树的操作实现二叉搜索树的插入、删除和查找操作。
（四）图的实现与遍历1、图的表示使用邻接矩阵或邻接表来表示图的数据结构。
2、图的遍历实现深度优先遍历和广度优先遍历算法。
四、实验结果与分析（一）线性表1、顺序表插入操作在表尾进行时效率较高，在表头或中间位置插入时需要移动大量元素，时间复杂度较高。
删除操作同理，在表尾删除效率高，在表头或中间删除需要移动元素。
2、链表插入和删除操作只需修改指针，时间复杂度较低，但查找操作需要遍历链表，效率相对较低。
（二）栈和队列1、栈栈的特点是先进后出，适用于函数调用、表达式求值等场景。
入栈和出栈操作的时间复杂度均为 O(1)。
2、队列队列的特点是先进先出，常用于排队、任务调度等场景。
数据结构实验(1)线性表及其应用
计算机系数据结构实验报告（1）实验目的：帮助学生掌握线性表的基本操作在顺序和链表这两种存储结构上的实现，尤以链表的操作和应用作为重点。
问题描述：1、构造一个空的线性表L。
2、在线性表L的第i个元素之前插入新的元素e；3、在线性表L中删除第i个元素，并用e返回其值。
实验要求：1、分别利用顺序和链表存储结构实现线性表的存储，并设计出在不同的存储结构中线性表的基本操作算法。
2、在实验过程中，对相同的操作在不同的存储结构下的时间复杂度和空间复杂度进行分析。
算法分析：由于两种存储结构都用来创建线性结构的数据表，可采用相同的输出模式和整体结构类似的算法，如下：v1.0 可编辑可修改实验内容和过程：顺序存储结构线性表程序清单：//顺序存储结构线性表的插入删除#include <iostream>#include <>using namespace std;# define LISTSIZE 100# define CREMENTSIZE 10typedef char ElemType; //定义数据元素类型为字符型typedef struct {ElemType *elem; //数据元素首地址int len; //当前元素个数int listsize; //当前存储最大容量}SqList;//构造一个空的线性表Lint InitList(SqList &L){=(ElemType *)malloc(LISTSIZE*sizeof(ElemType));if (! exit(-2); //分配空间失败=0;=LISTSIZE;}//在顺序线性表L中第i个位置之前插入新的元素eint ListInsert(SqList &L,int i,ElemType e){if (i<1||i>+1) return -1; //i值不合法if >={ElemType *newelem=(ElemType *)realloc,+CREMENTSIZE)*sizeof(ElemType));//存储空间已满，增加分配if(!newelem) exit (-2); //分配失败=newelem;+=CREMENTSIZE;}ElemType *q=&[i-1]) ;for (ElemType *p=&[]);p>=q;--p) *(p+1)=*p; //插入位置及其后的元素后移 *q=e; ++;return 1;}//在顺序线性表L中删除第i个元素，并用e返回其值int ListDelete(SqList &L,int i,ElemType&e){if (i<1||i> return -1; //i值不合法ElemType *p=&[i-1]);e=*p; ElemType*q=+;for (++p;p<=q+1;++p) *(p-1)=*p; //被删除元素之后的元素前移;return 1;}int main (){SqList L; char e,ch;int i,j,state;InitList(L); //构造线性表printf("请输入原始数据(字符串个数0~99)：L="); //数据初始化gets;for ( j=1;[j-1]!='\0';j++) =j; //获取表长[j]='\0';printf("操作：插入（I）还是删除(D)\n"); //判断进行插入还是删除操作AGAIN:cin>>ch;if(ch=='I'){cout<<"插在第几个元素之前:"; //插入操作cin>>i; cout<<"输入要插入的新元素:";cin>>e;cout<<endl;printf("输入数据：L=(%s) ListInsert(L,%d,%c)",,i,e);state=ListInsert (L,i,e);}else if (ch=='D'){cout<<"删除第几个元素："; //删除操作cin>>i;cout<<endl;printf("输入数据：L=(%s) DeleteList(L,%d,e)",,i);state=ListDelete(L,i,e);}else goto AGAIN; //操作指示符输入错误处理cout<<endl<<"正确结果：";if(state==-1) cout<<"ERROR,";printf("L=(%s) ",; //输出结果if(ch=='D'&&state!=-1) cout<<",e="<<e;}链式存储结构线性表程序清单：// - - - - -单链存储结构线性表的插入删除 - - - - -#include <iostream>#include <>using namespace std;#define null 0typedef char ElemType; //定义数据元素类型为字符型typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;int GetElem(LinkList L,int i,ElemType &e) //获取第i个元素的值 {LinkList p;int j;p=L->next; j=1;while(p&&j<i){p=p->next; ++j; //寻找第i个元素}if(!p||j>i) return -1; //寻找失败e=p->data;return 1;}int ListInsert(LinkList &L,int i,ElemType e){//在带头结点的单链线性表L中第i个元素之前插入元素eLinkList p,s; int j;p=L;j=0;while(p&&j<i-1) {p=p->next;++j;}if(!p||j>i-1) return -1;s=(LinkList) malloc( sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return 1;}int ListDelete(LinkList&L,int i,ElemType&e){//在带头结点的单链线性表L中,删除第i个元素，并由e返回其值LinkList p,q; int j;p=L;j=0;while(p->next&&j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1) return -1;q=p->next;p->next=q->next;e=q->data;free(q);return 1;}int newdata(LinkList&L,char *ch){int k;printf("请输入原始数据(字符串个数0~99)：L="); //数据初始化gets(ch);for (k=0;ch[k]!='\0';k++) ListInsert(L,k+1, ch[k]); //将初始化数据插入链表L中cout<<"OK"<<endl;return k; //返回链表中的元素个数}int main (){char *ch;ch=(char *)malloc(100*sizeof(char)); //定义数组用来辅助数据初始化LinkList L; //头指针LNode head; //头结点L=&head; =null;int i,k,state; char e,CH,f;k=newdata(L,ch); //调用函数使链表数据初始化=k; //将元素个数存入头结点的数据域printf("操作：插入（I）还是删除(D)\n"); //判断进行插入还是删除操作AGAIN:cin>>CH;if(CH=='I'){cout<<"插在第几个元素之前:"; //插入操作cin>>i; cout<<"输入要插入的新元素:";cin>>e;cout<<endl;printf("输入数据：L=(%s) ListInsert(L,%d,%c)",ch,i,e);state=ListInsert(L,i,e);++;}else if (CH=='D'){cout<<"删除第几个元素："; //删除操作cin>>i;cout<<endl;printf("输入数据：L=(%s) DeleteList(L,%d,e)",ch,i);state=ListDelete(L,i,e);--;}else goto AGAIN; //操作指示符输入错误处理cout<<endl<<"正确结果：";if(state==-1) cout<<"ERROR,"; //输出结果cout<<"L=(";for(int m=1;>=m;m++) //一一输出数据{GetElem(L,m,f);cout<<f;}cout<<")";if(CH=='D'&&state!=-1) cout<<",e="<<e; //删除操作反馈e }实验结果：由于两个程序的输出模式相同，在此只列一组测试数据：L = () ListInsert (L, 1, 'k')L = (EHIKMOP) ListInsert (L, 9, 't')L = (ABCEHKNPQTU) ListInsert(L, 4, 'u') L = () ListDelete (L, 1, e)L = (DEFILMNORU) ListDelete_Sq(L, 5, e) L = (CD) ListDelete_Sq(L, 1, e)测试过程中所注意到的问题主要还是输出与输入界面的问题，通过灵活使用cout和cin函数来不断改进。
“线性表及其应用”实验报告
序号73 学号2013112000 姓名张三实验 2 实验名称线性表及其应用难度等级B+一、需求分析1、问题描述设计一个一元稀疏多项式简单计算器.2、基本要求一元稀疏多项式基本功能包括：1)输入并建立多项式⏹一元n次多项式：P n(x)=c m错误！未找到引用源。
+c m-1错误！未找到引用源。
+…+c1错误！未找到引用源。
，其中n=e m>e m-1>…>e1≥0,c i≠0(i=1,2,m)⏹输入(c m,e m)(c m-1,e m-1)…(c1,e1)构建一元n次m项多项式2)输出多项式：c m x^e m+c m-1x^e m-1+…+c1x^e13)多项式a和b相加，建立a+b4)多项式a和b相减，建立a-b3、测试数据1)(-3.1x11+5x8+2x)+(11x9-5x8+7)=(-3.1x11+11x8+2x+7)2)(-1.2x9+6x-3+4.4x2-x)-(7.8x15+4.4x2-6x-3)=(-7.8x15-1.2x9+12x-3-x)3)(x5+x4+x3+x2+x+1)-(-x4-x3)=(x5+x2+x+1)4)(x3+x)-(-x3-x)=05)(x100+x)+(x200+x100)=(x200+2x100+x)6)(x3+x2+x)+0=x3+x2+x7)互换上述测试数据中的前后多项式.二、概要设计ADT Polynomial{数据对象: D={a i|a i∈TermSet, i=1,2,…,m,m≥0,TermSet中的每个元素包含一个表示系数的实数和表示指数的整数}数据对象: R1={<a i,a i-1>|a i,a i-1∈D,且a i-1中的指数值小于ai中的指数,i=2,…,m}基本操作：createPoly(&p,m,(*input)())Result: 指数由大到小输入m项的系数和指数,建立一元多项式pdestroyPoly(&p)Condition: 一元多项式p已存在Result: 销毁一元多项式ptraversePoly(p)Result: 输出一元多项式addPoly(&pa,&pb);Condition: 一元多项式pa,pb已存在Result: 完成多项式相加运算,即pa=pa+pb,并销毁一元多项式pb.subtractPoly(&pa，&pb)Condition: 一元多项式pa,pb已存在Result: 完成多项式相减运算,即pa=pa-pb,并销毁一元多项式pb.}ADT Polynomial三、详细设计1、 数据类型定义typedef struct{float coef; int expn;}ElemType;//定义存放多项式中项的系数和指数 typedef struct LNode{ElemType data;struct LNode *next; }LNode, *LNodePtr;定义单链表的数据类型 typedef struct{LNodePtr hp; int length;}LinkList;创建单链表typedef LinkList Poly;//将链表定义为多项式类型 2、 函数原型定义Status createPoly(Poly &p, int m, Status (*input)(int, float *, int *)); Status traversePoly(Poly p, Status (*visit)(int, int, float, int)); Status destroyPoly(Poly &p);Status addPoly(Poly &pa, Poly &pb);//下面的函数可以根据需要由用户在main()函数中定义 Status input(int, float *, int *); Status visit(int, int, float, int);3、 核心算法描述⏹ createPoly()Status createPoly(Poly &p, int m, Status (*input)(int, float *, int *)){ int i,expn; float coef; LNodePtr s,hp;p.hp =(LNodePtr)malloc(sizeof(LNode)); if(!p.hp) exit(OVERFLOW); p.hp->next=NULL; p.length=0; hp=p.hp;for(i=1;i<=m;i++){(*input)(i,&coef,&expn);s=(LNodePtr)malloc(sizeof(LNode)); if(!s) exit(OVERFLOW); s->data.coef=coef; s->data.expn=expn; s->next=NULL; hp->next=s; hp=s; }p.length=m; return OK; }⏹ traversePoly()Status traversePoly(Poly p, Status (*visit)(int,int, float, int)){ int m;LNodePtr q;构建链表头结点，完成链表初始化 根据用户输入多项式的项信息构建多项式，hp 指向当前创建结点q=p.hp->next;for(m=1;m<=p.length;m++){(*visit)(p.length,m,q->data.coef,q->data.expn);q=q->next;}return OK;}⏹destroyPoly()Status destroyPoly(Poly &p){LNodePtr q;while(p.hp){q=p.hp;p.hp=q->next;free(q);}p.length=0;return OK;}⏹addPoly()Status addPoly(Poly &pa, Poly &pb){LNodePtr q,ap,bh,bp,s;float tcoef;int result;q=pa.hp; ap=q->next; bh=pb.hp; bp=bh->next;while(ap&&bp){result=ap->data.expn-bp->data.expn;if(result<0){s=bp; bp=bp->next; bh->next=bp;q->next=s; s->next=ap; q=s;pa.length++; pb.length--;}else if(result>0){q=ap; ap=ap->next;}else{tcoef=ap->data.coef+bp->data.coef;if(!tcoef){q->next=ap->next; free(ap);ap=q->next;pa.length--;}else{ap->data.coef=tcoef; q=ap;ap=ap->next;}bh->next=bp->next; free(bp);bp=bh->next; pb.length--;}//result=0}//while 根据用户定义的输出函数遍历多项式的每一项并将项和系数输出if(bp) {q->next=bp; pa.length += pb.length; bh->next=NULL; pb.length=0;}free(pb.hp);return OK;}4、函数调用关系main()首先调用createPoly()，traversePoly()，addPoly()，而createPoly()调用用户自定义input()输入多项式信息，traverPoly()调用用户自定义visit()输出多项式信息.四、运行记录测试数据预期结果实际结果分析(-3.1,11) (5,8) (2,1) -3.1x^11+5x^8+2^x -3.1x^11-3.1x^11-3.1x^11 scanf(“(%f,%d)”)(-3.1,11)(5,8)(2,1) -3.1x^11+5x^8+2^x -3.1x^11+5.0x^8+2.0x^1 剔除输入数据项括号之间的空格测试addPoly()pa:(-3.1,11)(5,8)(2,1) pb:(11,9)(-5,8)(7,0) -3.1x^11+11x^9+2x^1+7-3.1x^11+11x^9+2x^1原因算法中忽略了对pa和pb长度的处理，另外，在将剩余元素加到pa上，忘记对pb头结点的处理即pb.hp->next=NULL五、总结这次实验的难度和复杂度高于第一次实验，第一次实验是熟悉C语言环境，本次实验要求对结构体、链表和多项式项的特点要熟练掌握。
数据结构实验报告（一）线性表的应用
数据结构实验报告（⼀）线性表的应⽤实验说明数据结构实验⼀ 线性表的实验——线性表的应⽤⼀、实验⽬的通过本实验使学⽣了解线性表的⼀种简单应⽤，熟悉线性表顺序存储与链式存储的特性，特别训练学⽣编程灵活控制链表的能⼒，为今后编程控制更为复杂的数据结构奠定基础。
⼆、实验内容1.⽤顺序表和链表分别分别编程实现教材中例⼦2-1与2-2。
要求：（1）只能⽤C语⾔编程实现；（2）完全保持书中算法2.1与算法2.2形式，不允许有任何变化，除⾮语法上不允许;所调⽤各函数参照书中19页的功能描述，其中函数名、参数个数及性质、函数功能必须与书中完全⼀致，不能有变化。
2.利⽤线性表表⽰⼀元多项式完成多项式的加、减、乘、求导、求值运算。
要求：（1）输⼊的⼀元多项式可以采⽤只输⼊各项的系数与指数这种简化的⽅式。
如对于多项式2x2+6x5，输⼊可为： 2,2 6,5 这样的简单形式。
（2）遇到有消项时应当处理，如2x2+6x5与3x2-6x5进⾏相加时，结果为5*x^2。
（3）当给定x的值时，能计算表达式相加或相减的结果。
（4）操作的结果放⼊⼀个新线性表中，原来的两个表达式存储表⽰不变，也可以不是产⽣新的线性表，⽽是将两上线性表合并为⼀个。
（5）要求程序功能模块划分合理（每个函数功能单⼀、可重⽤性好），使⽤空间尽可能少，算法尽可能⾼效。
实验报告1.实现功能描述使⽤线性表表⽰⼀元多项式完成多项式的加、减，乘，求导、求值运算。
2.⽅案⽐较与选择（1）因为使⽤的是线性表，所以主要⽅案有数组法和链表法。
（2）从时间复杂度来说，使⽤数组法更优；从空间复杂度来说，链表法更优。
因为数组法是指定好空间的，若式⼦⼤⼩超出设置⼤⼩，那程序必然出错；若式⼦⼤⼩⼩于设置⼤⼩，那就意味着有多余的空间被浪费了。
综合来讲，若计算式⼦较为庞⼤，使⽤链表法更佳；相反，若计算式⼦较⼩，数组法更佳。
3.设计算法描述（1）单个项式的数据存储使⽤了结构体，数组法是在⼀个结构体中定义两个⼀维数组；链表法是通过⼀个结构体作为⼀个节点，通过next指针连接起来。
线性表及其应用实验报告
数据结构实验报告实验名称：线性表及其应用班级：12级电气本2学号：2012081227姓名：赵雪磊指导教师：梁海丽日期：2013年9月9日数学与信息技术学院一、实验目的1、掌握线性表的概念，理解线性表的顺序、链式存储。
2、掌握线性表的基本操作，插入、删除、查找，以及线性表合并等运算在顺序存储结构和链接存储结构上的运算。
二、实验要求1、建立顺序存储的线性表，并对之进行插入、删除操作。
2、建立链式存储的线性表，并对之进行插入、删除操作。
；三、算法描述#include <cstdlib>#include <iostream>#include "myList.h"using namespace std;template <class T> class Link {public:T data; // 用于保存结点元素的内容Link * next; // 指向后继结点的指针Link(const T info, Link* nextValue = NULL) { // 具有两个参数的Link构造函数data = info;next = nextValue;}Link(Link* nextValue = NULL) { // 具有一个参数的Link构造函数next = nextValue;}}// 【代码2.7】单链表的类型定义template <class T>class lnkList : public List<T> {protected:Link<T>* head, tail; // 单链表的头、尾指针public:lnkList(); // 构造函数~lnkList(); // 析构函数bool isEmpty(); // 判断链表是否为空void clear(); // 将链表存储的内容清除，成为空表int length(); // 返回此顺序表的当前实际长度bool append(T value); // 在表尾添加一个元素value，表的长度增1 bool insert(int p, T value); // 在位置p上插入一个元素value，表的长度增1 bool delete(int p); // 删除位置p上的元素，表的长度减 1int getPos(const T value); // 查找值为value的元素，并返回第1次出现的位置Link<T> setPos(int p); // 返回线性表指向第p个元素的指针值}template <class T>class lnkList:: lnkList() {head = tail = new Link<T>;}template <class T>class lnkList:: ~lnkList() {Link tmp;while (head != NULL) {tmp = head;head = head->next;delete tmp;}}template <class T> // 假定线性表的元素类型为TLink lnkList :: setPos(int i) {int count = 0;Link *p;if (i == -1) // i为-1则定位到"虚"头结点return head;p = head->next; // 若i为0则定位到第一个结点while (p != NULL && count < i) {p = p-> next;count++;};return p; // 指向第 i 结点，i＝0,1,…，当链表中结点数小于i时返回NULL }template <class T> // 假定线性表的元素类型为Tbool lnkList :: insert (int i, T value) {Link *p, *q;q = new Link<T>;p = setPos(i-1); // p是第i个结点的前驱if (p == NULL ) {cout << " the inserted point is illegal"<<endl;return false;}q->next = p->next;q->data = value;p->next = q;if (q->next == NULL ) // 插入点在链尾，插入结点成为新的链尾tail = q;return true;}// delete a node from singly linked listtemplate <class T> // 假定线性表的元素类型为Tbool lnkList :: delete(int i) {Link *p, *q;p = setPos(i-1); // p是第i个结点的前驱if (p == NULL ) {cout << " the deletion point is illegal"<<endl;return false;}q = p->next; // q是真正待删结点if (q == tail) // 待删结点为尾结点，则修改尾指针tail = p;if (q != NULL) { // 删除结点q 并修改链指针p->next = q->next;delete q;}return true;}template <class T> // 假定顺序表的元素类型为Tvoid lnkList<T> :: print() {while (head != NULL) {cout << head->data;cout << endl; // 从位置p开始每个元素左移直到curLen, tmp = head;head = head->next;}}四、程序清单#include <iostream.h>#define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #defineOVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 10 #define LISTINCREMENT 2typedef struct shunxubiao{ ElemType *list;int size;int Maxsize; }SqList;int InitList_Sq(SqList &L) {// 构造一个空的线性表L。
数据结构实验线性表及其应用
计算机系数据结构实验报告（1）实验目的：帮助学生掌握线性表的基本操作在顺序和链表这两种存储结构上的实现，尤以链表的操作和应用作为重点。
问题描述：1、构造一个空的线性表L。
2、在线性表L的第i个元素之前插入新的元素e；3、在线性表L中删除第i个元素，并用e返回其值。
实验要求：1、!2、分别利用顺序和链表存储结构实现线性表的存储，并设计出在不同的存储结构中线性表的基本操作算法。
3、在实验过程中，对相同的操作在不同的存储结构下的时间复杂度和空间复杂度进行分析。
算法分析：由于两种存储结构都用来创建线性结构的数据表，可采用相同的输出模式和整体结构类似的算法，如下：实验内容和过程：顺序存储结构线性表程序清单：//顺序存储结构线性表的插入删除#include <iostream>#include <>using namespace std;# define LISTSIZE 100# define CREMENTSIZE 10typedef char ElemType; //定义数据元素类型为字符型typedef struct {ElemType *elem; //数据元素首地址int len; //当前元素个数{int listsize; //当前存储最大容量}SqList;//构造一个空的线性表Lint InitList(SqList &L){=(ElemType *)malloc(LISTSIZE*sizeof(ElemType));if (! exit(-2); //分配空间失败=0;=LISTSIZE;\}//在顺序线性表L中第i个位置之前插入新的元素eint ListInsert(SqList &L,int i,ElemType e){if (i<1||i>+1) return -1; //i值不合法if >={ElemType *newelem=(ElemType *)realloc,+CREMENTSIZE)*sizeof(ElemType));//存储空间已满，增加分配<if(!newelem) exit (-2); //分配失败=newelem;+=CREMENTSIZE;}ElemType *q=&[i-1]) ;for (ElemType *p=&[]);p>=q;--p) *(p+1)=*p; //插入位置及其后的元素后移*q=e; ++;return 1;}//在顺序线性表L中删除第i个元素，并用e返回其值int ListDelete(SqList &L,int i,ElemType&e){if (i<1||i> return -1; //i值不合法ElemType *p=&[i-1]);e=*p; ElemType*q=+;for (++p;p<=q+1;++p) *(p-1)=*p; //被删除元素之后的元素前移;return 1;}】int main (){SqList L; char e,ch;int i,j,state;InitList(L); //构造线性表printf("请输入原始数据(字符串个数0~99)：L="); //数据初始化gets;for ( j=1;[j-1]!='\0';j++) =j; //获取表长[j]='\0';%printf("操作：插入（I）还是删除(D)\n"); //判断进行插入还是删除操作AGAIN:cin>>ch;if(ch=='I'){cout<<"插在第几个元素之前:"; //插入操作cin>>i; cout<<"输入要插入的新元素:";cin>>e;cout<<endl;printf("输入数据：L=(%s) ListInsert(L,%d,%c)",,i,e);|state=ListInsert (L,i,e);}else if (ch=='D'){cout<<"删除第几个元素："; //删除操作cin>>i;cout<<endl;printf("输入数据：L=(%s) DeleteList(L,%d,e)",,i);state=ListDelete(L,i,e);}else goto AGAIN; //操作指示符输入错误处理cout<<endl<<"正确结果：";if(state==-1) cout<<"ERROR,";printf("L=(%s) ",; //输出结果if(ch=='D'&&state!=-1) cout<<",e="<<e;}链式存储结构线性表程序清单：// - - - - -单链存储结构线性表的插入删除- - - - -#include <iostream>#include <>@using namespace std;#define null 0typedef char ElemType; //定义数据元素类型为字符型typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;"int GetElem(LinkList L,int i,ElemType &e) //获取第i个元素的值{LinkList p;int j;p=L->next; j=1;while(p&&j<i){p=p->next; ++j; //寻找第i个元素}if(!p||j>i) return -1; //寻找失败—e=p->data;return 1;}int ListInsert(LinkList &L,int i,ElemType e){//在带头结点的单链线性表L中第i个元素之前插入元素eLinkList p,s; int j;p=L;j=0;while(p&&j<i-1) {p=p->next;++j;}if(!p||j>i-1) return -1;s=(LinkList) malloc( sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return 1;}int ListDelete(LinkList&L,int i,ElemType&e){//在带头结点的单链线性表L中,删除第i个元素，并由e返回其值—LinkList p,q; int j;p=L;j=0;while(p->next&&j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1) return -1;q=p->next;p->next=q->next;e=q->data;free(q);return 1;|}int newdata(LinkList&L,char *ch){int k;printf("请输入原始数据(字符串个数0~99)：L="); //数据初始化gets(ch);for (k=0;ch[k]!='\0';k++) ListInsert(L,k+1, ch[k]); //将初始化数据插入链表L 中cout<<"OK"<<endl;【return k; //返回链表中的元素个数}int main (){char *ch;ch=(char *)malloc(100*sizeof(char)); //定义数组用来辅助数据初始化LinkList L; //头指针LNode head; //头结点L=&head; =null;—int i,k,state; char e,CH,f;k=newdata(L,ch); //调用函数使链表数据初始化=k; //将元素个数存入头结点的数据域printf("操作：插入（I）还是删除(D)\n"); //判断进行插入还是删除操作AGAIN:cin>>CH;if(CH=='I'){cout<<"插在第几个元素之前:"; //插入操作cin>>i; cout<<"输入要插入的新元素:";\cin>>e;cout<<endl;printf("输入数据：L=(%s) ListInsert(L,%d,%c)",ch,i,e);state=ListInsert(L,i,e);++;}else if (CH=='D'){cout<<"删除第几个元素："; //删除操作cin>>i;\cout<<endl;printf("输入数据：L=(%s) DeleteList(L,%d,e)",ch,i);state=ListDelete(L,i,e);--;}else goto AGAIN; //操作指示符输入错误处理cout<<endl<<"正确结果：";if(state==-1) cout<<"ERROR,"; //输出结果cout<<"L=(";for(int m=1;>=m;m++) //一一输出数据，{GetElem(L,m,f);cout<<f;}cout<<")";if(CH=='D'&&state!=-1) cout<<",e="<<e; //删除操作反馈e}实验结果：由于两个程序的输出模式相同，在此只列一组测试数据：L = () ListInsert (L, 1, 'k')!L = (EHIKMOP) ListInsert (L, 9, 't')L = (ABCEHKNPQTU) ListInsert(L, 4, 'u') L = () ListDelete (L, 1, e)L = (DEFILMNORU) ListDelete_Sq(L, 5, e)L = (CD) ListDelete_Sq(L, 1, e)）测试过程中所注意到的问题主要还是输出与输入界面的问题，通过灵活使用cout和cin函数来不断改进。
线性表的链式存储,多项式的加减乘除四则运算报告
多项式实验报告2011-4-9实验题目：一元多项式的表示及四则运算实验目的：1.了解线性表的链式存储结构，熟悉掌握链表2.了解作为链表的多项式存储方式3.熟悉掌握多项式加减乘除四则运算的算法实验内容:一、抽象数学模型：ADT Polynomial{数据对象：D={ai|ai∈TermSet,i=1,2,···，m, m>=0TermSet中的每个元素包含一个表示系数的实数和表示指数的整数} 数据关系：R1={<ai-1,ai>|ai-1,ai∈D,且ai-1中的指数值<ai中的指数值，i=2,···，n}基本操作：Insert(p,h);初始条件：多项式p与h已存在操作结果：合并指数相同的项CreatePolyn(& head, m)操作结果：建立一个头指针为head、项数为m的一元多项式DestroyPolyn(& p)初始条件：一元多项式P已存在操作结果：销毁多项式pPrintPolyn( P)初始条件：一元多项式P已存在操作结果：打印输出一元多项式PAddPolyn(&pa,& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa+Pb, 返回其头指针SubtractPolyn(& pa，& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa-Pb，返回其头指针MultiplyPolyn(& pa,& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa*Pb，返回其头指针DevicePolyn(& pa,& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa/Pb，返回其头指针}ADT Polynomial二、算法描述：为了实现上述程序功能，根据一元多项式的特点，可以构造链式存储的线性表存放一元多项式各式的信息。
线性及其应用实验报告(3篇)
第1篇一、实验目的1. 理解线性结构的基本概念和特点。
2. 掌握线性结构的应用场景和实际操作。
3. 学习线性结构在计算机科学中的重要性。
4. 提高编程能力，通过实践加深对线性结构理解。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019三、实验内容1. 线性结构的基本概念2. 线性结构的应用场景3. 线性结构的基本操作4. 线性结构在实际项目中的应用四、实验步骤1. 线性结构的基本概念（1）定义：线性结构是一种数据结构，其中的元素按照一定的顺序排列，每个元素都有一个前驱和一个后继（或前驱和后继都为空）。
（2）特点：线性结构具有以下特点：a. 有且只有一个根节点；b. 每个节点有且只有一个前驱和一个后继；c. 除根节点外，其他节点都有且只有一个前驱和一个后继。
2. 线性结构的应用场景（1）栈：用于处理先入后出（FILO）的场景，如函数调用、表达式求值等。
（2）队列：用于处理先入先出（FIFO）的场景，如打印任务、任务调度等。
（3）链表：用于处理动态数据，如动态数组、动态内存管理等。
（4）双向链表：在链表的基础上增加前驱指针，方便前后遍历。
（5）循环链表：在链表的基础上增加尾节点指向头节点，形成环状结构。
3. 线性结构的基本操作（1）插入操作：在链表的指定位置插入一个新节点。
（2）删除操作：删除链表中的指定节点。
（3）查找操作：查找链表中的指定节点。
（4）遍历操作：遍历链表中的所有节点。
4. 线性结构在实际项目中的应用（1）文件系统：文件系统中，文件内容以线性结构存储，方便读写操作。
（2）数据库：数据库中，数据以线性结构存储，如行和列。
（3）操作系统：操作系统中的进程管理、内存管理等功能都涉及到线性结构。
（4）编译器：编译器中的语法分析、语义分析等功能也涉及到线性结构。
五、实验结果与分析1. 实验结果（1）成功实现线性结构的基本操作，如插入、删除、查找、遍历等。
数据结构+实验报告+线性表及其应用(多项式相加、相乘)等
一、 实验目的和要求
1、掌握树的有关图相关操作算法; 2、熟悉树的基本存储方法; 3、学习利用树求解实际问题。
二、 实验内容和原理
1、实验内容： （1）构造哈弗曼树； （2）对单个结点编码； （3）输出树； （4） 编 码； （5）译码。 2、实验原理：通过树的有关图的相关操作算法，以及树的基本存储方法，利用
实验项目名称 线性表及其应用(多项式相加、相乘) 哈弗曼树及哈弗曼编码译码的实现 Dijkstra 最短路径 或 Prim 最小生成树 （快速、堆、归并）排序算法的设计 构造平衡二叉排序树
成绩
100 100 100 100 100
指导教师
王治和 王学院实验报告
多项式加法：定义指针 p,q 分别指向 ha,hb
1
i.p->exp==q->exp ,r->coef=p->coef+q->coef,pa,pb 下移; ii.p->exp<q->exp ,r->coef=q->coef;r->exp=q->exp;,q 下移 iii.pa->exp>pb->exp, r->exp=p->exp;r->coef=p->coef;,p 下移 iv.p!=NULL,pb==NULL.相当于 iii. V.q==NULL,pb!=NULL.相当于 ii. 其流程图如下：
三、 实验环境
Visual C++ 6.0 及 PC 机
四、 算法描述及实验步骤
思想算法： 以线性表来描述一元多项式，存储结构采用单链表，每个结点存储的多项 式中某一项的系数和指数， 建立单链表时指数高的结点列于指数低的结点之后， 即线性表的元素按指数递增有序排列。 例如构造两个多项式 ha: hb: 5X3+4X2+3X+2 X2+X+1
线性表及其应用(多项式相加、相乘)
福建农林大学计算机与信息学院（程序设计类课程）实验报告课程名称：数据结构*名：***系：计算机与信息专业：网络工程年级：09级学号：*********指导教师：***职称：副教授福建农林大学计算机与信息学院实验报告系：计算机与信息专业：网络工程年级：09级姓名：邓建国学号：091154050 实验室号：___ 计算机号：实验一线性表及其应用（多项式相加、相乘）一、实验目的和要求1、熟悉tc的运行环境，并可以熟练的使用tc；2、掌握链表存储的方法以及基本操作；3、掌握内存的动态分配和释放方法；4、熟悉C语言程序的基本格式与规范。
二、实验内容和原理1、实验内容：设计一个一元多项式的简单计算程序，其基本功能有：（1）输入并建立多项式；（2）输出多项式；（3）多项式的相加减；（4）多项式的相乘。
利用单链表实现。
2、实验原理：将两多项式存入链表lianbiao1、lianbiao2，用pointer1扫描lianbiao1，pointer2扫描lianbiao2，结果保存在lianbiao3中(用pointer3来创建lianbiao3)三、实验环境硬件：（1）学生用微机（2）多媒体实验教室（3）局域网环境软件：（1）Windows XP中文操作系统（2）Turbo C 3.0四、算法描述及实验步骤1、描述1.定义创建链表的函数，然后创建三个链表，一个用于存放结果。
2.定义多项式相加的函数实现多项式的相加功能，定义多项式的相乘功能。
3.定义打印链表和释放链表的函数。
4.最后在主函数里面调用这些函数，实现多项式的相加和相乘。
例子：A(X)=3X+7X6-9X9B(X)=2X-3+7-3X+8X3+X5（1）执行加法操作，输出“lianbiao1+lianbiao2:(2,-3) (7,0) (8,5) (1,5) (7,6) (-9,9)”（2）执行乘法操作，输出“lianbiao1*lianbiao2:(6,-2) (21,1) (-9,2) (14,3) (55,6) (3,6) (-21,7) (-63,9) (27,10) (56,11) (7,11) (-72,14) (-9,14)”2、框图3、代码(注释)#include "stdio.h" /* 输入输出函数的头文件*/#include "alloc.h" /* alloc.h是动态分配内存空间头文件*/typedef struct node /* 定义节点，包含两个数据域（c和e）和一个指针域（*next）*/ {int c,e; /*c是指多项式的系数, e是项的指数*/struct node *next; /* 定义next为指向下一个结点的指针*/}Pn; /*定义Pn类型*/Pn *create() /*创建链表*/{Pn *pointer,*lianbiao;int n;lianbiao=malloc(sizeof(Pn)); /*用malloc动态分配函数给链表分配内存空间*/printf("n:"); /*提示用户输入多项式的项数*/scanf("%d",&n); /*接收用户输入的多项式的项数*/pointer=lianbiao;while(n) /*对n进行判断，当n不为零时执行while循环语句*/{pointer->next=malloc(sizeof(Pn)); /*为链表新的节点申请空间*/pointer=pointer->next; /*将pointer下移*/printf("c e:");scanf("%d %d",&pointer->c,&pointer->e); /*将系数c,指数e存入链表中的新节点*/n--; /*没当输入一项时，项数n就减一*/ }pointer->next=NULL; /*如果pointer指向的下一个结点的指针域为空，说明链表已经创建好了*/ return lianbiao;}void OUT(Pn *lianbiao) /*打印输出链表*/{Pn *pointer=lianbiao->next;while(pointer) /*打印出当前的结点系数c和指数e, 直到链表为空*/{printf("(%d,%d) ",pointer->c,pointer->e); /*打印出多项式系数c和指数e*/pointer=pointer->next; /*打印出当前结点后,将指针移到下一个节点*/ }printf("\n"); /*用\n换行*/}void Free(Pn *lianbiao) /*释放链表空间*/{Pn *pointer=lianbiao; /*将pointer指向头节点*/while(pointer) /*释放链表中的结点,直到pointer链表为空时推出循体*/{lianbiao=lianbiao->next; /*删除当前节点*/free(pointer); /*释放当前结点的空间*/pointer=lianbiao; /* 当pointer指向头结点指针时结束循环*/}}Pn *add(Pn *lianbiao1,Pn *lianbiao2) /*多项式相加*/{Pn *lianbiao3,*pointer3,*pointer1=lianbiao1->next,*pointer2=lianbiao2->next; /*建立新的链表lianbia o3，用于存放lianbiao1与lianbiao2相加后的结果*/int c,e; /*这里的c为多项式相加后的系数,而e为结点相加后的指数*/ pointer3=lianbiao3=malloc(sizeof(Pn)); /*用malloc为lianbiao3申请空间*/lianbiao3->next=NULL;while(pointer1||pointer2) /*当pointer1或pointer2不为空时，分成3种情况*/{if(pointer1&&(pointer2==NULL||pointer1->e<pointer2->e)) /*第一种是当pointer1不空并且pointer2为空,或者pointer1所指的指数e小于pointer2所指的指数e时*/{c=pointer1->c; /*将pointer1当前所指结点的系数c赋值给c*/e=pointer1->e; /*将pointer1当前所指结点的系数e赋值给e*/pointer1=pointer1->next; /*将pointer1移到下一结点*/ }else if(pointer2&&(pointer1==NULL||pointer2->e<pointer1->e)) /*第二种是当pointer2不空且pointer1为空或者pointer2所指的指数e小于pointer1所指的指数e时*/{c=pointer2->c;e=pointer2->e;pointer2=pointer2->next;}else /*第三种是当pointer1、pointer2都不为空且pointer1的指数e等于pointer2的指数e时*/{c=pointer1->c+pointer2->c; /*将pointer1与pointer2所指的系数相加*/e=pointer1->e;pointer1=pointer1->next; /*将pointer1下移*/pointer2=pointer2->next; /*将pointer2下移*/}if(c){pointer3->next=malloc(sizeof(Pn)); /*申请新结点的空间*/pointer3=pointer3->next; /*pointer3下移*/pointer3->c=c; /*把系数c放入新结点*/pointer3->e=e; /*把指数e放入新结点*/}}pointer3->next=NULL; /*当所指的指针为NULL时，链表结束*/return lianbiao3; /* 返回两个多项式相加的结果lianbiao3 */ }Pn *mx1(Pn *pointer1,Pn *lianbiao2) /*多项式相乘*/{Pn *lianbiao3,*pointer3,*pointer2=lianbiao2->next; /*定义链表lianbiao3 */pointer3=lianbiao3=malloc(sizeof(Pn)); /*为lianbiao3申请空间, 并将pointer3指向lianbiao3*/ lianbiao3->next=NULL;while(pointer2) /* 当pointer2不为空时，执行while循环*/ {pointer3->next=malloc(sizeof(Pn)); /*为新创结点申请空间*/pointer3=pointer3->next; /*将pointer3指向新结点*/pointer3->c=pointer1->c*pointer2->c; /*将pointer1的系数乘以pointer2->c*/pointer3->e=pointer1->e+pointer2->e; /*将pointer1的指数乘以pointer2->e*/pointer2=pointer2->next; /*pointer2下移*/}pointer3->next=NULL;return lianbiao3; /*将结果lianbiao3返回*/}Pn *mxm(Pn *lianbiao1,Pn *lianbiao2) /*多项式相乘*/{Pn *lianbiao3,*pointer1=lianbiao1->next,*htemp;lianbiao3=malloc(sizeof(Pn));lianbiao3->next=NULL;while(pointer1) /*当pointer1不为空，执行while循环*/{htemp=mx1(pointer1,lianbiao2); /*将相乘结果放到链表htemp*/lianbiao3=add(lianbiao3,htemp); /*将htemp中的多项式加上lianbiao3中的多项式*/ pointer1=pointer1->next;Free(htemp); /*释放链表htemp*/}return lianbiao3; /*返回结果lianbiao3 */}main(){Pn *lianbiao1,*lianbiao2,*lianbiao3; /*定义三个链表lianbiao1,lianbiao2,lianbiao3*/ clrscr();printf("Create lianbiao1\n");lianbiao1=create(); /*创建链表lianbiao1*/printf("\nPrintf lianbiao1\n");OUT(lianbiao1); /*打印出链表lianbiao1*/printf("\nCreate lianbiao2\n");lianbiao2=create(); /*创建链表lianbiao2*/printf("\nPrintf lianbiao2\n");OUT(lianbiao2); /*打印出链表lianbiao2*/printf("\nlianbiao1+lianbiao2:");lianbiao3=add(lianbiao1,lianbiao2); /*把lianbiao1和lianbiao2相加的结果赋给lianbiao3*/ OUT(lianbiao3); /*打印出lianbiao3*/Free(lianbiao3); /*释放lianbiao3 */printf("\nlianbiao1*lianbiao2:");lianbiao3=mxm(lianbiao1,lianbiao2); /*把lianbiao1和lianbiao2相乘的结果赋给lianbiao3*/ OUT(lianbiao3); /*输出lianbiao3*/Free(lianbiao1); /*释放lianbiao1*/Free(lianbiao2);Free(lianbiao3);getch();}五、调试过程#include "malloc.h"语句出错，多了一个m，后来改为#include "alloc.h"，就编译通过了。
数据结构线性表实验报告
数据结构线性表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中线性表的基本概念、存储结构和操作算法，并通过实际编程实现来提高对线性表的应用能力和编程技能。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验内容（一）线性表的顺序存储结构顺序表是用一组地址连续的存储单元依次存储线性表的数据元素。
其特点是逻辑上相邻的元素在物理位置上也相邻，便于随机存取，但插入和删除操作需要移动大量元素，效率较低。
（二）线性表的链式存储结构链表是通过指针将一组零散的存储单元链接成一个线性序列。
常见的链表有单链表、双向链表和循环链表。
链表的插入和删除操作只需修改指针，无需移动元素，但随机存取效率较低。
（三）线性表的基本操作实现1、初始化线性表2、销毁线性表3、清空线性表4、判断线性表是否为空5、获取线性表的长度6、获取指定位置的元素7、查找指定元素在线性表中的位置8、在线性表指定位置插入元素9、删除线性表指定位置的元素四、实验步骤（一）顺序表的实现1、定义顺序表的结构体，包括数据存储数组和表的长度。
2、实现顺序表的初始化函数，分配初始存储空间并设置表长度为0。
3、销毁顺序表函数，释放存储空间。
4、清空顺序表函数，将表长度置为 0。
5、判断顺序表是否为空，根据表长度判断。
6、获取顺序表长度，直接返回表长度。
7、获取指定位置元素，检查位置合法性后返回对应元素。
8、查找指定元素位置，遍历表进行比较。
9、插入元素函数，检查插入位置合法性，若合法则移动后续元素，插入新元素并更新表长度。
10、删除元素函数，检查删除位置合法性，若合法则移动后续元素，更新表长度。
（二）链表的实现1、定义链表节点结构体，包含数据域和指针域。
2、实现链表的初始化函数，创建头节点。
3、销毁链表函数，遍历链表释放节点内存。
4、清空链表函数，遍历链表删除节点但保留头节点。
5、判断链表是否为空，检查头节点的指针域是否为空。
数据结构实验报告完成多项式的运算
简单介绍：本次作业力在学会链表表示线性表的插入、删除、查找等基本操作设计与实现，学习利用链表提供的接口去求解实际问题，同时熟悉链表的的存储方法。
再基于线性链表的基础设计完成多项式的相加运算程序。
一、实验目的和要求完成多项式的相加、相乘运算。
（1）掌握线性表的插入、删除、查找等基本操作设计与实现（2）学习利用线性表提供的接口去求解实际问题（3）熟悉线性表的的存储方法二、实验内容和原理1.实验内容设计一个一元多项式的简单计算程序，其基本功能有：（1）输入并建立多项式；（2）输出多项式；（3）多项式的相加运算。
利用单链表实现。
2.实验原理使用单链表实现一元多项式的存储，并实现两个一元多项式的加法运算。
三、实验环境硬件：（1）学生用微机（2）多媒体教室或远程教学（3）局域网环境软件：（1）Windows XP中文操作系统（2）VC6.0四、算法描述及实验步骤1、描述：加法：输入建立一元多项式,进行简单加法运算,输出结果；通过建立单链表A和B分别存放多项式的a和b的各项系数及指数；并且利用A使得不产生新的节点而在A中存放数据运算结果；该过程通过定义指针变量p和q使它们分别指向两个多项式的第一个节点，之后依次比较它们所指向的项的指数，即一种情况指数相等时系数相加且和不为零，修改当前p所指项的系数（和），同时删除q所指项，若和为零则同时删除p和q各自所指；情况二，p当前项指数大于q当前项，将q所指插入p所指之前作为结果项之一；情况三，p当前项指数小于q当前项，p所指作为多项式和的一项，移动p指向下一项，进行比较，在移动p，q至其中以个链空，把另一个链余下节点插在p所指之后；乘法：定义指针p,q指向所操作节点，通过A链表的每一项与B链表各项相乘，指数相加，系数相乘，将值赋给新节点各自域，构成一新的链表，最后返回头结点。
可这样有一个问题，即新生成的链表，即最终结果混乱，没有对数据进行过滤，相同指数项应在执行加法运算，所以可以这样实现，通过A链表的每一项与B链表各项相乘的新生成节点单独构成一链表，并将第一个链表加入另一新链表，循环此操作将后生成的链表加之先前的链表，即可实现排序问题。
数据结构多项式实验报告
数据结构实验报告--Week05姓名：覃兆坤学号：10389355一、实验目的用线性表实现多项式的相关操作，加强对线性表的理解和练习，熟练对线性表的操作。
二、实验题目一个d阶多项式有如下形式：c d x d+c d−1x d−1+c d−2x d−2…+c0其中，c d≠0，指数都是非负数。
每一个c i x i是多项式中的一项。
设计一个C++的模板类Polynomial<T>，T给出系数的类型，要求能够实现多项式的表示和运算。
Polynomial类应该包括私有变量degree，和其他需要的变量。
对多项式的表示要求用线性表的形式，例如(c0,c1,c2,…,c d)表示系数表。
并设计以下成员函数和操作：(a) Polynomial()，创建零阶多项式，即构造函数(b) Degree()，返回多项式的阶数degree(c) Input()，输入多项式，指数升序依次输入每一项的指数和系数。
例如输入: 0 c0 1 c1 2 c2…d c d。
重载>>完成输入。
(d) Output()，输出多项式，和输入的格式相同。
重载<<完成输出。
(e) Add(b)，和b多项式相加，并返回结果多项式。
重载+。
(f) Subtract(b)，和b多项式相减返回结果多项式。
重载-。
(g) Multiply(b)，和b多项式相乘返回结果多项式。
重载*。
(h) Value(x)，返回x代入多项式的值。
重载( )，例如对于多项式对象P, P(x)能够返回代入x的多项式值。
三、实验设计设计方法：本次实现采用链表的结构，实现建立多项式，对多项式进行相加相减相乘求值的操作。
一共写了2个文件Polynomial.h和test.cpp文件。
其中前者实现多项式的相关功能，后者为人机交互式测试其功能。
1：Polynomial.h：共有2个类：Node为一个节点其中index; modulus; next 分别为指数，系数和指向下一个节点的指针。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验项目列表福建农林大学计算机与信息学院实验报告系：计算机系专业：计算机科学与技术年级：2007姓名：谢飞乐学号：071152032 实验室号_ 田_513_ 计算机号25实验时间：09.3.25下午10、11 节指导教师签字：宁正元成绩：实验一线性表及其应用一、实验目的和要求1、掌握线性表的插入、删除、查找等基本操作设计与实现2、学习利用线性表提供的接口去求解实际问题3、熟悉线性表的的存储方法二、实验内容和原理1、实验内容：设计一个一元多项式的简单计算器，其基本功能有①输入并建立多项式；②输出多项式；③多项式相加。
可利用单链表或单循环链表实现之。
2、实验原理：以线性表来描述一元多项式，存储结构采用单链表，每个结点存储的多项式中某一项的系数和指数，建立单链表时指数高的结点列于指数低的结点之后，即线性表的元素按指数递增有序排列。
三、实验环境Visual C++ 6.0 及PC机四、算法描述及实验步骤思想算法：以线性表来描述一元多项式，存储结构采用单链表，每个结点存储的多项式中某一项的系数和指数，建立单链表时指数高的结点列于指数低的结点之后，即线性表的元素按指数递增有序排列。
例如构造两个多项式ha: 5X3+4X2+3X+2hb: X2+X+1多项式加法：定义指针p,q分别指向ha,hbi.p->exp==q->exp ,r->coef=p->coef+q->coef,pa,pb下移;ii.p->exp<q->exp ,r->coef=q->coef;r->exp=q->exp;,q下移iii.pa->exp>pb->exp, r->exp=p->exp;r->coef=p->coef;,p下移iv.p!=NULL,pb==NULL.相当于iii.V.q==NULL,pb!=NULL.相当于ii.其流程图如下：多项式乘法：定义指针fp,gp分别指向f,g1.将两多项式最大指数相加并赋于maxp，并置g2.用for循环求指数等于maxp时相乘的系数3. (fp!=NULL)&&(gp!=NULL), p=fp->exp+gp->exp1.p>maxp, fp=fp->next;2. p<maxp, gp=gp->next;3.p=maxp, x+=fp->coef*gp->coef; fp=fp->next;gp=gp->next;五、调试过程将主函数中的多项式相乘的函数hd=polymult(ha,hb);/*ha和hb相乘*/的polymult(ha,hb)改为polymulti(ha,hb)即可。
六、实验结果1.分别输入两个多项式: 5X3+4X2+3X+2 和X2+X+1,然后输出结果如下:2.分别输入两个多项式：6X4+4X2+2和5X+6，然后输出结果如下：七、总结此次上机实验应用了线性表实现了一次实际操作，完成了一个一元多项式的简单计算器，不仅对此次编译程序的算法思想有了新的认识，还让我深刻的体会到了线性表的重要性以及其应用的方便，并且对指针加深了映象，应用了书本中的算法思想，对我以后的编译以及完成新的程序有很大的帮助。
附录：1.建立多项式列表代码如下：mulpoly *creatpoly()/*建立多项式列表*/{mulpoly *head,*r,*s;/*设中间变量*/int m,n;head=(mulpoly *)malloc(sizeof(mulpoly));/*头结点申请空间*/printf("\ninput coef and exp:\n");scanf("%d%d",&n,&m);/*输入多项式系数和指数*/r=head;/*尾指针指向头指针*/while(n!=0)/*将输入的多项式存放在S中*/{s=(mulpoly*)malloc(sizeof(mulpoly));s->coef=n;s->exp=m;r->next=s;r=s;/*printf("input coef and exp:\n");*/scanf("%d%d",&n,&m);/*再次输入多项式系数和指数*/}r->next=NULL;/*将尾指针置空*/head=head->next;/*将head哑结点向前跑一个结点，使其不为空*/ return (head);/*返回多项式*/}2.两个多项式相加代码如下：mulpoly *polyadd(mulpoly *ha,mulpoly *hb)/*两个多项式相加*/{mulpoly *hc,*p,*q,*s,*r;/*声明结构体型*/int x;p=ha;q=hb;hc=(mulpoly *)malloc(sizeof(mulpoly));/*申请结点空间*/s=hc;while((p!=NULL)&&(q!=NULL))/*两多项式不为空*/if(p->exp==q->exp)/*指数相等*/{x=p->coef+q->coef;/*系数相加*/if(x!=0)/*系数不为零*/{r=(mulpoly*)malloc(sizeof(mulpoly));/*结果放r中存放*/r->exp=q->exp;r->coef=x;s->next=r;s=r;}p=p->next;/*多项式前进一项*/q=q->next;/*多项式前进一项*/}else if(p->exp<q->exp)/*比较指数大小*/{r=(mulpoly *)malloc(sizeof(mulpoly));r->coef=q->coef;r->exp=q->exp;s->next=r;s=r;q=q->next;}else{r=(mulpoly *)malloc(sizeof(mulpoly));r->exp=p->exp;r->coef=p->coef;s->next=r;s=r;p=p->next;}while(p!=NULL)/*当多项式p中不为空时照抄*/{r=(mulpoly *)malloc(sizeof(mulpoly));r->exp=p->exp;r->coef=p->coef;s->next=r;s=r;p=p->next;}while(q!=NULL)/*当多项式q中不为空时照抄*/{r=(mulpoly *)malloc(sizeof(mulpoly));r->exp=q->exp;r->coef=q->coef;s->next=r;s=r;q=q->next;/*将最终尾指针置空*/}s->next=NULL;r=hc;hc=hc->next;free(r);/*释放r*/return(hc);/*返回结果*/}3.两个多项式相乘代码如下：mulpoly*polymulti(mulpoly *f,mulpoly *g) /*两个多项式相乘*/{mulpoly *fp,*gp,*hp,*q,*h;int maxp,p,r,x;mulpoly *reverse(mulpoly *q);/*函数声明*/maxp=f->exp+g->exp;/*将两多项式最大指数相加并赋于maxp*/h=(mulpoly *)malloc(sizeof(mulpoly));hp=h;g=reverse(g);/*逆置g*/for(r=maxp;r>=0;r--)/*循环求指数等于r时相乘的系数*/{x=0;/*设x初始值为0*/fp=f;gp=g;while((fp!=NULL)&&(gp!=NULL))/*循环求相乘之后指数为r时的系数*/ {p=fp->exp+gp->exp;/*f的指数加上g逆置后的指数并给p*/if(p>r)/*比较p，r*/fp=fp->next;/*p大，fp到下一个结点，以确保p等于r*/elseif(p<r)gp=gp->next;/*p小，gp到下一个结点，以确保p等于r*/else/*p等于r*/{x+=fp->coef*gp->coef;/*将相乘之后指数为r时的系数给x*/ fp=fp->next;gp=gp->next;}}if(abs(x)>1e-6)/*条件限制，使得所求多项式系数绝对值不能太小*/{q=(mulpoly *)malloc(sizeof(mulpoly));q->exp=r;q->coef=x;q->next=NULL;hp->next=q;hp=q;}/*将所求结果给hp，h*/}hp=h;h=h->next;/*将h的哑结点前进，使不为空*/free(hp);/*释放hp*/return h;/*返回结果*/}4.定义链表逆置函数mulpoly *reverse(mulpoly *q)/*定义链表逆置函数*/{mulpoly *p1,*p2;if(q!=NULL)/*确保所要逆置多项式不为空*/{p1=q->next;/*使p1指向下一个结点*/q->next=NULL;/*将q->next为空*/while(p1!=NULL)/*循环使相邻两个结点逆置，直到最后一个逆置为头结点*/{p2=p1->next;p1->next=q;q=p1;p1=p2;}}return q;/*返回逆置结果*/}5.输出多项式代码如下：void polyout(mulpoly *head) /*输出多项式*/{mulpoly *q,*p;/*p=head->next;*/p=head;while(p!=NULL)/*循环输出多项式的系数和指数*/{printf("%dx%d ",p->coef,p->exp);p=p->next;}printf("\n");}福建农林大学计算机与信息学院实验报告系：计算机系专业：计算机科学与技术年级：2007姓名：谢飞乐学号：071152032 实验室号_ 田_513_ 计算机号25实验时间：09.3.25下午10、11 节指导教师签字：宁正元成绩：实验二哈弗曼树及哈弗曼编码译码的实现一、实验目的和要求1、掌握树的有关图相关操作算法;2、熟悉树的基本存储方法;3、学习利用树求解实际问题。