实验二 顺序表与链表
三种存储结构(顺序表,链表,静态链表)求解josuphu问题的实验报告
实验报告：使用三种存储结构（顺序表、链表、静态链表）求解Josephus问题一、实验目的掌握顺序表、链表和静态链表的基本操作和实现方法。
学习如何使用不同的存储结构解决同一问题，并分析其性能差异。
通过求解Josephus问题，加深对数据结构在实际问题中应用的理解。
二、实验内容问题描述：Josephus问题是著名的理论问题。
在罗马人占领乔塔帕特后，n个犹太人与他们的妻子和孩子被一个圈子所包围，圈中第一个人从1开始报数，每数到m的那个人就被杀死，然后再由他的下一个人从1开始重新报数，直到剩下最后一个人为止，那个人就被称为Josephus。
本实验要求使用顺序表、链表和静态链表三种存储结构求解Josephus问题。
顺序表求解Josephus问题：使用数组作为顺序表存储结构，通过循环遍历数组实现报数和杀人过程。
当杀死某个人时，将其后的人依次向前移动填补空位。
重复此过程直到只剩下一个人为止。
链表求解Josephus问题：使用链表作为存储结构，通过链表的遍历实现报数和杀人过程。
当杀死某个人时，将其从链表中删除。
重复此过程直到链表中只剩下一个节点为止。
静态链表求解Josephus问题：使用静态链表作为存储结构，通过数组模拟链表操作。
在静态链表中，每个节点包含数据域和游标域。
通过游标域实现节点间的链接关系。
通过遍历静态链表实现报数和杀人过程，当杀死某个人时，修改其前后节点的链接关系以删除该节点。
重复此过程直到静态链表中只剩下一个节点为止。
三、实验结果与分析实验结果：使用顺序表求解Josephus问题时，时间复杂度较高，因为每次杀人后都需要移动大量元素来填补空位。
空间复杂度较低，只需一个大小为n的数组。
使用链表求解Josephus问题时，时间复杂度较低，因为删除节点时只需修改相邻节点的指针。
空间复杂度与顺序表相当，但需要额外的指针空间来存储节点间的链接关系。
使用静态链表求解Josephus问题时，时间复杂度和空间复杂度与链表相似。
最新实验1-2顺序表和链表基本操作-参考答案
实验1、2：线性表的应用参考代码一、实验预备知识1．复习C中编写函数的相关内容。
2．复习如何用主函数将多个函数连在一起构成一个C完整程序。
二、实验目的1．掌握线性表的顺序和链式存储结构2．熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算3．熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算三、实验要求1．编写初始化并创建线性表和输出线性表的算法。
2．编写对线性表插入和删除运算算法，要判断位置的合法性和溢出问题。
3．编写有序表的插入和删除运算算法。
4．编写一个主函数，将上面函数连在一起，构成一个完整的程序。
5．将实验源程序调试并运行，写出输入、输出结果，并对结果进行分析。
四、实验内容顺序表实验内容：1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。
2．初始化并建立顺序表。
（开辟的存储空间大小为8）3．编写顺序表输出算法。
4．依次插入3、21、15、99四个数，分别插入在第1、8、4和12位置，每插入一次都要输出一次顺序表。
5．删除第1，第9和第12个位置上的元素，每删除一个元素都要输出一次顺序表。
6．编写一个排序算法，对线性表中元素从小到大排列。
7．向有序表分别插入20和50，插入后表仍然有序。
（修改开辟的存储空间大小为15）单链表实验内容：1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。
2．建立一个带表头结点的单链表（前插入法和尾插入法均可）。
3．编写单链表输出算法。
4．依次插入3、21、15、99四个数，分别插入在第1、8、4和12位置，每插入一次都要输出一次单链表。
5．删除第1，第9和第12个位置上的元素，每删除一个元素都要输出一次单链表。
6．编写一个排序算法，对链表中元素从小到大排列。
7．向有序链表分别插入20和50，插入后表仍然有序。
五、实验结果顺序表源程序：#include <iostream>using namespace std;const int MAXSIZE=8; //做有序表插入操作时，将8改为15typedef int DataType;typedef struct{DataType data[MAXSIZE];int length;}SeqList;void Init_SeqList(SeqList &L);//创建空顺序表算法void Show_SeqList(SeqList L);//顺序表输出算法void Create_SeqList(SeqList &L);//顺序表创建算法int Insert_SeqList(SeqList &L,DataType x,int i);//顺序表的插入算法int Delete_SeqList(SeqList &L,int i);//顺序表的删除算法int Locate_SeqList(SeqList L,DataType x);//顺序表的按值查找算法void Sort_SeqList(SeqList &L);//顺序表的排序算法int Insert_SeqList_sort(SeqList &L,DataType x);//有序表的插入算法void Merge(SeqList LA,SeqList LB,SeqList &LC);//两个有序顺序表的合并算法void menu(); //菜单算法void main(){ menu(); }void menu()//菜单算法{SeqList L;Init_SeqList(L);int m;while(1){cout<<"\n根据所做操作选择以下数字序号："<<endl;cout<<"1:创建顺序表2:执行插入操作3:执行删除操作"<<endl;cout<<"4:执行输出操作5:执行查找操作6:执行排序操作"<<endl;cout<<"7:执行有序表的插入操作8:执行有序表的合并操作0:退出"<<endl;int n,i,x;cin>>n;switch (n){case 1:{Create_SeqList(L);break;}case 2:{cout<<"请输入插入位置：";cin>>i;cout<<endl<<"请输入插入元素值：";cin>>x;cout<<endl;m=Insert_SeqList(L,x,i);if (m==1)cout<<"插入操作成功！"<<endl;elseif (m==0)cout<<"插入位置不合法！"<<endl;elsecout<<"发生溢出！"<<endl;break;}case 3:{cout<<"请输入删除位置：";cin>>i;cout<<endl;m=Delete_SeqList(L,i);if (m==1)cout<<"删除操作成功！"<<endl;elseif (m==0)cout<<"删除位置不合法！"<<endl;elsecout<<"空表！"<<endl;break;}case 4:{Show_SeqList(L);break;}case 5:{cout<<"请输入所要查找的元素值：";cin>>x;cout<<endl;m=Locate_SeqList(L,x);if (m==0)cout<<"所查找元素不在顺序表中！"<<endl;elsecout<<"所查找元素是顺序表的第"<<m<<"个元素！"<<endl;break;}case 6:{Sort_SeqList(L);cout<<"排序操作完成！"<<endl;break;}case 7:{cout<<endl<<"请输入插入元素值：";cin>>x;cout<<endl;m=Insert_SeqList_sort(L,x);if (m==1)cout<<"插入操作成功！"<<endl;elsecout<<"发生溢出！"<<endl;break;}case 8:{SeqList L1,L2,L3;Init_SeqList(L1);Init_SeqList(L2);Init_SeqList(L3);cout<<"创建有序表1："<<endl;Create_SeqList(L1);Sort_SeqList(L1);cout<<"创建有序表2："<<endl;Create_SeqList(L2);Sort_SeqList(L2);cout<<"有序表1："<<endl;Show_SeqList(L1);cout<<"有序表2："<<endl;Show_SeqList(L2);Merge(L1,L2,L3);cout<<"合并后："<<endl;Show_SeqList(L3);break;}case 0:return;}}void Init_SeqList(SeqList &L)//创建空顺序表算法{L.length=0;}void Show_SeqList(SeqList L)//顺序表输出算法{if(L.length==0)cout<<"空表！"<<endl;elsefor(int i=0;i<L.length;i++)cout<<L.data[i]<<" ";cout<<endl;}void Create_SeqList(SeqList &L)//顺序表创建算法{cout<<"请输入元素个数:";cin>>L.length;cout<<"依次输入各个元素的值:"<<endl;for(int i=0;i<L.length;i++)cin>>L.data[i];}int Insert_SeqList(SeqList &L,DataType x,int i)//顺序表的插入算法{if(MAXSIZE<=L.length)return -1;if(i<1||i>L.length+1)return 0;for(int j=L.length-1;j>=i-1;j--)L.data[j+1]=L.data[j];L.data[i-1]=x;L.length++;return 1;}int Delete_SeqList(SeqList &L,int i)//顺序表的删除算法{if(L.length ==0)return -1;if(i<1||i>L.length)return 0;for(int j=i;j<L.length;j++)L.data[j-1]=L.data[j];L.length--;return 1;int Locate_SeqList(SeqList L,DataType x)//顺序表的按值查找算法{int i=0;while(i<L.length&&L.data[i]!=x)i++;if(i<L.length )return i+1;elsereturn 0;}void Sort_SeqList(SeqList &L) //排序算法{int i,k,j;DataType temp;for(i=0;i<L.length-1;i++){k=i;for(j=i+1;j<=L.length -1;j++)if(L.data [j]<L.data [k])k=j;if(i!=k){temp=L.data [i];L.data [i]=L.data [k];L.data [k]=temp;}}}int Insert_SeqList_sort(SeqList &L,DataType x)//有序表的插入算法{if(MAXSIZE<=L.length)return -1;int i=0;while(i<L.length&&L.data[i]<x)i++;for(int j=L.length-1;j>=i;j--)L.data[j+1]=L.data[j];L.data[i]=x;L.length++;return 1;}void Merge(SeqList LA,SeqList LB,SeqList &LC)//两个有序顺序表的合并算法{int i,j,k;i=j=k=0;while(i<LA.length&&j<LB.length){if(LA.data[i]<LB.data[j]){LC.data[k]=LA.data[i];i++;k++;}else{LC.data[k]=LB.data[j];j++;k++;}}while(i<LA.length){LC.data[k]=LA.data[i];i++;k++;}while(j<LB.length){LC.data[k]=LB.data[j];j++;k++;}LC.length=k;}输入输出结果：图1-1主菜单图1-2顺序表的创建和输出操作图1-3 顺序表的插入操作图1-4顺序表的删除操作图1-5顺序表的排序操作图1-6有序表的插入操作图1-7两个有序表的合并操作单链表的源程序：#include "iostream"using namespace std;typedef int DataType;typedef struct node{DataType data;struct node *next;}LNode,*LinkList;void Init_LinkList(LinkList &L);//创建空单链表void Create1LinkList(LinkList &L,int n);//前插入法创建单链表的算法void Create2LinkList(LinkList &L,int n);//后插入法创建单链表的算法void PrintLinkList(LinkList L);//单链表的输出算法int InsertLinkList(LinkList &L,int i,DataType x);//单链表的插入算法int DeleteLinkList(LinkList &L,int i);//单链表的删除算法void Select_Sort_LinkList(LinkList &L);//链表的排序算法（选择排序）void Insert2(LinkList L,DataType x);//有序表的插入void Merge(LinkList L1,LinkList L2,LinkList &L3);//两个有序表的合并算法void menu();//菜单函数int main(){menu();return 0;}void Init_LinkList(LinkList &L)//创建空单链表{L=new LNode;L->next=NULL;}void Create1LinkList(LinkList &L,int n)//前插入法创建单链表的算法{LNode *s;for(int i=1;i<=n;i++){s=new LNode;cout<<"请输入第"<<i<<"个元素的值：";cin>>s->data;s->next=L->next;L->next=s;}}void Create2LinkList(LinkList &L,int n)//后插入法创建单链表的算法{LNode *s,*r=L;for(int i=1;i<=n;i++){s=new LNode;cout<<"请输入第"<<i<<"个元素的值：";cin>>s->data;r->next=s;r=s;}r->next=NULL;}void PrintLinkList(LinkList L)//单链表的输出算法{if(L->next==NULL){cout<<"空表！"<<endl;return;}cout<<"当前单链表为："<<endl;LNode *p=L->next;while(p){cout<<p->data<<" ";p=p->next;}cout<<endl;}int InsertLinkList(LinkList &L,int i,DataType x)//单链表的插入算法{int j=0;LNode *p=L,*s;while(p&&j<i-1){p=p->next;j++;}if(!p||j>i-1)return 0;s=new LNode;s->data=x;s->next =p->next ;p->next =s;return 1;}int DeleteLinkList(LinkList &L,int i)//单链表的删除算法{if(L->next ==NULL)return -1;int j=0;LNode *p=L,*q;while((p->next !=NULL)&&(j<i-1)){p=p->next ;j++;}if((p->next==NULL)||(j>i-1))return 0;q=p->next ;p->next =q->next ;delete q;return 1;}void Select_Sort_LinkList(LinkList &L)//链表的排序算法（选择排序）{if(L->next ==NULL){cout<<"空表，不需要排序！"<<endl;return;}LNode *p,*q,*s;DataType temp;if(L->next==NULL) return;for(p=L->next;p->next!=NULL;p=p->next){s=p;for(q=p->next;q!=NULL;q=q->next){if(q->data<s->data)s=q;}if(s!=p){temp=s->data; s->data=p->data; p->data=temp;}}cout<<"排序成功！"<<endl;}void Insert2(LinkList L,DataType x)//有序表的插入{LNode *p=L,*s;while(p->next!=NULL&&p->next->data<x)p=p->next;s=new LNode;s->data=x;s->next=p->next;p->next=s;cout<<"插入操作成功！"<<endl;}void Merge(LinkList L1,LinkList L2,LinkList &L3)//两个有序表的合并算法{LNode *p1,*p2,*p3,*s;p1=L1->next ;p2=L2->next ;L3=p3=new LNode;L3->next =NULL;while(p1&&p2){s=new LNode;if(p1->data <p2->data ){s->data =p1->data ;p1=p1->next ;}else{s->data =p2->data ;p2=p2->next ;}p3->next =s;p3=s;}if(p1)p3->next =p1;if(p2)p3->next =p2;}void menu()//菜单函数{LinkList L;Init_LinkList(L);int m;while(1){cout<<"\n根据所做操作选择以下数字序号："<<endl;cout<<"1:前插入创建单链表2:尾插入创建单链表3:执行插入操作"<<endl;cout<<"4:执行删除操作5:执行输出操作6:执行排序操作"<<endl;cout<<"7:执行有序表的插入操作8:执行有序表的合并操作0:退出"<<endl;int n,i,x;cin>>n;switch (n){case 1:{cout<<"请输入结点个数：";cin>>i;Create1LinkList(L,i);PrintLinkList(L);break;}case 2:{cout<<"请输入结点个数：";cin>>i;Create2LinkList(L,i);PrintLinkList(L);break;}case 3:{cout<<"请输入插入位置：";cin>>i;cout<<endl<<"请输入插入元素值：";cin>>x;cout<<endl;if (InsertLinkList(L,i,x)==1)cout<<"插入操作成功！"<<endl;elsecout<<"插入位置不合法！"<<endl;break;}case 4:{cout<<"请输入删除位置：";cin>>i;cout<<endl;m=DeleteLinkList(L,i);if (m==1)cout<<"删除操作成功！"<<endl;elseif(m==-1)cout<<"空表！"<<endl;elsecout<<"删除位置不合法！"<<endl;break;}case 5:{PrintLinkList(L);break;}case 6:{Select_Sort_LinkList(L);break;}case 7:{cout<<endl<<"请输入插入元素值：";cin>>x;cout<<endl;Insert2(L,x);break;}case 8:{LinkList L1,L2,L3;Init_LinkList(L1);Init_LinkList(L2);Init_LinkList(L3);cout<<"创建有序表1："<<endl;cout<<"请输入结点个数：";cin>>i;Create2LinkList(L1,i);Select_Sort_LinkList(L1);cout<<"创建有序表2："<<endl;cout<<"请输入结点个数：";cin>>i;Create2LinkList(L2,i);Select_Sort_LinkList(L2);cout<<"有序表1："<<endl;PrintLinkList(L1);cout<<"有序表2："<<endl;PrintLinkList(L2);Merge(L1,L2,L3);cout<<"合并后："<<endl;PrintLinkList(L3);break;}case 0:return;}}}输入输出结果：图2-1主菜单图2-2创建单链表（用头插入法）图2-3创建单链表（用尾插入法）图2-4单链表的插入操作图2-5单链表的插入操作（插入位置不合法情况）图2-6单链表的删除操作图2-7单链表的删除操作（删除位置不合法情况）图2-8单链表的排序操作图2-9有序表的插入操作图2-10两个有序表的合并操作建议：代码较长，为了方便阅读和调试，可写成多文件结构！。
数据结构实验报告顺序表和链表
实验报告课程名称数据结构实验项目实验一线性表的生成与操作题目一顺序表和链表的创建与基本操作系别___ _计算机学院 _ ______专业__ __计算机大类_ __班级/学号__(1406/2014011288)_____学生姓名 _______(孙文学)_________实验日期_（2015年10月19日）成绩_______________________指导教师黄改娟实验题目：实验一线性表的生成与操作------顺序表和链表的创建与基本操作（自己所选择实验题目，必填）一、实验目的1)掌握线性表的顺序存储和链式存储结构；2)验证顺序表及链表的基本操作的实现；(验证)3)理解算法与程序的关系，能够将算法转换为对应程序；4)体会线性表在实际应用中能够解决的问题。
（设计、综合）二、实验内容1)根据实验一题目列表，选定题目，说明题目的主要需求；2)结合所选定的题目，定义存储结构，并完成对应应用的线性表创建、插入、删除、查找等基本操作的算法描述；3)程序编码实现，并获得运行结果。
三、报告内容1)实验题目及主要存储结构定义（提示：请根据所选定题目，描述存储结构）题目：顺序表和链表的创建及基本操作顺序表我是采用数组存储的，链表是采用结构体存储的2)结合题目，说明对相应线性表的基本操作算法描述（提示：可用自然语言、流程图、伪代码等均可，要求对每一个操作，都给出具体的算法描述）基本操作：#顺序表#（1）插入：在线性表中的x位置插入y----将x位置及之后的元素都往后挪一位，将y的值赋给a[x].（2）删除：删除位置为x的元素----另y=a[x],然后x之后的元素都往前挪一位。
（3）查找：寻找值为y的元素----从a[0]开始，若a[i]==y，则返回i，否则i++。
#链表#（1）插入：当i小于要插入的位置x时，i++，插入p->data------p->next=s->next;s->next=p;（2）删除：当p->data不等于要删除的值x时，p=p->next；q=p->next;p->next=q->next;free(q);（3）查找：当p->data!=x时，p=p->next，找到之后返回p->data3)程序源码（提示：列出所编写程序的代码。
顺序表和链表详解及实现
顺序表和链表详解及实现⾸先了解顺序表和链表的概念1.顺序表（类似STL库中的vector）顺序表是在计算机内存中以数组形式保存的线性表，是指⽤⼀组地址连续的存储单元依次存储数据元素的线性结构。
线性表采⽤顺序存储的⽅式称为顺序表。
优点：（1）空间利⽤率⾼（连续存放）（2）存取速度⾼效，通过下标直接存储和读取。
缺点：（1）插⼊和删除⽐较慢。
（插⼊或删除⼀个元素时需要遍历移动元素来重新排⼀次顺序）（2）不可以增长长度，有空间限制，当需要存储的元素个数可能多于顺序表元素时，可能出现“溢出”问题。
当元素个数远远⼩于预先分配的空间是，会造成空间浪费。
2.链表（类似STL库中的list）链表是⼀种物理存储单元上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
链表由⼀系列的节点组成，节点可以在运⾏时动态⽣成。
每个节点由两部分组成：数据域（存储数据元素）和指针域（存放下⼀个节点的地址）。
链表的种类：单链表、双向链表、循环链表优点：（1）插⼊和删除的速度快，保留原有的物理顺序（插⼊或删除时，只需要改变指针指向即可）。
（2）没有空间限制，存储元素的个数⽆上限，基本只与内存空间⼤⼩有关。
缺点：（1）存取元素⽐较慢（不能进⾏索引访问，只能从头结点开始顺序查找）（2）占⽤额外的空间⽤来存储指针（不连续存放，空间碎⽚多）总结：频繁查找却很少插⼊和删除操作可以⽤顺序表存储，堆排序，⼆分查找适宜⽤顺序表。
频繁插⼊和删除却很少查找可以使⽤链表存储。
若线性表长度变化不⼤，事先知道线性表的⼤致长度，且主要操作时查找，则采⽤顺序表。
若线性表长度变化较⼤或根本不知道多⼤时，且主要操作是插⼊、删除，则采⽤链表。
顺序表：顺序存储，随机读取。
链表：随机存储，顺序读取。
链表基本操作实验报告
while(p&&j<i) {p=p->next;j++;} if(p==NULL||j>i)
printf("插入位置不正确\n"); else{s=(LNode *)malloc(sizeof(LNode));
{printf("%d ",p->data); p=p->next;} } printf("\n"); }
int LinkedListLength (LinkedList L) {LinkedList p;
int j; p=L->next; j=0; while(p!=NULL)
{j++;p=p->next;} return j; }
8.向链表中插入元素
插入元素之后的链表 9.从链表中删除元素
删除位置为 6 的元素(是 3)
10.清空单链表
五、 实验体会
经过这次单链表基本操作实验，自己的编程能力有了进一步的提高，认识到自 己以前在思考一个问题上思路不够开阔，不能灵活的表达出自己的想法，虽然在 打完源代码之后出现了一些错误，但是经过认真查找、修改，最终将错误一一修 正，主要是在写算法分析的时候出现了障碍，经过从网上查找资料，自己也对程 序做了仔细的分析，对单链表创建、插入、删除算法画了详细的 N-S 流程图。
r=L; r 指向头结点
使用 malloc 函数动态分配存储空间，指针 p 指向新开辟的结点，并将元素存
放到新开辟结点的数据域，
顺序表与链表的比较全套资料
顺序表与链表的比较全套资料(全套资料，可以直接使用，可编辑优秀版资料，欢迎下载）顺序表与链表的比较一、顺序表的特点是逻辑上相邻的数据元素,物理存储位置也相邻,并且，顺序表的存储空间需要预先分配.它的优点是：（1）方法简单，各种高级语言中都有数组，容易实现.（2）不用为表示节点间的逻辑关系而增加额外的存储开销。
(3）顺序表具有按元素序号随机访问的特点。
缺点：（1）在顺序表中做插入、删除操作时，平均移动表中的一半元素，因此对n较大的顺序表效率低。
（2）需要预先分配足够大的存储空间，估计过大，可能会导致顺序表后部大量闲置；预先分配过小，又会造成溢出。
二、在链表中逻辑上相邻的数据元素，物理存储位置不一定相邻，它使用指针实现元素之间的逻辑关系。
并且，链表的存储空间是动态分配的。
链表的最大特点是：插入、删除运算方便。
缺点：（1）要占用额外的存储空间存储元素之间的关系，存储密度降低.存储密度是指一个节点中数据元素所占的存储单元和整个节点所占的存储单元之比。
（2)链表不是一种随机存储结构,不能随机存取元素。
三、顺序表与链表的优缺点切好相反，那么在实践应用中怎样选取存储结构呢?通常有以下几点考虑：（1）顺序表的存储空间是静态分配的，在程序执行之前必须明确规定它的存储规模,也就是说事先对“MaxSize"要有合适的设定，设定过大会造成存储空间的浪费,过小造成溢出。
因此，当对线性表的长度或存储规模难以估计时，不宜采用顺序表。
然而，链表的动态分配则可以克服这个缺点.链表不需要预留存储空间，也不需要知道表长如何变化，只要内存空间尚有空闲，就可以再程序运行时随时地动态分配空间，不需要时还可以动态回收。
因此，当线性表的长度变化较大或者难以估计其存储规模时，宜采用动态链表作为存储结构。
但在链表中，除数据域外海需要在每个节点上附加指针。
如果节点的数据占据的空间小，则链表的结构性开销就占去了整个存储空间的大部分。
当顺序表被填满时，则没有结构开销.在这种情况下，顺序表的空间效率更高。
顺序表与链表的比较
顺序表与链表的比较一、顺序表的特点是逻辑上相邻的数据元素，物理存储位置也相邻，并且，顺序表的存储空间需要预先分配。
它的优点是：（1）方法简单，各种高级语言中都有数组，容易实现。
（2）不用为表示节点间的逻辑关系而增加额外的存储开销。
（3）顺序表具有按元素序号随机访问的特点。
缺点：（1）在顺序表中做插入、删除操作时，平均移动表中的一半元素，因此对n较大的顺序表效率低。
（2）需要预先分配足够大的存储空间，估计过大，可能会导致顺序表后部大量闲置；预先分配过小，又会造成溢出。
二、在链表中逻辑上相邻的数据元素，物理存储位置不一定相邻，它使用指针实现元素之间的逻辑关系。
并且，链表的存储空间是动态分配的。
链表的最大特点是：插入、删除运算方便。
缺点：（1）要占用额外的存储空间存储元素之间的关系，存储密度降低。
存储密度是指一个节点中数据元素所占的存储单元和整个节点所占的存储单元之比。
（2）链表不是一种随机存储结构，不能随机存取元素。
三、顺序表与链表的优缺点切好相反，那么在实践应用中怎样选取存储结构呢？通常有以下几点考虑：（1）顺序表的存储空间是静态分配的，在程序执行之前必须明确规定它的存储规模，也就是说事先对“MaxSize”要有合适的设定，设定过大会造成存储空间的浪费，过小造成溢出。
因此，当对线性表的长度或存储规模难以估计时，不宜采用顺序表。
然而，链表的动态分配则可以克服这个缺点。
链表不需要预留存储空间，也不需要知道表长如何变化，只要内存空间尚有空闲，就可以再程序运行时随时地动态分配空间，不需要时还可以动态回收。
因此，当线性表的长度变化较大或者难以估计其存储规模时，宜采用动态链表作为存储结构。
但在链表中，除数据域外海需要在每个节点上附加指针。
如果节点的数据占据的空间小，则链表的结构性开销就占去了整个存储空间的大部分。
当顺序表被填满时，则没有结构开销。
在这种情况下，顺序表的空间效率更高。
由于设置指针域额外地开销了一定的存储空间，从存储密度的角度来讲，链表的存储密度小于1.因此，当线性表的长度变化不大而且事先容易确定其大小时，为节省存储空间，则采用顺序表作为存储结构比较适宜。
数据结构顺序表链表试验报告
数据结构顺序表链表试验报告数据结构试验报告一、引言数据结构是计算机科学中非常重要的一个概念，它用于组织和存储数据，以便能够高效地进行检索和操作。
顺序表和链表是两种常见的数据结构，它们在实际应用中都有各自的优势和局限性。
本报告将对顺序表和链表进行试验比较，以评估它们在不同场景下的性能和适合性。
二、实验目的本次试验的目的是比较顺序表和链表在插入、删除和查找操作上的性能差异，并分析其时间复杂度和空间复杂度。
通过实验结果，可以对不同场景下选择合适的数据结构提供参考。
三、实验内容1. 顺序表实验a. 创建一个包含100个元素的顺序表；b. 在表尾插入一个元素；c. 在表头插入一个元素；d. 在表的中间位置插入一个元素；e. 删除表尾的一个元素；f. 删除表头的一个元素；g. 删除表的中间位置的一个元素；h. 查找一个元素；i. 遍历整个顺序表。
2. 链表实验a. 创建一个包含100个节点的链表；b. 在链表尾部插入一个节点；c. 在链表头部插入一个节点；d. 在链表的中间位置插入一个节点；e. 删除链表尾部的一个节点；f. 删除链表头部的一个节点；g. 删除链表的中间位置的一个节点；h. 查找一个节点；i. 遍历整个链表。
四、实验结果与分析1. 顺序表实验结果a. 在表尾插入一个元素的平均时间为0.1ms；b. 在表头插入一个元素的平均时间为0.2ms；c. 在表的中间位置插入一个元素的平均时间为0.5ms；d. 删除表尾的一个元素的平均时间为0.1ms；e. 删除表头的一个元素的平均时间为0.2ms；f. 删除表的中间位置的一个元素的平均时间为0.5ms；g. 查找一个元素的平均时间为1ms；h. 遍历整个顺序表的平均时间为10ms。
2. 链表实验结果a. 在链表尾部插入一个节点的平均时间为0.2ms；b. 在链表头部插入一个节点的平均时间为0.1ms；c. 在链表的中间位置插入一个节点的平均时间为0.5ms；d. 删除链表尾部的一个节点的平均时间为0.2ms；e. 删除链表头部的一个节点的平均时间为0.1ms；f. 删除链表的中间位置的一个节点的平均时间为0.5ms；g. 查找一个节点的平均时间为2ms；h. 遍历整个链表的平均时间为5ms。
数据结构第二章实验报告
数据结构第二章实验报告一、实验目的数据结构第二章主要涉及线性表的相关知识，本次实验的目的在于通过实际操作和编程实现，深入理解线性表的概念、存储结构以及基本操作，巩固所学的理论知识，并提高编程能力和问题解决能力。
二、实验环境本次实验使用的编程语言为C+＋，编程环境为Visual Studio 2019。
三、实验内容（一）顺序表的实现顺序表是一种用顺序存储方式实现的线性表。
在实验中，我们定义了一个结构体来表示顺序表，包括存储数据的数组和表示表长度的变量。
实现了顺序表的初始化、插入、删除、查找等基本操作。
（二）链表的实现链表是一种通过指针链接实现的线性表。
我们分别实现了单向链表和双向链表。
在单向链表中，每个节点包含数据和指向下一个节点的指针；双向链表则在此基础上增加了指向前一个节点的指针，使得链表的操作更加灵活。
（三）线性表的应用运用实现的线性表解决了一些实际问题，如数据排序、查找特定元素等。
四、实验步骤（一）顺序表的实现步骤1、定义顺序表结构体，包括数据数组和长度变量。
2、实现顺序表的初始化函数，将长度初始化为 0。
3、插入操作：首先判断表是否已满，如果未满，在指定位置插入元素，并将后续元素后移。
4、删除操作：首先判断指定位置是否合法，然后将该位置元素删除，并将后续元素前移。
5、查找操作：遍历表中的元素，找到目标元素返回其位置，否则返回－1。
（二）链表的实现步骤1、单向链表定义单向链表节点结构体，包含数据和指向下一个节点的指针。
实现链表的初始化函数，创建头节点。
插入操作：分为头插法和尾插法，根据插入位置的不同选择相应的方法。
删除操作：找到要删除的节点，将其前后节点连接起来，释放删除节点的内存。
查找操作：遍历链表，找到目标元素返回节点指针，否则返回NULL。
2、双向链表定义双向链表节点结构体，包含数据、指向前一个节点和指向下一个节点的指针。
初始化函数与单向链表类似，但需要同时处理前后指针。
插入和删除操作：在单向链表的基础上，同时更新前后节点的指针。
数据结构实验二链表
数据结构实验二1、实验目的∙熟练掌握线性表的链式存储结构定义及基本操作∙理解循环链表和双链表的特点和基本运算2、实验内容：建立单链表，完成链表（带表头结点）的基本操作：建立链表、插入、删除、查找、输出、求前驱、求后继、两个有序链表的合并操作。
其他基本操作还有销毁链表、将链表置为空表、求链表的长度、获取某位置结点的内容、搜索结点。
1．问题描述：利用线性表的链式存储结构,设计一组输入数据（假定为一组整数），能够对单链表进行如下操作：∙初始化一个带表头结点的空链表;∙创建一个单链表是从无到有地建立起一个链表，即一个一个地输入各结点数据，并建立起前后相互链接的关系。
又分为逆位序(插在表头)输入n 个元素的值和正位序(插在表尾)输入n 个元素的值;∙插入结点可以根据给定位置进行插入（位置插入），也可以根据结点的值插入到已知的链表中（值插入），且保持结点的数据按原来的递增次序排列，形成有序链表。
∙删除结点可以根据给定位置进行删除（位置删除），也可以把链表中查找结点的值为搜索对象的结点全部删除（值删除）;∙输出单链表的内容是将链表中各结点的数据依次显示，直到链表尾结点;∙求前驱结点是根据给定结点的值，在单链表中搜索其当前结点的后继结点值为给定的值，将当前结点返回;∙求后继结点是根据给定结点的值，在单链表中搜索其当前结点的值为给定的值，将后继结点返回;∙两个有序链表的合并是分别将两个单链表的结点依次插入到第3 个单链表中，继续保持结点有序;编写主程序，实现对各不同的算法调用。
其它的操作算法描述略。
2．实现要求：对链表的各项操作一定要编写成为C（C++）语言函数，组合成模块化的形式，还要针对每个算法的实现从时间复杂度和空间复杂度上进行评价。
∙“初始化算法”的操作结果：构造一个空的线性表L，产生头结点,并使L 指向此头结点;∙“建立链表算法”初始条件：空链存在;操作结果：选择逆位序或正位序的方法，建立一个单链表，并且返回完成的结果;∙“链表（位置）插入算法”初始条件：已知单链表L 存在;操作结果：在带头结点的单链线性表L 中第i 个位置之前插入元素e;∙“链表（位置）删除算法”初始条件：已知单链表L 存在;操作结果：在带头结点的单链线性表L 中，删除第i 个元素,并由e 返回其值;∙“输出算法”初始条件：链表L 已存在;操作结果：依次输出链表的各个结点的值;∙“求前驱算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是第一个,则用pre_e 返回它的前驱;∙“求后继算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是最后一个,则用next_e 返回它的后继;∙“两个有序链表的合并算法”初始条件: 线性表单链线性表La 和Lb 的元素按值非递减排列;操作结果:归并La 和Lb 得到新的单链表。
顺序表和单链表实验报告
数据结构实验报告一、顺序表操作验证1. 实验目的⑴掌握线性表的顺序存储结构；⑵验证顺序表及其基本操作的实现；⑶掌握数据结构及算法的程序实现的基本方法。
2. 实验内容⑴建立含有若干个元素的顺序表；⑵对已建立的顺序表实现插入、删除、查找等基本操作。
3.设计与编码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList{int *list;int size;int MaxSize;};typedef struct LinearList LIST;void InitList(LIST *L,int ms){if((L->list=(int*)malloc(ms *sizeof(int)))==NULL){ printf("内存申请错误！\n");exit(1);}L->size=0;L->MaxSize=ms;}int InsertList(LIST *L,int item,int rc) {int i;if(L->size>=L->MaxSize)return-1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)L->list[i+1]=L->list[i];L->list[rc]=item;L->size++;return 0;}void OutputList(LIST *L){int i;for(i=0;i<L->size;i++)printf("%d ",L->list[i]);printf("\n");int FindList(LIST *L,int item){int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item){int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;int DeleteList2(LIST *L,int rc) {int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++) L->list[n]=L->list[n+1];L->size--;return 0;}void main(){LIST LL;int i,r;printf("listaddr=%p\tsize=%d\tMaxSize=%d\n",LL.list,LL.size,LL.MaxSize); InitList(&LL,100);printf("listaddr=%p\tsize=%d\tMaxSize=%d\n",LL.list,LL.size,LL.MaxSize);while(1){printf("请输入元素值，输入0结束插入操作：");fflush(stdin);scanf("%d",&i);if(i==0)break;printf("请输入插入位置：");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为：");OutputList(&LL);}while(1){printf("请输入查找元素值，输入0结束查找操作：");fflush(stdin);scanf("%d",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没找到\n");elseprintf("有符合条件的元素，位置为：%d\n",r+1);}while(1){printf("请输入删除元素值，输入0结束查找操作：");fflush(stdin);scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(r<0)printf("没找到\n");else{printf("有符合条件的元素，位置为：%d\n线性表为：",r+1);OutputList(&LL);}}while(1){printf("请输入删除元素位置，输入0结束查找操作：");fflush(stdin);scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为：");OutputList(&LL);}}}4.运行结果二、单链表操作验证1. 实验目的⑴掌握线性表的链式存储结构；⑵验证单链序表及其基本操作的实现；⑶进一步掌握数据结构及算法的程序实现的基本方法。
顺序表,链表实验报告.总结
顺序表,链表实验报告.总结实验报告实验目的：学生管理系统（顺序表）实验要求：1.建表2.求表长3.插入4.查找5.删除6.列表7.退出源程序：#include#include#include#define MaxSize 1000typedef struct{char xh[40];char xm[40];int cj;}DataType; //学生的结构typedef struct {DataType data[MaxSize]; //定义表的数据类型int length; //数据元素分别放置在data[0]到data[length-1]当中} SqList; //表的结构void liebiao(SqList *L) //建立表格{int k,n;char q;printf("请输入,输入学生的个数：\n");fflush(stdin);scanf("%d",&n);for(k=0;k<=n-1;k++){printf("请输入学生学号\n");scanf("%s",L->data[k].xh);printf("请输入学生名字\n");scanf("%s",L->data[k].xm);printf("请输入学生成绩\n");scanf("%d",&L->data[k].cj);}L->length=n;}void qb(SqList *L) //全部输出{int k,w;for(k=0;klength;k++){w=k+1;printf("第%d位学生：",w);printf("%s %s %d\n",L->data[k].xh,L->data[k].xm,L->da ta[k].cj);}}int cr(SqList *L,DataType *xs,int i) //插入信息{int j;if(L->length==MaxSize){printf("没有!");return 0;}else if((i<0)||(i>L->length)){printf("程序溢出，不符合");return 0;}else{for(j=L->length-1;j>=i;j--){strcpy(L->data[j+1].xh,L->data[j].xh); strcpy(L->data[j+1].xm,L->data[j].xm); L->data[j+1].cj=L->data[j].cj;}strcpy(L->data[i].xh,xs->xh);strcpy(L->data[i].xm,xs->xm);L->data[i].cj=xs->cj;L->length=L->length+1;}return 0;}int cz(SqList *L) //查找信息{char xh[40];char xm[40];int cj;int i=0,u;printf(" 1、按学号查询 \n");printf(" 1、按姓名查询 \n");printf(" 1、按成绩查询 \n");printf("请选择：");fflush(stdin);scanf("%d",&u);if (u==1){printf("请输入要查找学生的学号："); scanf("%s",xh);for(i=0;ilength;i++){if(strcmp(L->data[i].xh,xh)==0) return i;}}if (u==2){printf("请输入要查找学生的姓名："); scanf("%s",xm);for(i=0;ilength;i++){if(strcmp(L->data[i].xm,xm)==0) return i;}}if (u==3){printf("请输入要查找学生的成绩："); scanf("%s",cj);for(i=0;ilength;i++){if(L->data[i].cj,&cj)return i;}}return -1;//*如果没找到，返回-1}int cz2(SqList *L) //删除查找的函数{char xh[40];char xm[40];int i=0,h;printf(" 1、按学号删除 \n");printf(" 2、按姓名删除 \n");printf("请选择：");fflush(stdin);scanf("%d",&h);if (h==1){printf("请输入要删除学生的学号：");scanf("%s",xh);for(i=0;ilength;i++){if(strcmp(L->data[i].xh,xh)==0) //判断输入和已知学号一样不return i;}}else if (h==2){printf("请输入要删除学生的姓名：");scanf("%s",xm);for(i=0;ilength;i++){if(strcmp(L->data[i].xm,xm)==0) //判断输入姓名和已知姓名一样不return i;}}return -1;}void sc(SqList *L) //删除函数{int i,j;printf("请先选择您要删除的学生信息的方式：\n");scanf("%d",&j);i=cz2(L);if(i==-1){printf("没有查到要删除的学生信息");return;}for(j=i;jlength;j++) // 要删除学生以后的学生整体上调一位{L->data[j].cj=L->data[j+1].cj; //就是后一个覆盖了前一个strcpy(L->data[j].xh,L->data[j+1].xh);strcpy(L->data[j].xm,L->data[j+1].xm);}L->length--;printf("该学生信息已被删除！\n");}int bc(SqList *L){return (L->length);}int main() //主体大函数{int i,k;SqList *L; //定义顺序表的指针DataType *xs;L=(SqList *)malloc(sizeof(SqList)*MaxSize); char q;ee:rewind(stdin);{printf(" 学生管理系统 \n"); //函数的各个结构printf(" \n");printf(" \n");printf(" \n");printf(" 建立表格请输入1 \n");printf(" 求表长请输入2 \n");printf(" 插入请输入3 \n");printf(" 查找请输入4 \n");printf(" 删除请输入5 \n");printf(" 列表请输入6 \n");printf(" 退出请按0 \n");printf(" 请输入");scanf("%c",&q);}if(q=='1'){rewind(stdin);liebiao(L);goto ee;}if(q=='2'){rewind(stdin);bc(L);printf("共%d个学生\n",L->length);goto ee;}if(q=='3'){rewind(stdin);printf(" 插入 \n");printf("\t\t 请输入要添加的学生信息: \n"); xs=(DataType *)malloc(sizeof(DataType)); printf("请输入学生学号\n");scanf("%s",xs->xh);printf("请输入学生名字\n");scanf("%s",xs->xm);printf("请输入学生成绩\n");scanf("%d",&xs->cj);printf("请输入要插入的位置：\n"); rewind(stdin);scanf("%d",&i);cr(L,xs,i);goto ee;}if(q=='4'){rewind(stdin);printf(" 查找 \n");printf(" 查询学生信息 \n");i=cz(L);if(i!=-1){printf("%s %s %d\n",L->data[i].xh,L->data[i].x m,L->data[i].cj);}else{printf("信息不存");}goto ee;}if(q=='5'){rewind(stdin);printf(" 删除 \n"); printf(" 删除学生信息 \n");sc(L);goto ee;}if(q=='6'){rewind(stdin);printf(" 列表 \n");qb(L);goto ee;}if(q=='0') {printf("谢谢使用\n");}if(!(q=='1'||q=='2'||q=='3'||q=='4'||q=='5'||q=='5'||q=='0 ')) {goto ee;}system ("pause"); return 0;}主程序：输入1--6n=1 n=2n=3n=4n=5n=6退出建表求表长插入查找删除列表建表：是否输入学生个数n ，变量k k=0; k<=n-1;输入学号，姓名，成绩k=k+1 结束输入查找学号n，变量k k=0n=k是否k=k+1输出是否是否输入插入位置n 表长L 变量kn<=Lk=0n=kk=k+1strcpy(L->data[j+1].xh,L->data[j].xh);strcpy(L->data[j+1].xm,L->data[j].xm);L->data[j+1].cj=L->data[j].cj输入错误结束是否否是输入删除的位置n 变量k 表长Ln<=Lk=0n=k k=k+1strcpy(L->data[j].xh,L->data[j-1].xh);strcpy(L->data[j].xm,L->data[j-1].xm); L->data[j].cj=L->data[j-1].cj输入错误结束。
数据结构实验报告-顺序表链表的实现参考模板
课程名称：数据结构任课教师：实验题目：线性表的基本操作实验环境： Visual C++ 6.0实验目的：1、掌握线性表的定义；2、掌握线性表的基本操作，如建立、查找、插入和删除等。
实验内容：定义一个包含学生信息（学号，姓名，成绩）的的顺表序和链表，使其具有如下功能：(1)根据指定学生个数，逐个输入学生信息;(2)逐个显示学生表中所有学生的相关信息；(3)根据姓名进行查找，返回此学生的学号和成绩；(4)根据指定的位置可返回相应的学生信息（学号，姓名，成绩）；(5)给定一个学生信息，插入到表中指定的位置；int createStLink(struct Node *head,struct Node *stu){struct Node *p6,*p7,*p8;p7=head;p6=stu;if(head==NULL){head=p6;p6->next=NULL;}else{ //如果链表为空则在头结点创建信息while(p6->num > p7->num && p7->next!=NULL){p8=p7;p7=p7->next;}if(p6->num<=p7->num){if(head==p7)head=p6;elsep8->next=p6;p6->next=p7;}else{p7->next=p6;p6->next=NULL;}}N++;return 1;}int main(){struct Node *H,*stud;char M;int num1;H=initlist();(6)删除指定位置的学生记录;(7) 统计表中学生个数。
实验提示：学生信息的定义：typedef struct {char no[8]; //8位学号char name[20]; //姓名int price; //成绩}Student;顺序表的定义typedef struct {Student *elem; //指向数据元素的基地址int length; //线性表的当前长度}SqList；链表的定义：typedef struct LNode{Student data; //数据域struct LNode *next; //指针域}LNode,*LinkList;实验要求：(1) 程序要添加适当的注释，程序的书写要采用缩进格式。
青岛理工大学数据结构第二次实验报告
青岛理工大学数据结构课程实验报告
算法描述及实验步骤
template <class T>
class SQList//顺序表
template <class T>
class SQListjcb//顺序表的交叉并template <class T>
class SQLnode//单链表
template <class T>
class SQLnodejcb//链表的交叉并
调试过程及实验结果
总结本次试验对于顺序表和链表的优缺点的认识更加深刻。
顺序表中进行查找操作时较方便，而链表则适合进行插入和删除运算。
顺序表存储密度大，存储空间利用率高；链表插入和删除运算时很方便，使用灵活。
求集合的交并差运算用顺序表和链表实现时，顺序表的程序比较好做一点，因为是使用另一个数组C来存储运算结果，所以并没有在数组中进行插入和删除运算，程序较简单；而做链表时遇到了困难，再插入新节点时程序总是不能运行。
附录#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1 #define OVERLOW -2 #include<iostream>
#include<string>
#include<windows.h> using namespace std;。
顺序表链表KMP实验报告
附件（四）深圳大学实验报告课程名称：数据结构实验与课程设计实验项目名称：顺序表、链表、堆栈队列、串KMP算法学院：专业：指导教师：报告人：学号：班级：实验时间：实验报告提交时间：教务处制第1行输出创建后的顺序表内容，包括顺序表实际长度和数据（完成）每成功执行一次操作（插入或删除），输出执行后的顺序表内容（完成）每成功执行一次查找，输出查找到的数据（完成）如果执行操作失败（包括插入、删除、查找等失败），输出字符串error，不必输出顺序表内容（完成）2.Problem B: DS顺序表--连续操作目的：(1)建立顺序表的类，属性包括：数组、实际长度、最大长度（设定为1000）(2)实现连续多个插入，即从位置i开始插入多个数据(3)实现连续多个删除，即从位置i开始删除多个数据要求：Input第1行先输入n表示有n个数据，即n是实际长度；接着输入n个数据（完成）第2行先输入i表示插入开始的位置，再输入k表示有k个插入数据，接着输入k 个数据（完成）第3行先输入i表示删除开始的位置，再输入k表示要删除k个数据（完成）Output顺序表内容包括顺序表的实际长度和数据，数据之间用空格隔开（完成）第1行输出创建后的顺序表内容（完成）第2行输出执行连续插入后的顺序表内容（完成）第3行输出执行连续删除后的顺序表内容（完成）(2)属性包括：data数据域、next指针域(3)操作包括：插入、删除、查找(4)注意：单链表不是数组，所以位置从1开始对应首结点，头结点不放数据要求：Input第1行先输入n表示有n个数据，接着输入n个数据（完成）第2行输入要插入的位置和新数据（完成）第3行输入要插入的位置和新数据（完成）第4行输入要删除的位置（完成）第5行输入要删除的位置（完成）第6行输入要查找的位置（完成）第7行输入要查找的位置（完成）Output数据之间用空格隔开，（完成）第1行输出创建后的单链表的数据（完成）每成功执行一次操作（插入或删除），输出执行后的单链表数据（完成）每成功执行一次查找，输出查找到的数据（完成）如果执行操作失败（包括插入、删除、查找等失败），输出字符串error，不必输出单链表（完成）2.Problem B: DS单链表--结点交换目的：(1)用C++实现含头结点的单链表，然后实现单链表的两个结点交换位置。
数据结构 - 顺序表与链表
数据结构 - 顺序表与链表数据结构实验报告实验��：顺序表与链表专业：班级：姓名：学号：指导教师：日期：2021.实验��：顺序表与链表一、实验目的：（1）掌握顺序表的存储结构形式及其描述和基本运算的实现。
（2）熟练掌握动态链表结构及有关算法的设计。
（3）掌握用链表表示特定形式的数据的方法，并能编写出有关运算的算法。
（4）理解单循环链表及双循环链表的特点。
二、实验内容：1、顺序表的应用(1)．输入一组整型元素序列，建立顺序表。
(2)．实现该顺序表的遍历。
(3)．在该顺序表中顺序查找某一元素,查找成功返回1,否则返回0。
(4)．判断该顺序表中元素是否对称,对称返回1,否则返回0。
(5)．实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。
(6)．输入整型元素序列利用有序表插入算法建立一个有序表。
(7)．利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。
(8)．编写一个主函数,调试上述算法。
一、需求分析1.输入的形式和输入值的范围建立顺序表时输入的都是整数。
2.输出形式3.程序所能达到的功能完成顺序表的生成，排序，合并； 4.测试数据：见第八部分。
二、概要设计本程序包含的函数主函数 main()判断是否对称函数Symmetric() 排序的函数DataSort()其中main函数负责操作其他的函数。
三、调试分析在调试过程中要注意的就是输入多注意特殊值以及不要输入错误那个个数，因为要求输入的数比较多，所以要细心一点四、详细代码及运行结果#include #include #define MAX 300int Symmetric(int L[],int m); void DataSort(int number[],int r);int main() {int A[MAX] = {0}, Odd[MAX] = {0}, Even[MAX] = {0}; int B[500], C[500], D[1000]; int Lb, Lc;int i, La, a, n, p, w;int Found, flag = 0, time = 0, k = 0, tb = 0, tc = 0; scanf(\ for(i = 0; i < La; i++) scanf(\ scanf(\for(i = 0; i < La; i++) {printf(\ if(A[i] == Found) flag = 1; }printf(\ if(flag == 1)printf(\elseprintf(\ a = Symmetric(A,La);if(a == 1) printf(\else printf(\i = 0;while(i < La) {if(A[i] % 2 == 0) {Even[time++] = A[i]; i++; }else if(A[i] % 2 != 0) {Odd[k++] = A[i]; i++; } }for(p = k, w = 0; w < time; w++, p++) {Odd[p] = Even[w]; }for(p = 0; p < (time + k); p++) printf(\ printf(\DataSort(A,La);scanf(\ scanf(\ for(i = 0; i < Lb; i++) scanf(\ for(n = 0; n < Lc; n++) scanf(\ DataSort(B,Lb); DataSort(C,Lc);for(i = 0; i < Lb + Lc; i++) {if(B[tb] > C[tc]) {D[i] = B[tb]; tb++;} else {D[i] = C[tc]; tc++; } }for(i = 0; i < Lb + Lc; i++) printf(\ printf(\return 0; }int Symmetric(int L[],int m) {int l;if(m % 2 == 0) {for(l = 0; l < m / 2; l++) {if(L[l] != L[m - l - 1]) return 0; } } else {for(l = 0; l < (m - 1) / 2; l++) {if(L[l] != L[m - l - 1]) return 0; } }return 1; }void DataSort(int number[],int r) {int j, h, o, num;for(j = 0; j < r - 1; j++) {h = j;for(o = j + 1; o < r; o++) {if(number[o] > number[h])感谢您的阅读，祝您生活愉快。
线性表与链表实验报告
数据结构实验报告实验0：顺序表与链表专业：班级：姓名：学号：指导教师：日期：一、实验目的（1）掌握顺序表的存储结构形式及其描述和基本运算的实。
（2）熟练掌握动态链表结构及有关算法的设计。
（3）掌握用链表表示特定形式的数据的方法，并能编写出有关运算的算法。
（4）理解单循环链表及双循环链表的特点。
二、实验内容（1）顺序表的应用（2）链表的应用三、需求分析1.输入的形式和输入值的范围2.建立链表时输入的都是整数,输入0代表输入的结束，插入元素时需要输入插入的位置和元素的值，删除元素时输入删除元素的值。
3.输出形式4.所有操作在出现错误时都会有提示，并且在任意一个操作结束后都会输出操作后的链表。
5.程序所能达到的功能6.完成链表的生成，任意位置插入元素、删除，实现链表数据的排序，删除链表中相同的元素，并且比较两个链表是否相等以及将两链表合成一个有序的链表。
7. 4.测试数据：见第八部分。
四、概要设计实验一：(1) 本程序包含的函数如下:其中main函数负责操作其他的函数。
(2)各函数的功能设计为：Creat(student & L)：建立一个链表L(尾部插入建立的链表)，并且返回这个链表的头指针。
find（student L，int e）：在链表L中寻找一样元素e。
print(student L):依次输出链表 L 的内容。
insert(student & L)：插入元素。
spilt(student & L)：从后向前寻找奇数在偶数前的情况，如果一个奇数或偶数之后还是一个奇数和偶数，就让代表奇数和偶数的变量自增，在每次所有符合连续情况的奇偶数交换完成后，偶数要从新计数。
symmetry(student L)：判断是否是对称的链表。
unite(student L1, student L2, Student & L3)：将链表A和B合成一个非递减的链表，返回新链表的头指针.五、详细设计(1)结点类型和指针类型:typedef struct{int *elem;//数组指针elem指示线性表的基地址。
数据结构课程设计实验报告(顺序表与链表)
《数据结构》课程实验报告专业：计算机科学与技术（嵌入式系统方向）指导老师：解德祥班级: 20101121姓名: 刘毓涵学号: 2010112116完成日期: 2011/11/26实验内容：实验二一、实验目的1）掌握栈与队列的数据类型描述及特点；2）熟练掌握栈的顺序和链式存储存表示与基本算法的实现；3）掌握队列的链式存储表示与基本操作算法实现;4) 掌握栈与队列在实际问题中的应用和基本编程技巧;4）按照实验题目要求独立正确地完成实验内容（提交程序清单及相关实验数据与运行结果）；5）认真书写实验报告,并按时提交。
二、实验环境计算机、C语言程序设计环境三、实验学时4学时。
四、实验内容1、汉诺塔问题。
程序结果：给出程序执行过程中栈的变化过程与圆盘的搬动状态。
2、括号匹配问题（只考虑小括号）。
五、实验内容一（汉诺塔问题）步骤：#include<stdio.h>int i=0;void move(char a,int n,char b){i++;printf("%d.move %d from %c to %c\n",i,n,a,b);}void hanoi(int n,char x,char y,char z){if(n==1)move(x,1,z);else{hanoi(n-1,x,z,y);move(x,n,z);hanoi(n-1,y,x,z);}}void print(){printf("**************Hanoi**************");printf("\n1.Begin");printf("\n2.Exit");}void process(){int x;do{printf("\nplease chooce 1 or 2:");scanf("%d",&x);switch(x){case 1:printf("please write the number:");int n;scanf("%d",&n);printf("The process is:\n");hanoi(n,'A','B','C');break;case 2:printf("Are you sure exiting? Y/N\n");char m;scanf("%s",&m);if(m=='Y'||m=='y')x=3;break;default:printf("\nOut of range!\n");}}while(x!=3);}void main(){print();process();}六、实验内容一测试数据与实验结果：七、实验内容二（小括号匹配问题）步骤：#include<stdio.h>#include<malloc.h>#define TURE 1#define FALSE 0typedef struct node{char data;struct node *next;}LinkStackNode,*LinkStack;void InitStack(LinkStack *top){*top=(LinkStack)malloc(sizeof(LinkStackNode));(*top)->next=NULL;}int Push(LinkStack top,char x){LinkStackNode *temp;temp=(LinkStack)malloc(sizeof(LinkStackNode));if(temp==NULL)return(FALSE);else{temp->data=x;temp->next=top->next;top->next=temp;return(TURE);}}int Pop(LinkStack top,char *x){LinkStack temp;if(top->next!=NULL){temp=top->next;top->next=temp->next;*x=temp->data;free(temp);return(TURE);}elsereturn(FALSE);}void match(char *str){LinkStack S;char ch;int i;InitStack(&S);for(i=0;str[i]!='\0';i++){if(str[i]=='(')Push(S,str[i]);else if(str[i]==')'){if(S->next==NULL){printf("右括号多余!\n");printf("\n");return;}else{Pop(S,&ch);printf("%c%c",ch,str[i]);}}}if(S->next==NULL)printf("匹配成功!\n");elseprintf("左括号多余!\n");printf("\n");}void print(){printf("********************BracketMatch********************\n");printf("1.Begin\n");printf("2.Exit\n");}void process(){int x;do{printf("please write 1 or 2:");scanf("%d",&x);switch(x){case 1:printf("please write your char:\n");char s;scanf("%s",&s);match(&s);break;case 2:printf("Are you sure exiting?Y/N\n");char m;scanf("%s",&m);if(m=='Y'||m=='y')x=3;break;default:printf("Out of range!\n");}}while(x!=3);}void main(){print();process();}八、实验内容二测试数据与实验结果：。
顺序表与链表及应用
电子信息工程学系实验报告课程名称：数据结构与算法实验项目名称：算法练习实验时间： 2012.02.21 班级：姓名：学号：实验目的:1掌握线性表中元素的前驱、后续的概念。
2掌握顺序表与链表的建立、插入元素、删除表中某元素的算法。
3对线性表相应算法的时间复杂度进行分析。
实验环境Windows XPWin-Tc实验内容及过程:用线性表表示多项式,并实现多项式的相加.编程代码如下：#include <stdio.h>#include <stdlib.h>typedef struct{ int coff;int exp;} ElementType;typedef int Position;typedef struct node{ElementType data;struct node *link;} *List,Node;List MakeEmpty(){List h;h = (List) malloc(sizeof(Node));h ->link = NULL;return h;}PrintList(List h){ 成绩：指导教师（签名）：printf("\nThe list:\n");p = h->link;while(p!=NULL){if(p->link==NULL)printf("%dX%d ",p->data.coff,p->data.exp);elseprintf("%dX%d+ ",p->data.coff,p->data.exp);p = p->link;}}Insert(ElementType x,List L){List tail,q;tail=L;while(tail->link!=NULL)tail=tail->link;q = (List) malloc(sizeof(Node));q->data.coff = x.coff;q->data.exp = x.exp;tail->link = q;tail = q;tail->link=NULL;}List Addition(List l1,List l2){ElementType data;List p1,p2,l,q;l=MakeEmpty();p1=l1->link;p2=l2->link;while(p1!=NULL&&p2!=NULL){if(p1->data.exp<p2->data.exp){data.exp=p2->data.exp;data.coff=p2->data.coff;Insert(data,l);p2=p2->link;}else if(p1->data.exp==p2->data.exp){if(p1->data.coff+p2->data.coff){data.exp=p2->data.exp;data.coff=p1->data.coff+p2->data.coff;Insert(data,l);}p1=p1->link;p2=p2->link;else{data.exp=p1->data.exp;data.coff=p1->data.coff;Insert(data,l);p1=p1->link;}}while(p1!=NULL){data.exp=p1->data.exp;data.coff=p1->data.coff;Insert(data,l);p1=p1->link;}while(p2!=NULL){data.exp=p2->data.exp;data.coff=p2->data.coff;Insert(data,l);p1=p2->link;}return l;}List InputPolymial(int n){int i;ElementType data;List L;L = MakeEmpty();for(i=0;i<n;i++){printf("the [%d] term coff:",i+1);scanf("%d",&(data.coff));printf("the [%d] term exp:",i+1);scanf("%d",&(data.exp));Insert(data,L);}return L;}List Input(){int n;List l;printf("\nplease input the terms of Polyomial :");scanf("%d",&n);l=InputPolymial(n);PrintList(l);return l;}DestroyList(List L){while(L->link!=NULL){p=L->link;L->link=p->link;free(p);}free(L);}main(){List L1,L2,L;do{L1=Input();L2=Input();L=Addition(L1,L2);printf("\nThe sum of Polyomial L1 and L2 is:\n");PrintList(L);DestroyList(L1);DestroyList(L2);DestroyList(L);printf("\nIf you want to try again print Y:");}while(getche()=='y'||getche()=='Y');getch();}实验结果及分析：实验分析：根据要求我们要求得N个数中第K个最大数；经过分析共有两种方法：首先把输入的两个多项式保存在两个链表L1,L2中；第一种是把L2中的节点一个个的取出并逐个与L1中节点比较并按照指数exp从大到小的顺序插入L2中，如果exp相同则看他们系数和，为0则跳过这个节点，最后L2中就是最后答案，当然这种方法时间复杂度为O（m*n）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
常熟理工学院《数据结构与算法》实验指导与报告书__2017_学年第__1__ 学期专业：物联网工程___________________________ __ 学号： __________________________ ____姓名： ________________________________ __实验名称：顺序表与链表_______________________________ 实验地点：N6-210_____________________________ ____ 指导教师：聂盼红__________________________ ___计算机科学与工程学院2017实验二顺序表与链表【实验目的】1、掌握线性表中元素的前驱、后续的概念。
2、掌握顺序表与链表的建立、插入元素、删除表中某元素的算法。
3、对线性表相应算法的时间复杂度进行分析。
4、理解顺序表、链表数据结构的特点（优缺点）。
【实验学时】4学时【实验预习】回答以下问题：1、顺序表的存储表示在顺序表中，任一数据元素的存放位置是从起始位置开始、与该数据元素的位序成正比的对应存储位置，借助LOC(ai)=LOC(a1)+(i-1)*1确定，则顺序表是一种随机存取的存储结构。
2、单链表的存储表示线性链表也称单链表，在每一个结点中只包含一个指针，用于指示该结点的直接后继结点，整个链表通过指针相连，最后一个结点因为没有后继结点，其指针置为空（NULL）。
这样，链表中所有数据元素（结点）构成一对一的逻辑关系，实现线性表的链式存储。
【实验内容和要求】1、按照要求完成程序exp2_1.c，实现顺序表的相关操作。
以下函数均具有返回值，若操作完成，返回OK，操作失败返回ERROR。
函数需返回的其他数据，使用函数参数返回。
exp2_1.c部分代码如下：#include<stdio.h>#include<malloc.h>#define ERROR 0#define MAXSIZE 100#define OK 1typedef int ElemType; /*定义表元素的类型*/typedef struct slist{ElemType *list;int listsize;int length;}Sqlist;Sqlist *L;/*（1）---补充顺序表的存储分配表示，采用定长和可变长度存储均可*/ /*函数声明*/int InitList_sq(Sqlist *L);int CreateList_sq(Sqlist *L);int ListInsert_sq(Sqlist *L,int i,ElemType e);int PrintList_sq(Sqlist *L);int ListDelete_sq(Sqlist *L,int i,ElemType *e);int ListLocate(Sqlist *L,ElemType e,int *pos);int menu_select();/*（2）---顺序表的初始化*/int InitList_sq(Sqlist *L){L->list=(ElemType *)malloc(MAXSIZE*sizeof(ElemType));if(L->list==NULL)return ERROR;else{L->length=0;L->listsize=MAXSIZE;}return 0;}/*InitList*//*（3）---创建具有n个元素的顺序表*/int CreateList_sq(Sqlist *L){int a,b,c;printf("请输入输入数据的个数n:");scanf("%d",&a);printf("请输入输入的数据:");for(b=0;b<a;b++){scanf("%d",&c);L->list[b]=c;}L->length=L->length+a;return 0;}/*CreateList*//*（4）---输出顺序表中的元素*/int PrintList_sq(Sqlist *L)int a;printf("输出数据:");for(a=0;a<L->length;a++)printf("%d ",L->list[a]);return 0;}/*PrintList*//*（5）---在顺序表的第i个位置之前插入新元素e*/int ListInsert_sq(Sqlist *L,int i,ElemType e){int a=L->length-1;for(;a>=i-1;a--)L->list[a+1]=L->list[a];L->list[i-1]=e;L->length+=1;return OK;}/*ListInsert*//*（6）---在顺序表中删除第i个元素，e返回删除的元素*/int ListDelete_sq(Sqlist *L,int i,ElemType *e){int a=i-1;*e=L->list[i-1];for(;a<L->length;a++)L->list[a]=L->list[a+1];L->length-=1;return OK;}/* ListDelete_sq *//*（7）---在顺序表中查找指定值元素，pos为返回其位置序号*/ int ListLocate(Sqlist *L,ElemType e,int *pos){int a,b=0;for(a=0;a<L->length;a++){if(e==L->list[a]){b=0;*pos=a+1;break;}elseb=1;}if(b==1)return 0;elsereturn OK;}/* ListLocate *//*定义菜单字符串数组*/int menu_select(){char *menu[]={"\n***************MENU******************\n"," 1. Create List\n", /*创建顺序表*/" 2. Get Element\n", /*查找顺序表中的元素*/" 3. Insert data\n", /*插入数据*/" 4. Delete data\n", /*删除数据*/" 0. Quit\n", /*退出*/"\n***************MENU******************\n"};char s[3]; /*以字符形式保存选择号*/int c,i; /*定义整形变量*/for (i=0;i<7;i++) /*输出主菜单数组*/printf("%s",menu[i]);do{printf("\nEnter you choice(0~4):"); /*在菜单窗口外显示提示信息*/ scanf("%s",s); /*输入选择项*/c=atoi(s); /*将输入的字符串转化为整形数*/}while (c<0||c>4); /*选择项不在0~4之间重输*/return c; /*返回选择项，主程序根据该数调用相应的函数*/ }/*主函数*/int main(){Sqlist sl;InitList_sq(&sl);int m,k;for (;;) /*无限循环*/{switch (menu_select()) /*调用主菜单函数，返回值整数作开关语句的条件*/{case 1:printf("\n1-Create Sqlist:\n");CreateList_sq(&sl);printf("\nPrint Sqlist:\n");PrintList_sq(&sl);break;case 2:printf("\n3-GetElem from Sqlist:\n");printf("please input search data:");scanf("%d",&k);int pos;if (!ListLocate(&sl,k,&pos))printf("Not found");else{printf("found the element, position is %d\n",pos);printf("\nPrint Sqlist:\n");PrintList_sq(&sl);}break;case 3:printf("\n4-Insert from Sqlist:\n");printf("\n input insert location and data:(location,data)\n"); scanf("%d,%d",&m,&k);if (ListInsert_sq(&sl,m,k)){printf("\nOK\n");printf("\nPrint Sqlist:\n");PrintList_sq(&sl);}elseprintf("\nERROR!");break;case 4:printf("\n5-Delete from Sqlist:\n");printf("\nplease input delete location\n");scanf("%d",&k);int deldata;if (ListDelete_sq(&sl,k,&deldata)){printf("\nOK\n");printf("\nDelete data is %d\n",deldata);printf("\nPrintSqlist:\n");PrintList_sq(&sl);}elseprintf("\nERROR!");break;case 0:exit(0); /*如菜单返回值为0程序结束*/ }}return 0;}(1)创建一个顺序表(2)查找元素位置（3）插入元素（4）删除元素2、按照要求完成程序exp2_2.c，实现单链表的相关操作。