实验一 线性表的基本操作实现及其应用
实验一 线性表的操作及应用
2、实验要求： (1) 给出程序设计的基本思想、原理和算法描述。 (2) 源程序给出注释。 (3) 记录程序的运行结果，并结合程序进行分析。
3、实验内容
约瑟夫问题的实现：设有n个人围坐在圆桌周围， 现从某个位置m（1≤m≤n）上的人开始报数，报数 到k的人就站出来。下一个人，即原来的第k+1个位 置上的人，又从1开始报数，再报数到k的人站出来。 依此重复下去，直到全部的人都站出来为止。试设 计一个程序求出出列序列。
6、测试数据
（1）围坐在圆桌周围的人数n=7，第一次开始报数人 的位置m=3，希望报数到第2个数的人出列，则出 列的顺序如下：4 6 1 3 7 5 2； （2）围坐在圆桌周围的人数n=13，第一次开始报数 人的位置m=5，希望报数到第6个数的人出列，则 出列的顺序如下：10 3 9 4 12 7 5 2 6 11 8 1 13； （3）围坐在圆桌周围的人数n=21，第一次开始报数 人的位置m=3，希望报数到第9个数的人出列，则 出列的顺序如下：11 20 8 18 7 19 10 2 15 9 4 1 21 3 6 14 12 13 5 16 17。
4、实验步骤
（1）理解循环链表的基本实验原理；
（2）仔细分析实验内容，给出其算法和流程图； （3）用C或C++语言实现该算法； （4）给出测试数据，并分析其结果； （5）在实验报告册上写出实验过程。
5、实验帮助
（1）这是一个使用循环链表的经典问题。因为要不断地出列， 采用链表的存储形式能更好地模拟出列的情况。 （2）可以建立一个不带头结点的循环链表，其中的n个人用n 个结点来表示。结点结构表示如下： Typedef int Elemtype; Typedef struct Cnode { Elemtype data; struct Cnode *next; }CNode; （3）在本实验中，每次找出需出列结点，要经过k次循环移动 定位指针，全部结点出列，需经过n个k次循环，因此，时 间复杂度为O（k*n）。
实验1线性表及其应用实验报告
实验1线性表及其应⽤实验报告暨南⼤学本科实验报告专⽤纸课程名称数据结构成绩评定实验项⽬名称线性表及其应⽤指导教师王晓明实验项⽬编号实验⼀实验项⽬类型综合性实验地点南海楼601 学⽣姓名朱芷漫学号2010051875学院信息科学技术学院系计算机专业计算机科学与技术实验时间2011年9⽉7⽇18:30午～9⽉7⽇20:30午温度℃湿度⼀、实验⽬的和要求实验⽬的：熟练掌握线性表基本操作的实现及应⽤实验要求：在上机前写出全部源程序完毕并调试完毕。
⼆、实验原理和主要内容1.建⽴4个元素的顺序表SqList={2，3，4，5}，实现顺序表的基本操作；在SqList={2,3,4,5}的元素4与5之间插⼊⼀个元素9，实现顺序表插⼊的基本操作；在SqList={2,3,4,9,5}中删除指定位置(i=3)上的元素，实现顺序表删除的操作。
2.利⽤顺序表完成⼀个班级的⼀个学期的课程的管理：能够增加、删除、修改学⽣的成绩记录。
三、主要仪器设备PC机，Windows XP操作平台，Visual C++四、调试分析学⽣课程管理系统的调试过程中发现⼀些错误，主要是参数设置的问题，经过修改，错误得到排除。
五、测试结果1.顺序表2.学⽣课程管理系统附录（源程序）1.顺序表的操作#include#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 10 #define LISTINCREMENT 2 typedef struct shunxubiao{ElemType *list;int size;int Maxsize;}SqList;int InitList_Sq(SqList &L) {// 构造⼀个空的线性表L。
1数据结构-实验报告一(线性表的基本操作)
实验一 线性表的基本操作及其应用一、实验目的1、帮助读者复习C++语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现。
4、掌握顺序表的存储结构形式及其描述和基本运算的实现。
5、熟练掌握动态链表结构及有关算法的设计二、实验内容求两个多项式的相加运算[问题描述]用单链表存储一元多项式，并实现两个多项式的相加运算。
[基本要求]（1）本程序需要基于线性表的基本操作来实现一元多项式的加法，也可以用数组实现。
；（2）两个多项式都有键盘输入相应的系数和指数[测试数据] 由学生任意指定。
三、源代码#include <stdio.h>#include <malloc.h>#define MAX 20 //多项式最多项数typedef struct //定义存放多项式的数组类型{double coef; //系数int exp; //指数} PolyArray[MAX];typedef struct pnode //定义单链表结点类型{double coef; //系数int exp; //指数struct pnode *next;} PolyNode;void DispPoly(PolyNode *L) //输出多项式{bool first=true; //first为true表示是第一项PolyNode *p=L->next;while (p!=NULL){if (first)first=false;else if (p->coef>0)printf("+");if (p->exp==0)printf("%g",p->coef);else if (p->exp==1)printf("%gx",p->coef);elseprintf("%gx^%d",p->coef,p->exp);p=p->next;}printf("\n");}void DestroyList(PolyNode *&L) //销毁单链表{PolyNode *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}void CreateListR(PolyNode *&L,PolyArray a,int n) //尾插法建表{PolyNode *s,*r;int i;L=(PolyNode *)malloc(sizeof(PolyNode)); //创建头结点L->next=NULL;r=L; //r始终指向终端结点,开始时指向头结点for (i=0;i<n;i++){s=(PolyNode *)malloc(sizeof(PolyNode));//创建新结点s->coef=a[i].coef;s->exp=a[i].exp;r->next=s; //将*s插入*r之后r=s;}r->next=NULL; //终端结点next域置为NULL}void Sort(PolyNode *&head) //按exp域递减排序{PolyNode *p=head->next,*q,*r;if (p!=NULL) //若原单链表中有一个或以上的数据结点{r=p->next; //r保存*p结点后继结点的指针 p->next=NULL; //构造只含一个数据结点的有序表 p=r;while (p!=NULL){r=p->next; //r保存*p结点后继结点的指针 q=head;while (q->next!=NULL && q->next->exp>p->exp)q=q->next; //在有序表中找插入*p的前驱结点*qp->next=q->next; //将*p插入到*q之后q->next=p;p=r;}}}void Add(PolyNode *ha,PolyNode *hb,PolyNode *&hc) //求两有序集合的并{PolyNode *pa=ha->next,*pb=hb->next,*s,*tc;double c;hc=(PolyNode *)malloc(sizeof(PolyNode)); //创建头结点tc=hc;while (pa!=NULL && pb!=NULL){if (pa->exp>pb->exp){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}else if (pa->exp<pb->exp){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pb->exp;s->coef=pb->coef;tc->next=s;tc=s;pb=pb->next;}else //pa->exp=pb->exp{c=pa->coef+pb->coef;if (c!=0) //系数之和不为0时创建新结点{s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=c;tc->next=s;tc=s;}pa=pa->next;pb=pb->next;}}if (pb!=NULL) pa=pb; //复制余下的结点while (pa!=NULL){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点 s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}tc->next=NULL;}void main(){PolyNode *ha,*hb,*hc;PolyArray a={{2.3,0},{-2.8,2},{5.6,3},{-10.9,7},{7.6,10}};PolyArray b={{-1.2,0},{8.6,1},{-13.9,3},{15.5,5},{5.6,9}};CreateListR(ha,a,5);CreateListR(hb,b,5);printf("原多项式A: ");DispPoly(ha);printf("原多项式B: ");DispPoly(hb);Sort(ha);Sort(hb);printf("有序多项式A: ");DispPoly(ha);printf("有序多项式B: ");DispPoly(hb);Add(ha,hb,hc);printf("多项式相加: ");DispPoly(hc);DestroyList(ha);DestroyList(hb);DestroyList(hc);}四、测试结果五、心得体会两个简单的的多项式用相加，编程却需要线性表各种用法显得很复杂。
实验一 线性表的操作及应用
{
p=p->next;
++j;
}
if ( !p||j>i )
{
printf("参数 i 错或单链表不存在");
return (NULL);
} /*第i个结点不存在*/
return (p);
}
int Insert_LinkList( LinkList H, int i, DataType x)
scanf("%d%d",&n,&m);
for(j=0;j<n;j++)
{
printf("请输入要插入的第%d个元素：",j+1);
scanf("%d",&x);
y=Insert_LinkList( L,m,x);
if(y==1)
{
y=0;
printf("成功插入第%d个元素。\n",j+1);
}
}
代码：
#include <stdio.h>
#include <malloc.h>
typedef int DataType;
typedef struct node{
DataType data; /*每个元素数据信息*/
struct node *next; /*存放后继元素的地址*/
} LNode, *LinkList;
y=0;
/*（将单链表逆置，并输出逆置后单链表中的元素）*/
InvertList(L);
y=Print_LinkList(L);
数据结构实验线性表基本操作
学《数据结构》课程实验报告实验名称：线性表基本操作的实现实验室(中心)：学生信息：专业班级：指导教师：实验完成时间： 2016实验一线性表基本操作的实现一、实验目的1.熟悉C语言的上机环境，进一步掌握C语言的结构特点。
2.掌握线性表的顺序存储结构的定义及C语言实现。
3.掌握线性表的链式存储结构——单链表的定义及C语言实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
二、实验内容及要求1.顺序线性表的建立、插入、删除及合并。
2.链式线性表的建立、插入、删除及连接。
三、实验设备及软件计算机、Microsoft Visual C++ 6.0软件四、设计方案（算法设计）㈠采用的数据结构本程序顺序表的数据逻辑结构为线性结构，存储结构为顺序存储；链表的数据逻辑结构依然为线性结构，存储结构为链式结构。
㈡设计的主要思路1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度，顺序表的长度和元素由用户输入；2.利用前面建立的顺序表，对顺序表进行插入、删除及合并操作；3.建立一个带头结点的单链表，结点的值域为整型数据，链表的元素由用户输入；4.对前面建立的链表进行插入、删除及连个链表的连接操作；㈢算法描述1、顺序表void Init(sqlist &);//初始化顺序表BOOL Inse(sqlist &,int,char); //在线性表中插入元素BOOL del(sqlist&,int,char &); //在线性表中删除元素int Loc(sqlist,char); //在线性表中定位元素void print(sqlist); //输出顺序表void combine( sqlist & , sqlist & , sqlist &);//两个线性表的合并2、链表void CreaL(LinkList &,int); //生成一个单链表BOOL LInsert(LinkList &,int,char); //在单链表中插入一个元素BOOL LDele(LinkList &,int,char &); //在单链表中删除一个元素BOOL LFind_key(LinkList,char,int &); //按关键字查找一个元素BOOL LFind_order(LinkList,char &,int); //按序号查找一个元素void LPrint(LinkList); //显示单链表所有元素void LUnion(LinkList &,LinkList &,LinkList &,int); //两个链表的连接五、程序代码1、顺序表#include <stdio.h>#include <conio.h>#define Max 116enum BOOL{False,True};typedef struct{char elem[Max]; //线性表int last; //last指示当前线性表的长度}sqlist;void Init(sqlist &);BOOL Inse(sqlist &,int,char); //在线性表中插入元素BOOL del(sqlist&,int,char &); //在线性表中删除元素int Loc(sqlist,char); //在线性表中定位元素void print(sqlist);void combine( sqlist & , sqlist & , sqlist &);void main(){sqlist L1;sqlist L2;sqlist L3;int loc,S=1;char j,ch;BOOL temp;printf("本程序用来实现顺序结构的线性表。
线性表的基本操作
实验一：线性表的基本操作一、实验目的：（1）掌握线性表的基本运算，熟悉对线性表的一些基本操作和具体的函数定义。
（2）掌握顺序存储的概念，学会定义线性表的顺序存储类型。
（3）熟悉C语言程序的基本结构，掌握程序中的用户头文件、实现文件和主文件之间的相互联系及各自的作用。
（4）熟悉C语言环境的使用以及多文件程序的输入、编辑、调试和运行的全过程。
（5）加深对顺序存储结构的理解，逐步培养解决实际问题的能力。
二、实验要求：（1）熟练掌握线性表的存储结构及其操作。
（2）理解实训案例的算法，掌握线性表在实际中的运用。
（3）将上机程序全部调试通过。
（4）独立完成一个至两个实训项目，保存程序运行结果，并结合程序进行分析。
三、实验内容：(1)线性表的基本操作。
第一步：定义线性表的存储结构。
第二步：编写线性表的具体函数定义。
第三步：使用定义的线性表并调用线性表的一些操作，实现具体运算。
1）初始化线性表，2）创建一个线性表。
3）在线性表中查找指定的元素。
4）在线性表中插入指定的元素。
5）在线性表中删除指定的元素。
6）输出线性表。
四、源代码：// sqList.h#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2#define ML 10typedef int ElemT ype;typedef struct sqList{ElemT ype list[ML];int size;int MAXSIZE;//sqList.c#include <stdio.h>#include <stdlib.h>//#include <alloc.h>//#include "sqList.h"sqList *Init_List(sqList *L,int ms){L=(sqList *)malloc(ms*sizeof(sqList));if(!L){printf("Memory allocation failure!\n");exit(OVERFLOW);}elseL->size=0;L->MAXSIZE=ms;return L;}void Disp_List(sqList *L){int i;for(i=0;i<L->size;i++)printf("%d\t",L->list[i]);printf("\n");}int LocateElem_List(sqList *L,ElemT ype x){int i=0;for(i=0;i<=L->size;i++)if(L->list[i]==x)return i;if(i>L->size) return -1;}int Insert_List(sqList *L,ElemT ype x,int mark){int i=1;if(L->size>=L->MAXSIZE)return -1;if(mark>0){for(i=L->size+1;i>=mark;i--)L->list[i+1]=L->list[i];L->list[i]=x;else if(mark<0)L->list[L->size]=x;L->size++;return FALSE;}int Delete_List1(sqList *L,int item){int i,j;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(j=i+1;j<L->size-1;j++)L->list[j]=L->list[j+1];L->size--;return i;}return FALSE;}int Delete_List2(sqList *L,int mark){int i,item;if(mark>0){item=L->list[mark];for(i=mark+1;i<L->size-1;i++)L->list[i]=L->list[i+1];L->size--;return i;}return FALSE;}//sqListmain.c//#include"sqList.c"void main(){int p,n;ElemT ype x=0;sqList a,*b;b=Init_List(&a,ML);printf("listaddr=%p\tsize=%d\tMaxSize=%d\n",b->list,b->size,b->MAXSIZE); while(1)printf("\n请输入元素值,0为结束输入: ");scanf("%d",&x);if(!x)break;printf("请输入插入位置: ");scanf("%d",&p);Insert_List(b,x,p);printf("线性表为: \n");Disp_List(b);}while(1){printf("请输入查找元素值，输入0结束查找操作：");scanf("%d",&x);if(!x) break;n=LocateElem_List(b,x);if(n<0) printf("没找到\n");elseprintf("有符合条件的元素，位置为：%d\n",n+1); }while(1){printf("请输入删除元素值，输入0结束查找操作：");scanf("%d",&x);if(!x)break;n=Delete_List1(b,x);if(n<0)printf("没找到\n");else{printf("删除元素成功,线性表为: ");Disp_List(b);}}while(1){printf("请输入删除元素位置,输入0结束查找操作:"); scanf("%d",&p);if(!p) break;n=Delete_List2(b,p);if(p<0) printf("位置越界\n");else{printf("线性表为: ");Disp_List(b);}}五、测试结果：六、心得体会：通过这次写实验报告，我深切的理解了这门课的本质。
线性表的基本操作及其应用
线性表的基本操作及其应用一、实验目的1、帮助学生复习C++语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现，其中以熟悉链表的操作为侧重点。
二、实验内容单链表的基本操作[问题描述]实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。
[基本要求]（1）依次从键盘读入数据，建立带头结点的单链表；（2）输出单链表中的数据元素（3）求单链表的长度；（4）根据指定条件能够取元素和修改元素；（5）实现在指定位置插入和删除元素的功能。
三、概要设计各操作的具体函数实现：1.用尾插法建立带头结点的链表可任意输入元素（char 型）,void CreatList(LinkList &L){//LinkList p;L=(LinkList)malloc(sizeof(LNode));int n=0,j=0;L->next=NULL;cout<<"请输入结点个数:";cin>>n;for(int i=n;i>0;i--){LinkList p;p=(LinkList)malloc(sizeof(LNode));cout<<"请输入一个节点数据:"<<endl;cin>>p->data;p->next=L->next;L->next=p;Length++;//每增加一个数据，Length加一}}2.清空链表分析链表为空时，输出为空；当链表不为空时，清空链表，并输出原来的链表已经被清空!的字样告诉操作者，链表已为空了int ClearList(LinkList &L){if(L->next==NULL){cout<<"链表为空！";}else {{LinkList p,q;p=L->next;while(p){q=p;p=p->next;-- Length;delete q;}}cout<<"原来的链表已经被清空!!"<<endl;}return OK;}3.求链表的长度在建立链表是已经用Length着个全局变量记载建立的结点的个数，即链表的长度用cout<<Length就可以得到链表的长度：int Listlength(LinkList L){cout<<"链表长度为："<<Length<<endl;return Length;}4.链表元素的展示用函数DisplayList(LinkList L)实现，首先判断链表是否为空，当链表不为空时，在从第一个元素找到并输出，主要步骤为：LinkList p;p=L->next;cout<<"链表中的数据依次为:"<<'\t';while(p){cout<<p->data<<" ";p=p->next;}5.从链表中查找元素用函数GetElem_L(LinkList L)来实现该功能。
实验一--线性表基本操作的编程实现
实验一--线性表基本操作的编程实现实验一线性表基本操作的编程实现【实验目的】线性表基本操作的编程实现要求：线性表基本操作的编程实现（2学时，验证型），掌握线性表的建立、遍历、插入、删除等基本操作的编程实现，也可以进一步编程实现查找、逆序、排序等操作，存储结构可以在顺序结构或链表结构中任选，可以完成部分主要功能，也可以用菜单进行管理完成大部分功能。
还鼓励学生利用基本操作进行一些更实际的应用型程序设计。
【实验性质】验证性实验（学时数：2H）【实验内容】把线性表的顺序存储和链表存储的数据插入、删除运算其中某项进行程序实现。
建议实现键盘输入数据以实现程序的通用性。
为了体现功能的正常性，至少要编制遍历数据的函数。
【注意事项】1.开发语言：使用C。
2.可以自己增加其他功能。
【思考问题】1.线性表的顺序存储和链表存储的差异？优缺点分析？2.那些操作引发了数据的移动？3.算法的时间效率是如何体现的？4.链表的指针是如何后移的？如何加强程序的健壮性？【参考代码】（以下内容，学生任意选择一个完成即可）（一）利用顺序表完成一个班级学生课程成绩的简单管理1、预定义以及顺序表结构类型的定义(1) #include<stdio.h>#include<conio.h>#define ListSize 100 //根据需要自己设定一个班级能够容纳的最大学生数(2) typedef struct stu{int num; //学生的学号char name[10]; //学生的姓名float physics; //物理成绩float math; //数学成绩float english; //英语成绩}STUDENT; //存放单个学生信息的结构体类型typedef struct List{STUDENT stu[ListSize]; //存放学生的数组定义，静态分配空间int length; //记录班级实际学生个数}LIST; //存放班级学生信息的顺序表类型2、建立班级的学生信息void listcreate(LIST *Li,int m) //m为该班级的实际人数{int i;Li->length=0;for(i=1; ;i++) //输入m个学生的所有信息{printf("请输入第%d位学生的信息:\n",i);printf("学号=");scanf("%d",&Li->stu[i].num); //输入第i个学生的学号printf("姓名=");scanf("%s",&Li->stu[i].name); //输入第i个学生的姓名printf("物理成绩=");scanf("%f",&Li->stu[i].physics); //输入第i 个学生的物理成绩printf("数学成绩=");scanf("%f",&Li->stu[i].math); //输入第i个学生的数学成绩printf("英语成绩=");scanf("%f",&Li->stu[i].english); //输入第i 个学生的英语成绩; //学生人数加1}}3、插入一个学生信息int listinsert(LIST *Li,int i) //将学生插入到班级Li的第i个位置。
_线性表的基本操作实现及其应用
三、实验步骤㈠、数据结构与核心算法的设计描述1、单链表的结点类型定义/* 定义DataType为int类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct Lnode{ int data;struct LNode *next;} LNode,*LinkList;2、初始化单链表LinkList LinkList_L(LinkList &L){ L 为带头结点的单链表的头指针L=(LinkList)malloc(sizeof(LNode)); // 分配存储空间L->next=NULL; //将链表置空return L;}3、用尾插法创建单链表void CreateList_L(LinkList &L,int n){ L 为带头结点的单链表的头指针，n为创建的链的结点个数int i;LNode *p;//定义结点指针L=(LinkList)malloc(sizeof(LNode));//为链表分配空间L->next=NULL;cout<<"为链表创建元素，请输入元素："<<endl;for(i=n;i>0;--i){ p=(LinkList)malloc(sizeof(LNode));//令P指向头结点 cin>>p->data; // 输入第一个元素p->next=L->next; //指向下一个地址L->next=p;}if(n) cout<<"链表已成功创建 !"<<endl;else cout<<"创建一个空链表成功!"<<endl;}4、求单链表的长度int ListLength_L( LinkList &L ){ L 为带头结点的单链表的头指针LNode *p; int NodeNum;NodeNum = 0;p = L->next; // 不带头结点的统计p = L;while( p ) // 查找X p&&p->data!=x { NodeNum++; //k++p = p->next;}return NodeNum; //输出累加后的值就是个数}5、遍历单链表void Bianli_L(LinkList &L,int NodeNum){ L 为带头结点的单链表的头指针，NodeNum为元素个数LNode *p=L;int i; //定义结点P并指向头结点cout<<"链表如下：";for(i=0;i<NodeNum;i++){ p=p->next; //令P指向下个结点cout<<p->data<<" ";//从第一个结点输出元素}cout<<endl;}6、向单链表中插入元素int ListInsert_L(LinkList &L,int i,int e){ // L 为带头结点的单链表的头指针，本算法// 在链表中第i 个结点之前插入新的元素 eLNode *p=L; //定义结点P并指向头结点int j=0;while(p&&j<i-1) //从第一个元素开始查找直到最后一个{ p=p->next; //查找第i位置并赋给P++j;}if(!p||j>i-1) //如果查到最后仍不存在或结点i输入错误{ cout<<"Errer! The location is illegal!"<<endl;//提示错误return (ERROR);} LNode *s; //定义结点Ss=(LinkList)malloc(sizeof(LNode));//为S分配地址 s->data=e;//将e的值赋给Ss->next=p->next;//s插入P前p->next=s;return (OK);}7、从单链表表中查找与给定元素值相同的元素在链表中的位置int SearchE_L(LinkList &L ,int e){ // L 为带头结点的单链表的头指针,e为要查找的元素的值 LNode *p;int a=1; //定义结点pp=L->next; //p指向链表第一个元素while(p&&p->data!=e){p=p->next;a++;}//从链表中的第一个元素往后查找指定元素if(p) return a; //如果找到返回其值elsecout<<"要查找的元素不存在!"<<endl;//否则此元素不存在 } 8、从单链表表中查找元素int GetElem_L(LinkList L,int i,int &e){ //L是带头结点的链表的头指针，返回第 i 个元素，其值为eLNode *p; //定义结点pint j=1;p=L->next; //令p指向头结点while(p&&j<i) //查找第i个位置{p=p->next;++j;}if(!p||j>i) //找不到p{ cout<<"第"<<i<<" 个结点不存在 !"<<endl;}e=p->data; //如果存在，返回其值return (e);}9、从单链表中删除元素int ListDelete_L(LinkList &L,int i,int &e){ //L是带头结点的链表的头指针，返回第 i 个元素，其值为eLNode *p,*q; //定义结点p ,qint j=0;p=L;//令p指向头结点while(p->next&&j<i-1)//查找第i个位置{ p=p->next;++j;}if(!p||j>i-1) //找不到p{ cout<<"第 "<<i<<" 个元素不存在!"<<endl;return(0);}q=p->next; //将P的地址赋给qp->next=q->next; // 删除结点i e=q->data; //将i的值赋给efree(q); //释放 i的空间return (e); //返回其值}㈡、函数调用及主函数设计㈢程序调试及运行结果分析㈣实验总结这次试验把二章的内容通过实际的操作有了更进一步的了解，对链表的各种功能的运用由单纯的理论知识变成了理解，但还不能够说完全的掌握了，同时也对你以前的目录等知识的运用进行了回忆与巩固。
实验一线性表操作实验报告
实验一_线性表操作_实验报告实验一：线性表操作一、实验目的1.理解线性表的基本概念和特点。
2.掌握线性表的基本操作，包括插入、删除、查找等。
3.通过实验，提高动手能力和解决问题的能力。
二、实验原理线性表是一种较为常见的数据结构，它包含零个或多个数据元素，相邻元素之间有前后关系。
线性表具有以下特点：1.元素之间一对一的顺序关系。
2.除第一个元素外，每个元素都有一个直接前驱。
3.除最后一个元素外，每个元素都有一个直接后继。
常见的线性表有数组、链表等。
本实验主要针对链表进行操作。
三、实验步骤1.创建链表：首先创建一个链表，并给链表添加若干个节点。
节点包括数据域和指针域，数据域存储数据，指针域指向下一个节点。
2.插入节点：在链表中插入一个新的节点，可以选择在链表的头部、尾部或中间插入。
3.删除节点：删除链表中的一个指定节点。
4.查找节点：在链表中查找一个指定数据的节点，并返回该节点的位置。
5.遍历链表：从头节点开始，依次访问每个节点的数据。
四、实验结果与分析1.创建链表结果：我们成功地创建了一个链表，每个节点都有数据域和指针域，数据域存储数据，指针域指向下一个节点。
2.插入节点结果：我们成功地在链表的头部、尾部和中间插入了新的节点。
插入操作的时间复杂度为O(1)，因为我们只需要修改指针域即可。
3.删除节点结果：我们成功地删除了链表中的一个指定节点。
删除操作的时间复杂度为O(n)，因为我们可能需要遍历整个链表才能找到要删除的节点。
4.查找节点结果：我们成功地在链表中查找了一个指定数据的节点，并返回了该节点的位置。
查找操作的时间复杂度为O(n)，因为我们可能需要遍历整个链表才能找到要查找的节点。
5.遍历链表结果：我们成功地遍历了整个链表，并访问了每个节点的数据。
遍历操作的时间复杂度为O(n)，因为我们可能需要遍历整个链表。
通过本次实验，我们更加深入地理解了线性表的基本概念和特点，掌握了线性表的基本操作，包括插入、删除、查找等。
一线性表实现与应用
实验一线性表实现与应用一、实验目的1．掌握线性表的顺序存储和链接存储结构。
2．了解线性表的应用。
3．分析顺序线性表与链接线性表的差异。
二、实验内容1．利用顺序线性表实现集合运算ＡＵＢ。
2．利用向前链表实现集合运算（A-B）U（B-A）。
三、实验程序说明1．假设集合Ａ和Ｂ的元素都是整数，并利用两个线性表la和lb分别存放集合Ａ和Ｂ的成员。
现依次取出lb中的每个元素，按其值查找线性表la，若la中不存在该元素，则将它插入到la中去，最后线性表la就存放了集合ＡＵＢ的元素。
2．（A-B）U（B-A）是由属于集合A或集合B，但又不同时属于A和B的全部元素组成。
我们可以先分别建立由集合A和集合B的元素构成的链表la和lb，然后对lb中每一个元素进行如下处理：在链表la中查找是否有相同元素，若有相同元素，则从la 中删除该元素；若没有相同元素，则将此元素插入la中。
最后，链表la就存放了（A-B）U（B-A）的全部元素。
四、参考程序1．/* 求集合运算ＡＵＢ */#define MAX 100typedef struct{char element[MAX];int num;} LIST;void create(LIST *list){int i,n;printf("Enter the number of list:");scanf("%d",&n);for(i=0;i<n;i++){printf("Enter element[%d]:",i+1);scanf("%d",&(list->element[i]));}list->num=n;}int insert(LIST *list, int m, int x){int i,n;n=list->num;if(n >= MAX){printf("The list is overflow! \n");return(-1);}else if(m < 1 || m > n+1){printf("Error! \n");return(-2);}else{for(i=n-1; i>=m-1; i--)list->element[i+1]=list->element[i];list->element[m-1]=x;list->num=n+1;return(0);}}int locate(LIST *list, int x){int i;for(i=0; i<=list->num-1; i++)if(list->element[i] == x)return(i+1);return(0);}void print_list(LIST *list){int i,n;n=list->num;if(n == 0)printf("The list is empty.\n");else{for(i=0; i<=n-1; i++)printf("%d\t",list->element[i]);printf("\n");}}main(){LIST *la,*lb;int i,x;create(la);printf("SET A:\n");print_list(la);create(lb);printf("SET B:\n");print_list(lb);for(i=0;i<lb->num;i++){x=lb->element[i];if(locate(la,x) == 0)insert(la,la->num+1,x);}printf("SET (AUB):\n");print_list(la);}2．/* 集合运算（A-B）U（B-A）*/#include <stdio.h>typedef struct node{char info;struct node *link;} NODE;NODE *initial(),*process();main(){NODE *la,*lb,*ptr,*p1,*p2;printf("\nEnter the elements of Set A:");la=initial();printf("Set A:\n");travel(la);printf("\nEnter the elements of Set B:");lb=initial();printf("Set B:\n");travel(lb);la=process(la,lb);printf("\nSet (A-B)U(B-A):\n");travel(la);}NODE *initial(){NODE *head,*p1,*p2;char ch;head=(NODE *)malloc(sizeof(NODE));head->link=NULL;p1=head;while((ch=getchar()) != '\n'){p2=(NODE *)malloc(sizeof(NODE));p2->info=ch;p2->link=NULL;p1->link=p2;p1=p2;}return(head);}travel(NODE *ptr){ptr=ptr->link;while(ptr != NULL){printf("%c ",ptr->info);ptr=ptr->link;}printf("\n");}NODE *process(NODE *la,NODE *lb){NODE *ptr,*p1,*p2;int found=0;ptr=lb->link;while(ptr != NULL){p1=la->link;p2=la;while(p1 != NULL && ! found)if(p1->info == ptr->info)found=1;else{p2=p1;p1=p1->link;}if(found){p2->link=p1->link;free(p1);found=0;}else{p1=(NODE *)malloc(sizeof(NODE)); p1->info=ptr->info;p1->link=NULL;p2->link=p1;}ptr=ptr->link;}return(la);}/* 集合运算（A-B）U（B-A）*/#include <stdio.h>typedef struct node{char info;struct node *link;} NODE;NODE *initial(),*process();main(){NODE *la,*lb,*ptr,*p1,*p2;printf("\nEnter the elements of Set A:");la=initial();printf("Set A:\n");travel(la);printf("\nEnter the elements of Set B:");lb=initial();printf("Set B:\n");travel(lb);la=process(la,lb);printf("\nSet (A-B)U(B-A):\n");travel(la);}NODE *initial(){NODE *head,*p1,*p2;char ch;head=(NODE *)malloc(sizeof(NODE));head->link=NULL;p1=head;while((ch=getchar()) != '\n'){p2=(NODE *)malloc(sizeof(NODE));p2->info=ch;p2->link=NULL;p1->link=p2;p1=p2;}return(head);}travel(NODE *ptr){ptr=ptr->link;while(ptr != NULL){printf("%c ",ptr->info);ptr=ptr->link;}printf("\n");}NODE *process(NODE *la,NODE *lb){NODE *ptr,*p1,*p2;int found=0;ptr=lb->link;while(ptr != NULL){p1=la->link;p2=la;while(p1 != NULL && ! found)if(p1->info == ptr->info)found=1;else{p2=p1;p1=p1->link;}if(found){p2->link=p1->link;free(p1);found=0;}else{p1=(NODE *)malloc(sizeof(NODE));p1->info=ptr->info;p1->link=NULL;p2->link=p1;}ptr=ptr->link;}return(la);}五、实验步骤1．参考实验程序上机调试。
实验一线性表地基本操作实现及其应用
实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现。
2、会用线性链表解决简单的实际问题。
二、实验内容题目一链表基本操作该程序的功能是实现单链表的定义和操作。
该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。
其中，程序中的单链表（带头结点）结点为结构类型，结点值为整型。
单链表操作的选择以菜单形式出现，如下所示：please input the operation：1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满6.遍历链表（设为输出元素）7.从链表中查找元素8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。
实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现。
2、会用线性链表解决简单的实际问题。
二、实验内容题目一链表基本操作该程序的功能是实现单链表的定义和操作。
该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。
其中，程序中的单链表（带头结点）结点为结构类型，结点值为整型。
单链表操作的选择以菜单形式出现，如下所示：please input the operation：1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满6.遍历链表（设为输出元素）7.从链表中查找元素8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。
题目一链表基本操作一、数据结构与核心算法的设计描述1、单链表的最大长度#define MAXSIZE 1002、单链表的结点类型定义/* 定义elemtype为int类型 */typedef int elemtype;/* 单链表的结点类型 */typedef struct STD{elemtype elem;STD *next;}list, * linklist;3、初始化单链表/* 函数功能：对链表进行初始化参数：链表(linklist L)成功初始化返回1,否则返回0 */ int init(linklist &L){L=(linklist)malloc(sizeof(list));//头结点申请内存。
第一次实验 线性表的实现及其应用
typedef Struct
{ DataType data[MAXNUM];
int
last; //存放线性表中最后一个元素在数组data[ ]中的下标 注意：顺序表的类型定义 可存储在seqlist.h中。
} SeqList;
二、关键技术分析
2.顺序表的空间申请
在教材第6页中的“臵空表”的程序有错， 缺少了申请存储空间的语句，故完整程 序应该为：
Void SeqLSetNull(SeqList *l) { l=(SeqList*) malloc(sizeof(SeqList)); l->last= -1; }
注意：教材第6页至第8页中的算法 ①~⑧给出了线性表在顺序表存储 结构下的所有基本操作的实现算法， 可存储在seqlist.cpp中。
数据结构实验（C语言版）
第一次实验 线性表的实现及其应用
一、实验内容
1.用C语言实现线性表的存储结构 （顺序表或链表，任选其中之一）； 2.实现线性表所有基本操作的有关 算法； 3.利用线性表解决某一实际问题（实 现学生成绩管理系统；实现集合的 交运算和并运算）。
二、关键技术分析
1.顺序表的类型定义
二、关键技术分析
6.实现学生成绩管理系统
用一个带头结点的杂，导致对单链 表的输入、删除、插入等操作较为复杂，不能直接使 用教材2.1节中实现的单链表来表示线性表。必须重 新设计线性表的结点node(类型名为LinkList，教材第 19页）,并针对该线性表设计所需的全部操作（如建 立、插入、删除、输出及主函数模块）的算法。
二、关键技术分析
6.实现学生成绩管理系统
实验1 线性表的基本操作
实验一线性表的基本操作一、实验目的（1）掌握线性表顺序存储和链式存储的方法及基本运算的实现。
（2）掌握将算法在VC++6.0语言环境下实现的过程。
二、实验准备（1）复习线性表的定义，掌握顺序存储、链式存储的方法及操作。
（2）复习C语言中指针与结构体的概念、定义方式。
（3）掌握链表的C语言的实现。
（4）实验的计算机中安装了Microsoft VC++ 6.0。
三、实验内容顺序表1）首先创建一个顺序表：从键盘读入一组整数（长度小于等于20），按输入顺序放入顺序表，输入以－1结束（注意－1不放到顺序表内）；将创建好的顺序表元素依次输出到屏幕上。
2）在已创建好的顺序表中插入一个元素：从键盘读入需插入的元素值和插入位置，调用插入函数完成插入操作；然后将顺序表元素依次输出到屏幕上。
3）在已创建好的顺序表中删除一个元素：从键盘读入欲删除的元素位置（序号），调用删除函数完成删除操作；然后将顺序表元素依次输出到屏幕上。
算法提示：➢需求分析：1.功能（1）建立一顺序表（2）显示顺序表中每个元素（3）在上述的顺序表中的指定位置插入指定的元素，并输出顺序表中所有数据。
（4）在上述的顺序表中的指定位置删除指定的元素，并输出顺序表中所有数据。
2．输入要求从键盘输入顺序表中所有数据，输入以－1结束（注意－1不放到顺序表内）；需插入的数据元素的位置、值；要删除的数据元素的位置（序号）。
3. 测试数据顺序表中所有数据：15，26，58，27，9插入的数据元素的位置、值：1，28；6，28；0，28要删除的数据元素的位置：3➢概要设计：1.数据结构：提示：相关常量和顺序表数据类型定义#define MAXNUM 20#define true 1#define false 0typedef struct{int data[MAXNUM];int length;}list_type;2．模块划分：a)建立顺序表的createlist函数；b)显示输出顺序中每个结点的数据的showlist函数；c)insertlist函数：插入函数。
实验一 线性表的基本操作及其应用
实验一线性表的基本操作及其应用一、实验目的1、帮助读者复习C语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现，其中以熟悉链表的操作为侧重点。
二、实验内容本次实验提供3个题目，每个题目都标有难度系数，*越多难度越大，学生可以根据自己的情况任选一个！题目一：单链表的基本操作（*）[问题描述]实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。
[基本要求]（1）依次从键盘读入数据，建立带头结点的单链表；（2）输出单链表中的数据元素（3）求单链表的长度；（4）根据指定条件能够取元素和修改元素；（5）实现在指定位置插入和删除元素的功能。
[测试数据]由学生任意指定。
题目二：约瑟夫环（**）[问题描述]约瑟夫（Joseph）问题的一种描述是：编号为1,2,…,n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。
一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。
报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。
试设计一个程序求出出列顺序。
[基本要求]利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。
[测试数据]由学生任意指定。
如：m的初值为20；n的值为7；密码：3，1，7，2，4，8，4；（正确的输出结果应为6，1，4，7，2，3，5）。
(报告上要求写出多批数据测试结果)[实现提示]程序运行后首先要求用户输入初始报数上限值m，人数n,(设n≤30)。
然后输入各人的密码。
[选作内容]向上述程序中添加在顺序结构上实现的部分。
题目三：多项式的表示及相加（***）[问题描述]设计一个算法，以实现一元稀疏多项式的加法运算。
[基本要求]（1）输入并建立多项式；（2）输出多项式，输出形式为整数序列：n，c1，e1，c2，e2，……，cn，en，其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列；（3）多项式a和b相加，建立多项式a+b。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现。
2、会用线性链表解决简单的实际问题。
二、实验内容题目一、该程序的功能是实现单链表的定义和操作。
该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。
其中，程序中的单链表（带头结点）结点为结构类型，结点值为整型。
单链表操作的选择以菜单形式出现，如下所示：please input the operation：1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满6.遍历链表（设为输出元素）7.从链表中查找元素8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。
其中黑体部分必做题目二、约瑟夫环问题：设编号为1，2，3，……，n的n(n>0)个人按顺时针方向围坐一圈，每个人持有一个正整数密码。
开始时任选一个正整数做为报数上限m，从第一个人开始顺时针方向自1起顺序报数，报到m时停止报数，报m的人出列，将他的密码作为新的m值，从他的下一个人开始重新从1报数。
如此下去，直到所有人全部出列为止。
令n最大值取30。
要求设计一个程序模拟此过程，求出出列编号序列。
struct node(一)1．进入选择界面后，先选择7，进行插入：2.选择4，进行遍历，结果为：3.选择2，得出当前链表长度.4.选择3，得出当前链表为.5.选择分别选择5、6进行测试.6.选择8，分别按位置和元素值删除.7.选择9，或非1-8的字符，程序结束.(二) 实验总结通过这次实验，我对线性链表有了更深的理解，深入明白了线性存储结构与链式存储结构在内存存储的不同特点，同时我还学会了用这些知识实际解决一些问题，能够更加熟练地将算法转化为实际程序。
同时，在写程序和调试程序的过程中，学会了一些书写技巧和调试技巧，这对于自己能在短时间高效的写出正确地程序有很大作用。
四、主要算法流程图及程序清单 1. 主要算法流程图：(1) 从单链表表中查找与给定元素值相同的元素在链表中的位置p=p->nextp&&!(p->data==xtrue调用函数，传入参数L ，xp=L->next2.程序清单：#include<iostream> using namespace std; #include<>#include<>/* 预处理命令 */#define OK 1;#define ERROR 0;#define OVERFLOW -1;/* 单链表的结点类型 */typedef struct LNode{int data;struct LNode *next;}LNode,*LinkedList;/*初始化单链表*/LinkedList LinkedListInit(){空"<<endl;cout<<"\t\t\t"<<"2.求链表长度"<<endl;cout<<"\t\t\t"<<"3.检查链表是否为空"<<endl;cout<<"\t\t\t"<<"4.遍历链表"<<endl;cout<<"\t\t\t"<<"5.从链表中查找元素 "<<endl;cout<<"\t\t\t"<<"6.从链表中查找与给定元素值相同的元素在表中的位置"<<endl;cout<<"\t\t\t"<<"7.向链表中插入元素"<<endl;cout<<"\t\t\t"<<"8.从链表中删除元素"<<endl;cout<<"\t\t\t"<<"9.退出"<<endl;}/*主函数*/int main(){链表长度case 2:{cout<<"\t\t\t链表长度为："<<LinkedListLength(L)<<endl;getch();}break;查链表是否为空case 3:{if (!LinkedListEmpty(L)){cout<<"\t\t\t链表不为空！"<<endl;}else{cout<<"\t\t\t链表为空！"<<endl;}getch();}break;历链表case 4:{LinkedListTraverse(L);getch();}break;链表中查找元素case 5:{cout<<"\t\t\t请输入要查询的位置i：";int j;cin>>j;if (LinkedListGet(L,j)){cout<<"\t\t\t位置i的元素值为："<<LinkedListGet(L,j)->data<<endl;}else{cout<<"\t\t\ti大于链表长度！"<<endl;}getch();}break;链表中查找与给定元素值相同的元素在表中的位置case 6:{cout<<"\t\t\t请输入要查找的元素值：";int b;cin>>b;if (LinkedListGet1(L,b)){cout<<"\t\t\t要查找的元素值位置为："<<LinkedListGet1(L,b)<<endl;cout<<"\t\t\t要查找的元素值内存地址为："<<LinkedListLocate(L,b)<<endl;}else{cout<<"\t\t\t该值不存在！"<<endl;}getch();}break;链表中插入元素case 7:{cout<<"\t\t\t请输入要插入的值：";int x; cin>>x;cout<<"\t\t\t请输入要插入的位置：";int k; cin>>k;if(LinkedListInsert(L,k,x)){cout<<"\t\t\t插入成功！"<<endl;}else{cout<<"\t\t\t插入失败！"<<endl;}getch();}break;链表中删除元素case 8:{cout<<"\t\t\t1.按位置删除"<<endl;cout<<"\t\t\t2.按元素删除"<<endl;int d;cout<<"\t\t请选择：";cin>>d;switch(d){case 1:{cout<<"\t\t\t请输入删除位置：";cin>>d;int y;if (LinkedListDel(L,d,y)){cout<<"\t\t\t"<<y<<"被删除！"<<endl;}else{cout<<"\t\t\t删除失败！"<<endl;}}break;case 2:{cout<<"\t\t\t请输入删除元素：";int y;cin>>y;if (LinkedListDel(L,y)){cout<<"\t\t\t"<<y<<"被删除！"<<endl;}else{cout<<"\t\t\t删除失败！"<<endl;}}}getch();}break;}}return 1;}题二约瑟夫环问题算法、思想为了解决这一问题，可以先定义一个长度为30（人数）的数组作为线性存储结构，并把该数组看成是一个首尾相接的环形结构，那么每次报m的人，就要在该数组的相应位置做一个删除标记，该单元以后就不再作为计数单元。
这样做不仅算法较复杂，而且效率低，还要移动大量的元素。
用单循环链表来解决这一问题，实现的方法相对要简单得的多。
首先定义链表结点，单循环链表的结点结构与一般单链表的结点结构完全相同，只是数据域用一个整数来表示位置；然后将它们组成一个具有n个结点的单循环链表。
接下来从位置为1的结点开始数，数到第m个结点，就将此结点从循环链表中删去，然后再从删去结点的下一个结点开始数起，数到第m个结点，再将其删去，如此进行下去，直至全部删去为止。
代码分析(一)创建单循环链表struct Link{int Data;Link*next;};Link *Creat(int n){Link *head,*s,*r;head=new Link;r=head;for (int i=0;i<n;i++) {s=new Link;cin>>s->Data;r->next=s;r=s;}r->next=head->next;return head;}(二)“约瑟夫环”的操作模块；Link* Jose(Link*p,int m){int s=m;if (p==p->next)return p;//递归出口即循环链表只剩下一个结点，将该结点指针返回 Link*q=NULL;//指针q用来保存删除结点的前驱for (int j=1;j<s;j++){q=p;p=p->next;} //查找要删除结点q->next=p->next; //删除节点cout<<p->Data<<" "; //输出结点序号Jose(p->next,s);//递归调用}(三)主程序int main(){cout<<"请输入Jose环中人数：";int n,m;cin>>n;cout<<"请输入每个人手中的序号："<<endl;Link*head=Creat(n);cout<<"请输入报数的数值";cin>>m;Link*p=head->next;cout<<endl;cout<<"离开的序号依次是：";Link*Result=Jose(p,m);v1.0 可编辑可修改cout<<Result->Data<<endl;return 0;}测试数据调试分析1、早期程序只写了约瑟夫环的实现部分，没有对输入数据进行筛选，调试的时候会经常出错。