数据结构实验报告十六—自组织线性表问题

实验报告：线性表的基本操作实验1：实现顺序表各种基本运算的算法一、实验目的学会并运用顺序表存储结构及各种运算。

二、实验环境VC++6.0三、实验准备(1) 复习课件中理论知识(2)练习课堂所讲的例子四、实验内容编写一个程序实现SqList.cpp,实现顺序表基本运算，并在此基础上设计个主程序exp1.cpp，完成如下功能：（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;五、实验步骤1、构造一个空的线形表并分配内存空间Status InitList_Sql(SqList &L){L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem) exit(OVERFLOW);L.length=0; L.listsize=LIST_INIT_SIZE; return OK; }2、求线性表的长度Status ListLength(SqList L) {return L.length; }3、线性表清空void ClearList(SqList &L){ L.length = 0; }4、在顺序线形表 L 中第 i 个位置之前插入新的元素 eStatus ListInsert_Sq(SqList &L,int i,ElemType e)5、查找'm'在顺序表中的位序e = 'm'; i = LocateElem_Sq(L,e);printf("元素 m 在顺序表中的位序是：%d\n",i);6、在第4个位置上插入f元素printf("（在第 4 个元素位置上插入 f 元素\n");ListInsert_Sq(L,4,'f');7、删除第 3 个元素printf("（删除顺序表 L 中第 3 个元素:"); ListDelete_Sq(L, 3, e);printf("被删除的第 3 个元素值是：%c",e);8、重新申请空间ElemType*newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof( ElemType)); if(!newbase) exit(OVERFLOW);L.elem=newbase;新的存储空间基址 L.listsize+=LISTINCREMENT;9、初始化并插入元素InitList_Sql(L); printf("依次插入 a,b,c,d,e 元素\n");10、输出顺序表、释放顺序表printf("输出顺序表 L:"); ListTraverse(L); printf("（释放顺序表L\n"); DestroyList(L);六、实验总结通过该实验的学习，对课堂内容再次巩固，对顺序表也有了更深的了解。

数据结构线性表试验报告（最终定稿）第一篇：数据结构线性表试验报告线性表上机实习1、实验目的（1）熟悉将算法转换为程序代码的过程。

（2）了解顺序表的逻辑结构特性，熟练掌握顺序表存储结构的C 语言描述方法。

（3）熟练掌握顺序表的基本运算：查找、插入、删除等，掌握顺序表的随机存取特性。

（4）了解线性表的链式存储结构，熟练掌握线性表的链式存储结构的C语言描述方法。

（5）熟练掌握线性链表（单链表）的基本运算：查找、插入、删除等，能在实际应用中灵活选择适当的链表结构。

2、实验要求（1）熟悉顺序表的插入、删除和查找。

（2）熟悉单链表的插入、删除和查找。

3、实验内容: ① 顺序表（1）抽象数据类型定义typedef struct {TypeData data[maxsize];//容量为maxsize的静态顺手表int n;//顺序表中的实际元素个数}SeqList;//静态顺序表的定义在本次实验中，首先建立一个空的静态顺序表，然后键盘输入数据存入表中，然后进入菜单选择界面，通过不同的数字输入，实现对顺序表，删除，插入，查找，显示等操作。

（2）存储结构定义及算法思想在顺序表结构体的定义中，typedef int TypeData 为整型，存储结构如下：for(n=0;ncout<<“请输入线性表数据”<cin>>L.data[n];//顺序将数据存入顺序表}//其他存储与此类似，都是直接赋值与数组的某一位插入版块子函数：void insert(SeqList &L)//插入数据 {int a,b,c,k;cout<<“请输入插入的数及其插入的位置”<cin>>a>>b;if(b<=0||b>(L.n+1)){cout<<“不能在该位置插入”<k=L.data[b-1];L.data[b-1]=a;c=L.n;L.n=L.n+1;while(c>b){L.data[c]=L.data[c-1];c--;//通过循环，实现插入位置后的数据挨个往后移动一位}L.data[b]=k;} 顺序表的插入与删除操作类似，在插入与删除后，都要循环调整后面数组的每一位元素，同时记录数据元素的长度的标示符也要跟着改变。

数据结构实验报告题目：自组织线性表姓名：杨维学号：20090810229班级：物联网工程0901班完成日期：2010年12月20日一、问题描述：自组织线性表根据估算的访问频率排列记录，先放置请求频率最高的记录，接下来是请求频率次高的记录，依此类推。

自组织线性表根据实际的记录访问模式在线性表中修改记录顺序。

自组织线性表使用启发式规则决定如何重新排列线性表。

转置方法的基本原理是，在一次查找过程中，一旦找到一个记录，则将它与前一个位置的记录交换位置。

这样，随着时间的推移，经常访问的记录将移动到线性表的前端，而曾经频繁使用但以后不再访问的记录将逐渐退至线性表的后面。

尽管一般情况下自组织线性表的效率可能没有查找数和已排序的线性表那么好，但它也有自身的优势。

它可以不必对线性表进行排序，新记录的插入代价很小；同时也比查找树更容易实现，且无需额外的存储空间。

问题描述：用转置法实现一个自组织线性表，保存一组汉字用于查询。

基本要求：（1）从文件中读入一组汉字集合，用自组织线性表保存。

（2）在查询时，采用转置法调整自组织线性表的内容。

（3）从文件中依次读入需查询的汉字，把查询结果保存在文件中（如找到，返回比较的次数，如果没有找到，返回比较的次数）二．需求分析：1、本程序需要基于数组的操作来完成相应的功能。

三．概要设计算法的基本思想：1、将一组汉字读入数组（汉字占两个字符位置），所以需用二维数组。

再将另一组汉字读入数组。

2、计算每组汉字的长度。

3、进行每个汉字的查找。

返回查找的结果。

4、如果找到该汉字，则将该汉字与前一个位置的汉字倒置，继续进行查找。

程序的流程：（1）输入模块：读入两组汉字。

（2）处理模块：计算两组汉字的个数，进行查找，互换操作。

（3）输出模块：将查找结果输出。

四．详细设计：算法的具体步骤：bool flag;void Inverse(char a[][2],int i,int j){//倒置函数，查找到一次后，与前一个位置的数互换char temp=a[i][0];a[i][0]=a[j][0];a[j][0]=temp;temp=a[i][1];a[i][1]=a[j][1];a[j][1]=temp;}int search(char a[][2],int size,char c[2]){ //查找函数flag=0;int i;for( i=0;i<size;i++)if(a[i][0]==c[0] && a[i][1]==c[1]){//汉字所占的两位是否都相同flag=1;break;}if(flag){if(i>0)Inverse(a,i,i-1);return i+1;}elsereturn size; //如果找不到则查找次数为以保存汉字的个数}主函数：int main(){int i,size1,size2,num;static char a[100][2],b[100][2],c[2];cin>>a[0];//每个汉字占两个字符的位置for(i=0;;i++){if(a[i][0]==0)break;}size1=i; //计算该组汉字的长度cin>>b[0];for(i=0;;i++){if(b[i][0]==0)break;}size2=i;for(i=0;i<size2;i++){num=search(a,size1,b[i]);c[0]=b[i][0];c[1]=b[i][1];if(flag)cout<<"查找---"<<c<<"---成功！查找次数为："<<num<<endl;elsecout<<"查找---"<<c<<"---失败！查找次数为："<<num<<endl; }system("pause");return 0;}七．实验心得：1、一开始是按读入字符处理的，当输入汉字时出错。

一、实验目的1、深刻理解线性结构的特点以及线性表的概念。

2、熟练掌握线性表的顺序存储结构、链式存储结构及基本运算算法的实现，特别是查找、插入和删除等算法。

二、实验环境1) 硬件：每个学生需配备计算机一台，操作系统：Windows2000/XP。

2) 软件：visual c++6.0。

三、实验题目和实验内容实验题目：线性表的顺序、链式表示及其应用实验内容：1、基本题：实验2.1、实验2.2、实验2. 4、实验2.72、附加题：实验2.3、实验2.6(没做)四、实验数据和实验结果2.1a,b,c,d,e2.2a,b,c,d,e22.4a,b,c,d,e2.7第一个多项式:2x+6x^2-4x^3+3x^4 第二个多项式1x-3x^2+6x^3-3x^4五、附录（程序代码）2.1#include<iostream.h>#include<malloc.h>#define MaxSize 50typedef struct{char data[MaxSize];int length;}SqList;void CreateList(SqList *&L,char a[],int n) {int i;L=(SqList *)malloc(sizeof(SqList));for(i=0;i<n;i++)L->data[i]=a[i];L->length=n;}void InitList(SqList *&L){L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *&L){free(L);}int ListEmpty(SqList *L){return (L->length==0);}int ListLength(SqList *L){return (L->length);}void DispList(SqList *L){int i;for(i=0;i<L->length;i++)cout<<L->data[i];cout<<endl;}char GetElem(SqList *L,int i,char &e){if(i<1||i>L->length)return 0;e=L->data[i-1];return e;}第3 页共15 页int LocateElem(SqList *L,char e){int i=0;while(i<L->length&&L->data[i]!=e) i++;if(i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList*&L,int i,char e) {int j;if(i<1||i>L->length+1)return 0;i--;for(j=L->length;j>i;j--)L->data[j]=L->data[j-1];L->data[i]=e;L->length++;return 1;}int ListDelete(SqList *&L,int i,char &e) {int j;if(i<1||i>L->length)return 0;i--;e=L->data[i];for(j=i;j<L->length-1;j++)L->length--;return 1;}void main (){SqList *p;char b[10],e;int k;cout<<"元素个数:";cin>>k;cout<<"输入元素:";for(int m=0;m<k;m++)cin>>b[m];InitList(p);4CreateList(p,b,k);cout<<"输出顺序表:";DispList(p);cout<<"顺序表长度是:"<<ListLength(p)<<endl;if(ListEmpty(p))cout<<"顺序表为空"<<endl;elsecout<<"顺序表不为空"<<endl;cout<<"顺序表第3位元素是:"<<GetElem(p,3,e)<<endl;cout<<"元素a的位置是:第"<<LocateElem(p,'a')<<"位"<<endl;ListInsert(p,4,'f');cout<<"在第4个元素上插入元素f:";DispList(p);cout<<"删除顺序表第3个元素:";ListDelete(p,3,e);DispList(p);DestroyList(p);}2.2#include<iostream.h>#include<malloc.h>typedef struct LNode{char data;struct LNode *next;}LinkList;void CreateListR(LinkList *&L,char a[],int n){LinkList *s,*r;int i;L=(LinkList *)malloc(sizeof(LinkList));r=L;for(i=0;i<n;i++){s=(LinkList *)malloc(sizeof(LinkList));s->data=a[i];r->next=s;r=s;}r->next=NULL;}第5 页共15 页void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList));L->next=NULL;}void DestroyList(LinkList *&L){LinkList *pre=L,*p=pre->next;while(p){free(pre);pre=p;p=pre->next;}free(pre);}int ListEmpty(LinkList *L){return(L->next==NULL);}int ListLength(LinkList *L){int n=0;LinkList *p=L;while(p->next){n++;p=p->next;}return(n);}void DispList(LinkList *L){LinkList *p=L->next;while(p){cout<<p->data;p=p->next;}cout<<endl;}char GetElem(LinkList *L,int i,char &e) {int j=0;6LinkList *p=L;while(j<i&&p!=NULL){j++;p=p->next;}if(!p)return 0;else{e=p->data;return e;}}int LocateElem(LinkList *L,char e){int i=1;LinkList *p=L->next;while(p&&p->data!=e){p=p->next;i++;}if(!p)return(0);elsereturn(i);}int ListInsert(LinkList *&L,int i,char e){int j=0;LinkList *p=L,*s;while(j<i-1&&p){j++;p=p->next;}if(!p)return 0;else{s=(LinkList *)malloc(sizeof(LinkList));s->data=e;s->next=p->next;第7 页共15 页p->next=s;return 1;}}int ListDelete(LinkList *&L,int i,char &e){int j=0;LinkList *p=L,*q;while(j<i-1&&p){j++;p=p->next;}if(!p)return 0;else{q=p->next;if(!q)return 0;e=q->data;p->next=q->next;free(q);return 1;}}void main(){LinkList *h;char b[10],e;int k;cout<<"元素个数:";cin>>k;cout<<"输入元素:";for(int m=0;m<k;m++)cin>>b[m];InitList(h);CreateListR(h,b,k);cout<<"输出单链表:";DispList(h);cout<<"单链表长度是:"<<ListLength(h)<<endl;if(ListEmpty(h))cout<<"单链表为空"<<endl;else8cout<<"单链表不为空"<<endl;cout<<"单链表第3位元素是:"<<GetElem(h,3,e)<<endl;cout<<"元素a的位置是:第"<<LocateElem(h,'a')<<"位"<<endl;ListInsert(h,4,'f');cout<<"在第4个元素上插入元素f:";DispList(h);cout<<"删除单链表第3个元素:";ListDelete(h,3,e);DispList(h);DestroyList(h);}2.4#include<iostream.h>#include<malloc.h>typedef struct LNode{char data;struct LNode *next;}LinkList;void CreateListR(LinkList *&L,char a[],int n){LinkList *s,*r;int i;L=(LinkList *)malloc(sizeof(LinkList));r=L;for(i=0;i<n;i++){s=(LinkList *)malloc(sizeof(LinkList));s->data=a[i];r->next=s;r=s;}r->next=L;}void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList));L->next=NULL;}void DestroyList(LinkList *&L){第9 页共15 页LinkList *pre=L->next,*p=pre->next;L->next=NULL;while(p){free(pre);pre=p;p=pre->next;}free(pre);}int ListEmpty(LinkList *L){return(L->next==NULL);}int ListLength(LinkList *L){int n=0;LinkList *p=L;while(p->next!=L&&p->next){n++;p=p->next;}return(n);}void DispList(LinkList *L){LinkList *p=L->next;while(p!=L&&p){cout<<p->data;p=p->next;}cout<<endl;}char GetElem(LinkList *L,int i,char &e) {int j=1;LinkList *p=L->next;while(j<i&&p!=L&&p){j++;p=p->next;}10return 0;else{e=p->data;return e;}}int LocateElem(LinkList *L,char e){int i=1;LinkList *p=L->next;while(p!=L&&p->data!=e&&p){p=p->next;i++;}if(!p)return(0);elsereturn(i);}int ListInsert(LinkList *&L,int i,char e){int j=1;LinkList *p=L->next,*s;while(j<i-1&&p&&p!=L){j++;p=p->next;}if(!p)return 0;else{s=(LinkList *)malloc(sizeof(LinkList));s->data=e;s->next=p->next;p->next=s;return 1;}}int ListDelete(LinkList *&L,int i,char &e) {第11 页共15 页LinkList *p=L->next,*q;while(j<i-1&&p&&p!=L){j++;p=p->next;}if(!p)return 0;else{q=p->next;if(!q||q==L->next)return 0;e=q->data;p->next=q->next;free(q);return 1;}}void main(){LinkList *h;char b[10],e;int k;cout<<"元素个数:";cin>>k;cout<<"输入元素:";for(int m=0;m<k;m++)cin>>b[m];InitList(h);CreateListR(h,b,k);cout<<"输出循环单链表:";DispList(h);cout<<"循环单链表长度是:"<<ListLength(h)<<endl;if(ListEmpty(h))cout<<"循环单链表为空"<<endl;elsecout<<"循环单链表不为空"<<endl;cout<<"循环单链表第3位元素是:"<<GetElem(h,3,e)<<endl;cout<<"元素a的位置是:第"<<LocateElem(h,'a')<<"位"<<endl;ListInsert(h,4,'f');cout<<"在第4个元素上插入元素f:";DispList(h);12cout<<"删除循环单链表第3个元素:";ListDelete(h,3,e);DispList(h);DestroyList(h);}2.7#include<iostream.h>#include<malloc.h>typedef struct polynomial{int coef; //系数int index; //指数struct polynomial *next;}LinkList;void CreateList(LinkList *&L, int n){LinkList *s,*r;int i;L=(LinkList *)malloc(sizeof(LinkList));r=L;for(i=0;i<n;i++){s=(LinkList*)malloc(sizeof(LinkList));cout<<"依次输入多项式系数和指数：";cin>>s->coef>>s->index;s->next = NULL;r->next=s;r=s;}}void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList));L->next=NULL;}void AddList(LinkList *&list1,LinkList *&list2,int m,int n) {LinkList *s,*r,*t;int i;s=list1->next;r=list2->next;t=list1;第13 页共15 页for(i=0;i<n;i++){if(s==NULL){s=list1->next;t=list1;}while(s!=NULL){if(s->index!=r->index){s=s->next;t=t->next;}else break;}if(!s){s=(LinkList*)malloc(sizeof(LinkList));s->coef=r->coef;s->index=r->index;s->next=NULL;t->next=s;s=s->next;r=r->next;continue;}else{if(s->index==r->index)s->coef=s->coef+r->coef;if(s->coef==0){LinkList *temp1;temp1=s;s=s->next;t->next=s;delete temp1;}}r=r->next;s=NULL;}cout<<"多项式相加的结果是:";14list1=list1->next;while(list1){cout<<list1->coef<<"x^"<<list1->index;if(list1->next!=NULL)cout<<"+";list1=list1->next;}}void DispList(LinkList *L){L=L->next;while(L){cout<<L->coef<<"x^"<<L->index;if(L->next!=NULL)if(L->next->coef>0)cout<<"+";L=L->next;}}void main(){LinkList *list1,*list2;InitList(list1);InitList(list2);int m,n;cout<<"请输入第一个多项式的项数:";cin>>m;CreateList(list1,m);cout<<"多项式表示是:";DispList(list1);cout<<endl;cout<<"请输入第二个多项式的项数:";cin>>n;CreateList(list2,n);cout<<"多项式表示是:";DispList(list2);cout<<endl;AddList(list1,list2,m,n);cout<<endl;}第15 页共15 页。

数据结构线性表实验报告数据结构线性表实验报告1.简介本实验报告旨在介绍数据结构中线性表的实现和应用。

线性表是一种重要的数据结构，它的特点是数据元素之间存在一对一的前后关系，且具有唯一的起点和终点。

本实验通过实现线性表的基本操作，加深对线性表的理解，并通过实例应用展示线性表在实际问题中的应用。

2.实验环境本次实验采用的是编程语言C，并搭配使用一些常用的开发工具和库。

具体环境如下：________●操作系统：________Windows 10●编程语言：________C●开发工具：________Visual Studio Code●辅助库：________Stdio.h、stdlib.h、conio.h3.实验内容3.1 线性表的定义和基本操作3.1.1 线性表的定义线性表是由n（n ≥ 0）个数据元素组成的有限序列，数据元素之间存在一对一的前后关系。

3.1.2 线性表的基本操作●初始化线性表：________创建一个空的线性表。

●插入元素：________在指定位置插入一个新的元素。

●删除元素：________删除指定位置的元素。

●查找元素：________根据值或位置查找指定元素。

●修改元素：________根据位置修改指定元素的值。

●清空线性表：________将线性表中的所有元素清空。

3.2 线性表的顺序存储结构3.2.1 顺序存储结构的定义顺序存储结构是指使用一段连续的存储空间，依次存储线性表中的元素。

3.2.2 顺序存储结构的实现●初始化顺序表：________创建一个空的顺序表，并指定最大容量。

续元素依次后移。

●删除元素：________删除指定位置的元素，并将后续元素依次前移。

●查找元素：________根据值或位置查找指定元素，并返回其位置或值。

●修改元素：________根据位置修改指定元素的值。

●清空顺序表：________将顺序表中的所有元素清空。

●扩容：________当顺序表容量不足时，自动进行扩容。

数据结构实验报告线性表数据结构实验报告：线性表引言数据结构是计算机科学中非常重要的一个概念，它是用来组织和存储数据的一种方式。

线性表是数据结构中最基本的一种，它是由n个数据元素组成的有限序列。

在本次实验中，我们将对线性表进行深入研究，并进行实验验证。

实验目的1. 了解线性表的基本概念和特性2. 掌握线性表的顺序存储结构和链式存储结构3. 熟练掌握线性表的基本操作：插入、删除、查找等4. 通过实验验证线性表的操作和性能实验内容1. 学习线性表的基本概念和特性2. 熟悉线性表的顺序存储结构和链式存储结构3. 实现线性表的基本操作：插入、删除、查找等4. 对线性表的操作进行性能测试和分析实验步骤1. 学习线性表的基本概念和特性，包括线性表的定义、顺序存储结构和链式存储结构等2. 实现线性表的基本操作：插入、删除、查找等3. 设计实验用例，对线性表的操作进行性能测试4. 对实验结果进行分析和总结实验结果1. 实现了线性表的顺序存储结构和链式存储结构2. 实现了线性表的基本操作：插入、删除、查找等3. 对线性表的操作进行了性能测试，并得出了相应的性能数据4. 对实验结果进行了分析和总结，得出了相应的结论结论通过本次实验，我们深入了解了线性表的基本概念和特性，掌握了线性表的顺序存储结构和链式存储结构，熟练掌握了线性表的基本操作，并对线性表的性能进行了测试和分析。

这些都为我们进一步深入学习和应用数据结构打下了坚实的基础。

总结数据结构是计算机科学中非常重要的一部分，线性表作为数据结构中最基本的一种，对我们学习和应用数据结构具有重要的意义。

通过本次实验，我们对线性表有了更深入的了解，并且掌握了相关的操作和性能测试方法，这将为我们今后的学习和应用提供很大的帮助。

实验总结报告-线性表第一篇：实验总结报告-线性表实验总结报告—栈和队列学号：姓名：时间：一、目的 1.做实验的目的加深对线性表的理解，学会定义线性表的存储结构，掌握线性表的基本操作。

2.撰写实验报告的目的对本次实验情况进行总结，加强对实验内容的理解，对实验过程有一个系统的认识，从中获得本次试验的经验，并对实验结果进行适当的分析，加深对栈和队列的理解和认识。

二、内容1.说明实验次数及实验内容本次实验用一次实验课时完成实验内容：节点定义：typedef struct node{int idx;int age;struct node *next;}Node,*List;本次实验的对象的存储内容包括ID和AGE，所以定义了如上的结构体，idx用于存储ID 号，age用于存储年龄，next用于形成链式结构，Node定义了该类型的一个节点，List定义了该类型的一个链表。

（1）、编写函数CreateList()和PrintList()，从给定数组创建链表，打印链表。

int idx[8] = {1,2,3,4,5,6,7,8};int age[8] = {15,18,13,22,50,18,30,20};List CreatList(int idx[], int age[],int len){} int PrintList(List L){}（2）、编写函数DeleteNode(List L, int delete_age)，完成以下操作。

int DeleteNodeAge(List L, int delete_age){} 该函数传入List L，可以直接修改链表的节点，建议返回值为int 或void类型，无需为List类型，3，4题同上。

2.1删除年龄为18的成员，打印链表。

2.2删除年龄为20的成员，打印链表。

2.3删除年龄为15的成员，打印链表。

2.4（可选）删除年龄为21的成员（因无此成员，报错），打印链表。

实验报告课程名称____数据结构上机实验__________ 实验项目______线性表的应用 ____________实验仪器________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);}四、实验结果五、实验过程中遇到的问题及处理方法程序运行时，在中文状态下输入“，”回车后就不能再输入了，应在英文状态下输入“,”。

数据结构实验报告线性表数据结构实验报告：线性表引言：数据结构是计算机科学中的重要概念，它涉及到如何组织和存储数据，以及如何有效地操作和管理这些数据。

线性表是数据结构中最基本的一种，它是一种有序的数据元素集合，其中的元素之间存在着一对一的关系。

一、线性表的定义和特点线性表是由n个数据元素组成的有限序列，其中n为表的长度。

这些数据元素可以是相同类型的，也可以是不同类型的。

线性表中的数据元素按照一定的顺序排列，并且每个数据元素都有唯一的前驱和后继。

线性表的特点有以下几个方面：1. 数据元素之间是一对一的关系，即每个数据元素只有一个直接前驱和一个直接后继。

2. 线性表中的元素是有序的，每个元素都有一个确定的位置。

3. 线性表的长度是有限的，它的长度可以是0，也可以是任意正整数。

二、线性表的实现方式线性表可以使用不同的数据结构来实现，常见的实现方式有数组和链表。

1. 数组实现线性表：数组是一种连续存储的数据结构，它可以用来存储线性表中的元素。

数组的优点是可以快速访问任意位置的元素，但是插入和删除操作需要移动其他元素，效率较低。

2. 链表实现线性表：链表是一种非连续存储的数据结构，它通过指针将线性表中的元素链接起来。

链表的优点是插入和删除操作简单高效，但是访问任意位置的元素需要遍历链表，效率较低。

三、线性表的基本操作线性表的基本操作包括插入、删除、查找和修改等。

1. 插入操作：插入操作用于向线性表中插入一个新元素。

具体步骤是先将插入位置后面的元素依次后移，然后将新元素插入到指定位置。

2. 删除操作：删除操作用于从线性表中删除一个元素。

具体步骤是先将删除位置后面的元素依次前移，然后将最后一个元素删除。

3. 查找操作：查找操作用于在线性表中查找指定元素。

具体步骤是从线性表的第一个元素开始逐个比较，直到找到匹配的元素或者到达线性表的末尾。

4. 修改操作：修改操作用于修改线性表中的某个元素的值。

具体步骤是先查找到要修改的元素，然后将其值更新为新值。