链表实验报告
链表实验报告
《数据结构》实验报告二系别：嵌入式系统工程系班级：嵌入式11003班学号：11160400314 姓名：孙立阔日期：2012年4月9日指导教师：申华一、上机实验的问题和要求：单链表的查找、插入与删除。
设计算法，实现线性结构上的单链表的产生以及元素的查找、插入与删除。
具体实现要求：1.从键盘输入10个字符，产生不带表头的单链表，并输入结点值。
2.从键盘输入1个字符，在单链表中查找该结点的位置。
若找到，则显示“找到了”；否则，则显示“找不到”。
3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出单链表所有结点值，观察输出结果。
4.从键盘输入1个整数，表示欲删除结点的位置，输出单链表所有结点值，观察输出结果。
5.将单链表中值重复的结点删除，使所得的结果表中个结点值均不相同，输出单链表所有结点值，观察输出结果。
6.删除其中所有数据值为偶数的结点，输出单链表所有结点值，观察输出结果。
7.（★）将单链表分解成两个单链表A和B，使A链表中含有原链表中序号为奇数的元素，而B链表中含有原链表中序号为偶数的元素，且保持原来的相对顺序，分别输出单链表A和单链表B的所有结点值，观察输出结果。
二、程序设计的基本思想，原理和算法描述：（包括程序的结构，数据结构，输入/输出设计，符号名说明等）创建一个空的单链表，实现对单链表的查找，插入，删除的功能。
三、源程序及注释：#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define TRUE 1#define FALSE 0#define List_Init_Size 10#define ListIncrement 2typedef char ET;typedef ET * Ep;typedef int Status;typedef struct LNode{ET data;struct LNode *next;}LNode, *LinkList;/*LinkList La,Lb,Lc;*/#include "stdio.h"#include "alloc.h"/*Display the linklist's elements. */void printlk(LinkList L) {LinkList p;p=L->next;while (p) {printf("%c -> ",p->data);p = p->next;}printf("NULL\n");}/*Creat linklist from head node. */void CreatList( LinkList *L,int n){int i;LinkList p,q;ET str[20],c;p=(LinkList)malloc(sizeof(LNode));p->next=NULL;*L = q = p;printf("Please input the data : ");for (i=n;i>0;i--) {p=(LinkList)malloc(sizeof(LNode));c = getche(); /*scanf("%c",&c);*/printf("\n\n");p->data = c;p->next = q->next;q->next = p;}}/*Init the linklist. */void Init(LinkList *L) {int n;printf("Please input the number of the node : "); scanf("%d",&n);CreatList(L,n);}/* Get the value of element I; */int GetElem(LinkList L,int i,ET *e) {int j=1;LinkList p;p=L->next;while(p&&j<i) {p=p->next;++j;}if(!p||j>i) return TRUE;*e=p->data;return FALSE;}/*Insert a element after I */int ListInsert(LinkList *L,int i,ET e) {/* Add your own codes. */}/*Delete the element I */int ListDelete(LinkList *L,int i,ET *e) {/* Add your own codes. */}int Insert(LinkList *L) {int i,flag;ET data;printf("Please input the position : "); scanf("%d",&i);printf("Please input the data : ");data = getche(); /*scanf("%c",&data);*/ flag = ListInsert(L,i,data);return flag;}Status Delete(LinkList *L) {int i,flag;ET e;printf("Please input the number : "); scanf("%d",&i);flag = ListDelete(L,i,&e);printf("Deleted element is %c\n",e); return flag;}/*Find the element's position. */int LocateElem(LinkList L,ET e) {int i=0;LinkList p;p = L->next;while (p) {i++;if (p->data == e) return i;}return 0;}/*Add the Lb after the La. */void Union( LinkList *La ,LinkList *Lb){LinkList pa,pb;/* Add your own codes. */}/*Merge two sequence into one,don't change any elements in these two link lists. Join two sequence to one. */void MergeList(LinkList *L1,LinkList *L2,LinkList *L3) { LinkList pa,pb,pc;/* Add your own codes. */}/*List the Menu*/void MenuList() {printf("\n\n\n==========================\n"); printf(" 1 ******* Insert LA\n");printf(" 2 ******* Insert LB\n");printf(" 3 ******* Delete LA\n");printf(" 4 ******* Delete LB\n");printf(" 5 ******* Union LA and LB\n");printf(" 6 ******* Merge LA and LB to LC\n"); printf(" 7 ******* print LinkList\n");printf(" 8 ******* Exit\n");printf("==========================\n");}/*Select the menu */void MenuSelect(LinkList *La,LinkList *Lb){int select,done=1;LinkList Lc;while (done) {MenuList( );printf("input the operating code : ");scanf("%d",&select);switch(select){case 1: Insert(La);break;case 2: Insert(Lb);break;case 3: Delete(La);break;case 4: Delete(Lb);break;case 5: Union(La,Lb);break;case 6: MergeList(La,Lb,&Lc);printf("LC: ");printlk(Lc);break;case 7: printf("LA: ");printlk(*La);printf("LB: ");printlk(*Lb);break;case 8: done=0;break;default: printf(" ERROR\n");}}}main( ){LinkList La,Lb;printf("LA ");Init(&La) ;printlk(La);printf("LB ");Init(&Lb) ;printlk(Lb);MenuSelect(&La,&Lb);}调试后的代码：#include<stdio.h>#include<malloc.h>typedef int DataType;typedef struct LinkList{int data;struct LinkList *next;}LinkList;void PrintList(LinkList *h);LinkList* InitList();void InsList(LinkList *h,int i,DataType x); void LocList(LinkList *h,int i);void DelList(LinkList *h,int i);void main(){int i,n,x;LinkList *h;h=InitList();PrintList(h);printf("\n===========\n");printf("0------EXIT\n");printf("1------INSERT\n");printf("2------DELERT\n");printf("3------LOCERT\n");printf("\n===========\n\n\n");while(1){printf("\nSelect\n");scanf("%d",&n);switch(n){case 0:exit(0);break;case 1:printf("please input the position:\n");scanf("%d",&n);printf("please input the data:\n");scanf("%d",&x);InsList(h,n,x);PrintList(h);break;case 2:printf("please input you want to delete position:\n");scanf("%d",&i);DelList(h,i);PrintList(h);break;case 3:printf("please input you want to search position:\n");scanf("%d",&i);LocList(h,i);PrintList(h);break;default :printf("error\n");break;}}}LinkList* InitList(){LinkList *h,*s,*r;int a,c,i;h=(LinkList*)malloc(sizeof(LinkList));h->next=NULL;r=h;printf("please input some link's length:");scanf("%d",&c);for(i=0;i<c;i++){scanf("%d",&a);s=(LinkList*)malloc(sizeof(LinkList));s->data=a;s->next=r->next;r->next=s;r=r->next;}return h;}void InsList(LinkList *h,int i,DataType x){LinkList *s,*p;int j=1;p=h;s=(LinkList*)malloc(sizeof(LinkList));for(j=1;j<i && p!=NULL;j++)p=p->next;if(p==NULL)printf("error!\n");else{s->data=x;s->next=p->next;p->next=s;}}void DelList(LinkList *h,int i){LinkList *p,*q;int j=1;p=h->next;q=p->next;while(j!=i-1 && q!=NULL){p=p->next;q=q->next;j++;}if(q==NULL)printf("error!\n");else{p->next=q->next;free(q);}}void LocList(LinkList *h,int i){LinkList *p;int j=1;p=h->next;while(p!=NULL){if(p->data==i){printf("position is %d\n",j);break;}p=p->next;j++;}if(p==NULL)printf("NO this data in the link\n"); }void PrintList(LinkList*h){LinkList *p;p=h->next;while(p!=NULL){printf(" %d ->",p->data);p=p->next;}}四、运行输出结果：五、调试和运行程序过程中产生的问题及采取的措施：问题：子函数和主函数前后的调用出现问题，指针的调用不是太明白。
链表实验报告
C 语言程序设计实验报告实验一：链表的基本操作一·实验目的1. 掌握链表的建立方法2. 掌握链表中节点的查找与删除3. 掌握输出链表节点的方法4. 掌握链表节点排序的一种方法5. 掌握C 语言创建菜单的方法6. 掌握结构化程序设计的方法二·实验环境1. 硬件环境：当前所有电脑硬件环境均支持2. 软件环境：Visual C++6.0三.函数功能1. CreateList // 声明创建链表函数2.TraverseList // 声明遍历链表函数3. InsertList // 声明链表插入函数4.DeleteTheList // 声明删除整个链表函数5. FindList // 声明链表查询函数 四．程序流程图五．程序代码#include<stdio.h>#include<stdlib.h>typedef int Elemtype;typedef int Status;typedef struct node//定义存储节点{int data;//数据域struct node *next;//结构体指针} *linklist,node;//结构体变量，结构体名称linklist creat (int n)//创建单链表{linklist head,r,p;//定义头指针r,p,指针int x,i;head=(node *)malloc(sizeof(node));//生成头结点 声明函数 主函数 main 创建链表函数定义CreateList 定义链表遍历函数TraverseList定义链表查询函数FindList 定义链表插入函数在链表位置第pos 节点前插入包含数据val 的节点InsertList(PNode List, int pos, int val) 插入节点 定义删除整个链表函数 DeleteTheList定义删除链表元素函数删除链表中的第pos 节点DeleteList(PNode List, int pos) 删除节点r=head;//r指向头结点printf("输入数字:\n");for(i=n;i>0;i--)//for 循环用于生成第一个节点并读入数据{scanf("%d",&x);p=(node *)malloc(sizeof(node));p->data=x;//读入第一个节点的数据r->next=p;//把第一个节点连在头结点的后面r=p;//循环以便于生成第二个节点}r->next=0;//生成链表后的断开符return head;//返回头指针}void output (linklist head)//输出链表{linklist p;p=head->next;do{printf("%3d",p->data);p=p->next;}while(p);printf("\n")}Status insert ( linklist &l,int i, Elemtype e)//插入操作{int j=0;linklist p=l,s;while(j<i-1 && p){p=p->next;++j;}if(!p || j>i-1)return -1;else{s=(node *)malloc(sizeof(node));s->data=e;s->next=p->next;p->next=s;return 1;}}Status delect ( linklist &l,int i, Elemtype &e)//删除操作{int j=0;linklist p=l,q;while(j<i-1 && p->next){p=p->next;++j;}if(!p->next || j>i-1)return -1;else{q=p->next;p->next=q->next;e=q->data;free(q);return 1;}}void combine(linklist la,linklist lb)//合并单链表{node *pa,*pb,*pc;linklist lc;pa=la->next;pb=lb->next;lc=pc=la;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;free(lb);}Status GetElem(linklist l,int i,Elemtype &e )//查找操作 {linklist p;int j;p=l->next;j=1;while(p && j<i){p=p->next;++j;}if(!p || j>i)return -2;e=p->data;return e;}void main(){linklist la,lb;int n;int i,j;Elemtype e;printf("请输入第一个链表:\n");printf("输入链表元素的个数:\n");scanf("%d",&n);la=creat(n);printf("输出链表:\n");output(la);printf("请输入要查找元素的位置:\n");scanf("%d",&i);j=GetElem(la,i,e);printf("所要查找的元素是%d\n",j);printf("请输入插入位置和元素:\n");scanf("%d%d",&i,&e);insert(la,i,e);printf("插入后的链表:\n");output(la);printf("请输入要删除的位置:\n");scanf("%d",&i);delect(la,i,e);printf("删除的那个元素是:%d\n",e);printf("输出删除后的顺序表:\n");output(la);printf("请输入第一个非递减链表:\n");printf("输入链表元素的个数:\n");scanf("%d",&n);la=creat(n);printf("输出链表:\n");output(la);printf("请输入第二个非递减链表:\n");printf("输入链表元素的个数:\n");scanf("%d",&n);lb=creat(n);printf("输出链表:\n");output(lb);combine(la,lb);printf("输出合并后的链表:\n");output(la);六．运行结果七．心得体会通过本次实验我对链表有了更深的了解，对链表的插删操作、遍历、查找等基本上掌握了。
城市链表(实验报告)
本科学生综合性实验报告学院：软件与通信工程学院课程名称：数据结构与算法专业班级：09通信工程1班姓名：王燕学号：0093731学生实验报告（1）一、实验目的1．掌握用 C语言调试程序的基本方法。
2．掌握线性表的基本运算，如创建、插入、删除等。
二、实验内容将若干城市的信息，存入一个带头结点的单链表。
结点中的城市信息包括：城市名，城市的位置坐标。
要求能够利用城市名和位置坐标进行有关查找、插入、删除、更新等操作。
[拓展要求]（1）给定一个城市名，返回其位置坐标；（2）给定一个位置坐标P和一个距离D，返回所有与P的距离小于等于D的城市。
三、实验要求1．用C++/C完成算法设计和程序设计并上机调试通过。
2. 实验过程中学生调试完成，需向教师演示实验过程和结果。
3．撰写实验报告，提供实验结果和数据。
4．分析算法，要求给出具体的算法分析结果，包括时间复杂度和空间复杂度，并简要给出算法设计小结和心得。
5. 采用上机情况、程序质量、实习报告相结合的形式，满分为100分。
四、实验仪器1.WindowsXP以上操作系统；2.Visual C++6.0语言环境；3.每人一台PC机。
五、实验内容和步骤1．启动Windows XP操作系统2．创建工作文件夹创建Visual C++ 6.0的工作文件夹。
3．启动Visual C++ 6.0建立一个空工程LinkList,在建立一个源文件citylinklist4.编写代码如下：#include<stdio.h>#include<string.h>#include<malloc.h>#include<stdlib.h>#include<math.h>typedef struct Node{char CityName[10];float CityPoistion[2];struct Node *next;}Node, * LinkList;void InitList(LinkList * H){* H=(LinkList)malloc(sizeof(Node));(* H)->next=NULL;}//建立城市信息链表，以城市名“no”作为结束标识符void CreateCity(LinkList H){Node * r, * s;;char name[10];float x,y;r=H;printf("请输入若干个城市的信息！(以城市名no结束)\n城市名经度纬度\n");scanf("%s%f%f",name,&x,&y);while(strcmp(name,"no")!=0){s=(Node*)malloc(sizeof(Node));strcpy(s->CityName,name);s->CityPoistion[0]=x;s->CityPoistion[1]=y;r->next=s;r=s;scanf("%s%f%f",name,&x,&y);}r->next=NULL;}//在某个城市后面插入一个城市信息int InsertCity(LinkList L){char cityname[10],name[10]; //name为定位城市名，cityname为要插入城市信息的城市名float x,y,x1,y1; //x1,y1是定位城市位置坐标，x,y是要插入城市信息的城市位置坐标int flag;printf("请选择插入方式(0 按城市名插入, 1 按城市位置坐标插入)：");scanf("%d",&flag);switch(flag){case 0:p=L;printf("请输入在那个城市名后插入城市信息：");scanf("%s",name);getchar();while((p!=NULL)&&(strcmp(p->CityName,name)!=0))p=p->next;if(p==NULL){printf("没有找到城市名为%s 的城市，插入位置不当！\n",name);}else{printf("在城市%s 后插入一个城市信息：\n城市名经度纬度\n",name);scanf("%s%f%f",cityname,&x,&y);q=(Node*)malloc(sizeof(Node));strcpy(q->CityName,cityname);q->CityPoistion[0]=x;q->CityPoistion[1]=y;q->next=p->next;p->next=q;}break;case 1:p=L;printf("请输入在哪个城市位置坐标后插入城市信息：");scanf("%f%f",&x1,&y1);getchar();while((p!=NULL)&&(p->CityPoistion[0]!=x1)&&(p->CityPoistion[1]!=y1))p=p->next;if(p==NULL){printf("没有找到满足坐标为(%.2f , %.2f)的城市，插入位置不当！\n",x1,y1);}else{printf("在城市坐标为(%.2f , %.2f)的城市后面插入一个城市信息\n城市名经度纬度\n",x1,y1);q=(Node*)malloc(sizeof(Node));strcpy(q->CityName,cityname);q->CityPoistion[0]=x;q->CityPoistion[1]=y;q->next=p->next;p->next=q;}break;}return 1;}//删除一个城市信息int DeleteCity(LinkList L){Node *p,*q;char name[10]; //name是要删除城市信息的城市名float x1,y1; //x,y是要删除城市信息的城市位置坐标int flag;printf("请选择删除方式(0 按城市名删除, 1 按城市坐标删除): ");scanf("%d",&flag);switch(flag){case 0:p=L;q=p->next;printf("请输入要删除城市信息的城市名：");scanf("%s",name);while(q!=NULL && strcmp(q->CityName,name)!=0){q=q->next;p=p->next;}if(q==NULL){printf("没有找到城市名为%s 的城市，删除不成功！\n",name);}else{p->next=q->next;printf("删除了城市%s 的信息.\n",q->CityName);free(q);}break;case 1:p=L;printf("请输入要删除城市信息的城市位置坐标：");scanf("%f%f",&x1,&y1);while((q!=NULL)&&(q->CityPoistion[0]!=x1)&&(q->CityPoistion[1]!=y1)){q=q->next;p=p->next;}if(q==NULL){printf("没有找到满足坐标为(%.2f , %.2f)的城市，删除不成功！\n",x1,y1);}else{printf("删除了城市%s 的信息.\n",q->CityName);p->next=q->next;free(q);}break;}return 1;}//查找一个城市信息int FindCity(LinkList L){Node *p;char name[10]; //name是要查找城市信息的城市名float x1,y1; //x,y是要查找城市信息的城市位置坐标int flag;printf("请选择查找方式(0 按城市名查找, 1 按城市位置坐标查找)：");scanf("%d",&flag);switch(flag){case 0:p=L->next;printf("请输入要查找城市信息的城市名：");scanf("%s",&name);while(p!=NULL&&strcmp(p->CityName,name)!=0)p=p->next;if(p==NULL){printf("没有找到城市名为%s 的城市！\n",name);}else{printf("城市名为%s 的城市位置坐标为}break;case 1:p=L->next;printf("请输入要查找城市信息的城市位置坐标：");scanf("%f%f",&x1,&y1);while((p!=NULL)&&(p->CityPoistion[0]!=x1)&&(p->CityPoistion[1]!=y1))p=p->next;if(p==NULL){printf("没有找到城市位置坐标为(%.2f , %.2f)的城市！\n",x1,y1);}elseprintf("城市位置坐标为(%.2f , %.2f)的是城市名为%s \n",p->CityPoistion[0],p->CityPoistion[1],p->CityName);break;}return 1;}//计算二维坐标两点间的距离float Length(float x1,float y1,float x2,float y2){float l;l=sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));return l;}//以某点为中心找到所有小于某个距离的城市void SubDAround(LinkList L){Node * q;int n=0;float px,py,d;q=L->next;printf("请输入中心坐标点坐标以及距离：");scanf("%f%f%f",&px,&py,&d);printf("距中心坐标点(%.2f , %.2f) %.2f 的城市有：\n",px,py,d);while(q!=NULL){if(Length(px,py,q->CityPoistion[0],q->CityPoistion[1])<=d){printf("%s %.2f %.2f\n",q->CityName,q->CityPoistion[0],q->CityPoistion[1]);q=q->next;n++;}else}if(n==0) printf("没有任何城市符合条件！\n");}//显示所有城市信息void DisplayCity(LinkList L){Node * p;p=L->next;printf("城市名经度纬度\n");while(p!=NULL){printf("%s %.2f %.2f\n",p->CityName,p->CityPoistion[0],p->CityPoistion[1]);p=p->next;}}void main(){int k=1;LinkList CLL;InitList(&CLL);while(k){printf("\n\n\t\t\t城市信息管理系统\n\n");printf("\t\t\t1.建立一个城市信息链表\n");printf("\t\t\t2.查找一个城市信息\n");printf("\t\t\t3.插入一个城市信息\n");printf("\t\t\t4.删除一个城市信息\n");printf("\t\t\t5.显示所有城市信息\n");printf("\t\t\t6.距某点小于某距离的所有城市信息\n");printf("\t\t\t0.退出\n");printf("请选择操作项目：");scanf("%d",&k);system("cls");switch(k){case 1:CreateCity(CLL);system("pause");break;case 2:FindCity(CLL);system("pause");break;case 3:InsertCity(CLL);system("pause");break;case 4:DeleteCity(CLL);system("pause");break;case 5:DisplayCity(CLL);system("pause");break;case 6:SubDAround(CLL);system("pause");break;case 0:break;}system("cls");}5.编译、运行，结果如下：开始界面：建立城市城市信息链表：显示建立城市信息链表后的内容：按城市名查找城市信息，而且查找成功：按城市名查找城市信息，但查找不成功：按城市坐标查找城市信息，而且查找成功：按城市名查找城市信息，但查找不成功：按城市名在某个城市后面插入一个城市信息，而且插入成功：按城市名在某个城市后面插入一个城市信息，但插入不成功：按城市坐标在某个城市后面插入一个城市信息，而且插入成功：按城市坐标在某个城市后面插入一个城市信息，但插入不成功：显示插入城市信息后城市链表的内容：按城市名删除一个城市信息，而且删除成功：按城市名删除一个城市信息，但删除不成功：按城市坐标删除一个城市信息，而且删除成功：按城市坐标删除一个城市信息，但删除不成功：显示删除一些城市信息后城市链表的内容：寻找以某点中心小于某个距离的所有城市信息，而且寻找成功：寻找以某点中心小于某个距离的所有城市信息，但寻找不成功：选择退出后的页面：四、结论1、实验结果实现了在城市链表中利用城市名和位置坐标进行有关查找、插入、删除、更新基本要求的操作。
链表基本操作实验报告
实验2 链表基本操作实验一、实验目的1． 定义单链表的结点类型。
2． 熟悉对单链表的一些基本操作和具体的函数定义。
3． 通过单链表的定义掌握线性表的链式存储结构的特点。
二、实验内容与要求该程序的功能是实现单链表的定义和主要操作。
如：单链表建立、输出、插入、删除、查找等操作。
该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。
程序中的单链表（带头结点）结点为结构类型，结点值为整型。
要求：同学们可参考指导书实验2程序、教材算法及其他资料编程实现单链表相关操作。
必须包括单链表创建、输出、插入、删除操作，其他操作根据个人情况增减。
三、 算法分析与设计。
头结点......2.单链表插入s->data=x; s->next=p->next; p->next=s;3.单链表的删除：p->next=p->next->next;四、运行结果1.单链表初始化2.创建单链表3.求链表长度4.检查链表是否为空5.遍历链表6.从链表中查找元素7.从链表中查找与给定元素值相同的元素在顺序表中的位置8.向链表中插入元素插入元素之后的链表9.从链表中删除元素删除位置为6的元素(是3)10.清空单链表五、实验体会经过这次单链表基本操作实验，自己的编程能力有了进一步的提高，认识到自己以前在思考一个问题上思路不够开阔，不能灵活的表达出自己的想法，虽然在打完源代码之后出现了一些错误，但是经过认真查找、修改，最终将错误一一修正，主要是在写算法分析的时候出现了障碍，经过从网上查找资料，自己也对程序做了仔细的分析，对单链表创建、插入、删除算法画了详细的N-S流程图。
六、C语言版原代码# include<stdio.h># include<stdlib.h>/* 定义ElemType 为int类型*/typedef int ElemType;# define TRUE 1# define FALSE 0# define NULL 0# define flag -1/*单链表的结点类型*/typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkedList;/*初始化单链表*/LinkedList LinkedListInit(){LinkedList L;L=(LinkedList)malloc(sizeof(LNode));L->next=NULL;return L;}/*清空单链表*/void LinkedListClear(LinkedList L){L->next=NULL;printf("链表已经清空\n");}/*检查单链表是否为空*/int LinkedListEmpty(LinkedList L){if(L->next==NULL) return TRUE;else return FALSE;}/*遍历单链表*/void LinkedListTraverse(LinkedList L) {LinkedList 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 LinkedListLength (LinkedList L){LinkedList p;int j;p=L->next;j=0;while(p!=NULL){j++;p=p->next;}return j;}LinkedList LinkedListGet(LinkedList L,int i) {LinkedList 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;}int LinkedListLocate(LinkedList L,ElemType x) {LinkedList p;int j;p=L->next;j=1;while(p!=NULL&&p->data!=x){p=p->next;j++;}if(p) return j;else return 0;}void LinkedListInsert(LinkedList L,int i,ElemType x) {LinkedList 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=x;s->next=p->next;p->next=s;printf("%d 已插入到链表中\n",x);}}void LinkedListDel(LinkedList L,int i) {LinkedList 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);}}LinkedList LinkedListCreat(){LinkedList L=LinkedListInit(),p,r;ElemType x;r=L;printf("请依次输入链表中的元素，输入-1结束\n"); scanf("%d",&x);while(x!=flag){p=(LinkedList)malloc(sizeof(LNode));p->data=x;r->next=p;r=p;scanf("%d",&x);}r->next=NULL;return L;}int scan(){int d;printf("请选择要进行的操作\n");printf("-------------------------------------------------------\n"); printf("1.初始化 2.清空 3.求链表长度 4.检查链表是否为空\n"); printf("-------------------------------------------------------\n"); printf("5.遍历链表 6.从链表中查找元素\n");printf("-------------------------------------------------------\n"); printf("7.从链表中查找与给定元素值相同的元素在顺序表中的位置\n"); printf("-------------------------------------------------------\n"); printf("8.向链表中插入元素 9.从链表中删除元素 10创建线性表\n"); printf("-------------------------------------------------------\n"); printf("其他键退出。
链表实验报告总结
篇一：链表实验报告数据结构实验报告姓名；方钢学号：20105567 专业：电子商务班级： 10-1班指导教师：实验时间：实验地点：新区实验楼4楼（实验题目）单链表实验1.实验内容和要求1.1实验要求①本次实验中的链表结构均为带头结点的单链表；②链表结构定义，算法实现放入库文件“linklist.h”；运算和变量命名直观易懂，并有相应的注释1.2实验内容<1>求链表中第i个结点的指针（函数），若不存在，则返回null。
<2>在第i 个结点前插入值为x的结点。
<3>删除链表中第i个元素结点。
<4>在一个递增有序的链表l中插入一个值为x的元素，并保持其递增有序特性。
<5>将单链表ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），申请2个头结点，把分开的奇数项和偶数项分别链接到这2个头结点上，然后再将这两个新链表同时输出在屏幕上，并保留原链表的显示结果，以便对照求解结果。
<6>求两个递增有序链表l1和l2中的公共元素，并以同样方式连接成链表l3。
2.实验目的2.1 理解线性表的链式存储结构。
2.2熟练掌握单链表结构及有关算法的设计。
2.3根据具体问题的需要，设计出合理的表示数据的链表结构，并设计相关算法。
3.数据结构设计<1>求链表中第i个结点的指针（函数），若不存在，则返回null。
实验代码node *l,*p;int i; createnode(*&l); //尾插法创建一个链表，cout<<链表包含：<<endl;p=l->next; while(p){cout<<p->data<<,;p=p->next; }cout<<endl;cout<<请输入待求元素序号：;cin>>i; locatenode (l, i, &p );if(p!=null)cout<<序号<<i<<的元素值为：<<p->data<<endl;elsecout<<null<<endl;destroylist(l); //销毁链表，释放heap内存_crtdumpmemoryleaks(); //debug 模式下检测是否内存泄漏测试截图<2>在第i个结点前插入值为x的结点。
链表实验报告1
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 //结点结构{int number; /* 人的序号*/int cipher; /* 密码*/struct node *next; /* 指向下一个节点的指针*/};/* 定义 DataType 为 int 类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;LinkedList LinkedListInit(){ //函数功能：对链表进行初始化参数：链表(linklist L) 成功初始化返回 1, 否则返回 0 }void LinkedListClear(LinkedList &L){//函数功能：把链表清空参数：链表(linklist L) 成功清空链表返回 1 }int LinkedListEmpty(LinkedList L){ //函数功能:判断链表是否为空参数：链表(linklist L) 链表为空时返回 0, 不为空返回 1 }void LinkedListTraverse(LinkedList L){ //函数功能:遍历链表,输出每一个节点的 elem 值参数：链表(linklist L) 通过循环逐个输出节点的 elem 值 }int LinkedListLength(LinkedList L){ //函数功能:返回链表的长度参数：链表(linklistL) 函数返回链表的长度 }LinkedList LinkedListGet(LinkedList L,int i){ //函数功能: 从链表中查找有无给定元素参数;链表(linklist L),给定元素 (int i) 如果链表中有给定元素(i)则返回 1,否则返回 0 }LinkedList LinkedListLocate(LinkedList L, DataType x){//函数功能: 从链表中查找给定元素的位置参数;链表(linklist L),给定元素(int i) 如果链表中有给定元素 i 则返回元素的位置, 没有则返回 0 }void LinkedListInsert(LinkedList &L,int i,DataType x)}void LinkedListDel(LinkedList &L,DataType x)i 个结点 }(二)、zhujiemian();cin>>a;do{switch(a){case 1:if(init(L)==1)cout<<"成功初始化！ "<<endl;elsecout<<"初始化失败！ "<<endl;break;case 2:if(makeempty(L)==1)cout<<"链表已清空！ "<<endl;elsecout<<"链表清空失败！ "<<endl;break;case 3:b=getlength(L);cout<<"链表的长度为： "<<b<<endl;break;case 4:if(isempty(L)==1)cout<<"链表不为空！ "<<endl;elsecout<<"链表为空！ "<<endl;break;case 5:if(isfull(L)==1)cout<<"链表不满！ "<<endl;elsecout<<"链表已满！ "<<endl;break;case 6:show(L);break;case 7:cout<<"输入您要查找的元素： ";cin>>b;if(find(L,b)==1)cout<<"链表中有该元素"<<b<<endl;elsecout<<"链表中没有您要查找的元素"<<b<<endl;break;case 8:cout<<"您要查找的元素为： "<<endl;cin>>b;if(location(L,b)==0)cout<<"没有您要查找的元素"<<b<<endl;elsecout<<"您查找的元素 "<<b<<"在第"<<location(L,b)<<"个位置。
链表实验报告总结doc
链表实验报告总结篇一：顺序表,链表总结实验报告实验报告实验目的：学生管理系统（顺序表）实验要求：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 {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->d ata[k].cj);}}int cr(SqList *L,DataType *xs,int i) //插入信息{int j;if(L->length==MaxSize){printf("没有!");return 0;}else if((iL->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++){篇二：单链表的实验报告辽宁工程技术大学上机实验报告篇三：单链表实验报告实验一线性表基本操作的编程实现--线性表在链表存储下的主要操作实现班级:T523-1 姓名:王娟学号:33完成日期:XX.04.04 地点:5502学时:2学时一、需求分析【实验目的】通过本次实验，对课堂上线性表的知识进行巩固，进一步熟悉线性表的链接存储及相应的基本操作；并熟练掌握VC++ 6.0操作平台，学会调试程序，以及编写电子实验报告【实验要求】编写线性表的基本操作，有构造线性表，线性表的遍历，插入，删除，查找，求表长等基本功能，在此基础上能够加入DOS下的图形界面以及学会文件的操作等功能，为以后的学习打下基础。
数据结构顺序表链表试验报告
数据结构顺序表链表试验报告数据结构试验报告一、引言数据结构是计算机科学中非常重要的一个概念，它用于组织和存储数据，以便能够高效地进行检索和操作。
顺序表和链表是两种常见的数据结构，它们在实际应用中都有各自的优势和局限性。
本报告将对顺序表和链表进行试验比较，以评估它们在不同场景下的性能和适合性。
二、实验目的本次试验的目的是比较顺序表和链表在插入、删除和查找操作上的性能差异，并分析其时间复杂度和空间复杂度。
通过实验结果，可以对不同场景下选择合适的数据结构提供参考。
三、实验内容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。
数据结构上机实验报告
数据结构实验报告课程数据结构 _ 院系专业班级实验地点姓名学号实验时间指导老师数据结构上机实验报告1一﹑实验名称：实验一——链表二﹑实验目的：1.了解线性表的逻辑结构特性；2.熟悉链表的基本运算在顺序存储结构上的实现，熟练掌握链式存储结构的描述方法；3.掌握链表的基本操作（建表、插入、删除等）4. 掌握循环链表的概念，加深对链表的本质的理解。
5.掌握运用上机调试链表的基本方法三﹑实验内容：（1）创建一个链表（2）在链表中插入元素（3）在链表中删除一个元素（4）销毁链表四﹑实验步骤与程序#include <iostream.h>#include <malloc.h>typedef struct LNode{int data;struct LNode *next;}Lnode, *LinkList;//假设下面的链表均为带头结点。
void CreatLinkList(LinkList &L,int j){//建立一个链表L,数据为整数，数据由键盘随机输入。
LinkList p,q;L=(LinkList )malloc(sizeof(Lnode));L->next=NULL;q=L;cout<<"请输入一个链表："<<endl;for(int i=0;i<j;i++){ p=(LinkList)malloc(sizeof(Lnode));cin>>p->data;p->next=q->next;q->next=p;q=p;}}int PrintLinkList(LinkList &L){//输出链表L的数据元素LinkList p;p=L->next;if(L->next==NULL){cout<<"链表没有元素!"<<endl;return 0;}cout<<"链表的数据元素为:";while(p){cout<<p->data<<" ";p=p->next;}cout<<endl;return 1;}void LinkListLengh(LinkList &L){//计算链表L的数据元素个数。
链表(单链表 双向循环)实验报告讲解
数据结构实验报告T1223-3-21余帅实验一实验题目：仅仅做链表部分难度从上到下1.双向链表，带表头，线性表常规操作。
2.循环表，带表头，线性表常规操作。
3.单链表，带表头，线性表常规操作。
实验目的：了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。
实验要求：常规操作至少有：1.数据输入或建立2.遍历3.插入4.删除必须能多次反复运行实验主要步骤：1、分析、理解给出的示例程序。
2、调试程序，并设计输入数据，测试程序的如下功能：1.数据输入或建立2.遍历3.插入4.删除单链表示意图：headhead head 创建删除双向循环链表示意图：创建程序代码://单链表#include<iostream.h>#include<windows.h>const MAX=5;enum returninfo{success,fail,overflow,underflow,range_error}; int defaultdata[MAX]={11,22,33,44,55};class node{public:int data;node *next;};class linklist{private:node *headp;protected:int count;public:linklist();~linklist();bool empty();void clearlist();returninfo create(void);returninfo insert(int position,const int &item);returninfo remove(int position) ;returninfo traverse(void);};linklist::linklist(){headp = new node;headp->next = NULL;count=0;}linklist::~linklist(){clearlist();delete headp;}bool linklist::empty(){if(headp->next==NULL)return true;elsereturn false;}void linklist::clearlist(){node *searchp=headp->next,*followp=headp;while(searchp->next!=NULL){followp=searchp;searchp=searchp->next;delete followp;}headp->next = NULL;count = 0;}returninfo linklist::create(){node *searchp=headp,*newnodep;for(int i=0;i<MAX;i++){newnodep = new node;newnodep->data = defaultdata[i];newnodep->next = NULL;searchp->next = newnodep;searchp = searchp->next;count++;}searchp->next = NULL;traverse();return success;}returninfo linklist::insert(int position,const int &item) //插入一个结点{if(position<=0 || position>=count)return range_error;node *newnodep=new node,*searchp=headp->next,*followp=headp;for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}newnodep->data=item; //给数据赋值newnodep->next=followp->next; //注意此处的次序相关性followp->next=newnodep;count++; //计数器加一return success;}returninfo linklist::remove(int position) //删除一个结点{if(empty())return underflow;if(position<=0||position>=count+1)return range_error;node *searchp=headp->next,*followp=headp; //这里两个指针的初始值设计一前一后for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}followp->next=searchp->next; //删除结点的实际语句delete searchp; //释放该结点count--; //计数器减一return success;}returninfo linklist::traverse(void){node *searchp;if(empty())return underflow;searchp = headp->next;cout<<"连表中的数据为："<<endl;while(searchp!=NULL){cout<<searchp->data<<" ";searchp = searchp->next;}cout<<endl;return success;}class interfacebase{public:linklist listface; //定义一个对象Cskillstudyonfacevoid clearscreen(void);void showmenu(void);void processmenu(void);};void interfacebase::clearscreen(void){system("cls");}void interfacebase::showmenu(void){cout<<"================================"<<endl;cout<<" 功能菜单 "<<endl;cout<<" 1.创建链表 "<<endl;cout<<" 2.增加结点 "<<endl;cout<<" 3.删除结点 "<<endl;cout<<" 4.遍历链表 "<<endl;cout<<" 0.结束程序 "<<endl;cout<<"======================================"<<endl;cout<<"请输入您的选择：";}void interfacebase::processmenu(void){int returnvalue,item,position;char menuchoice;cin >>menuchoice;switch(menuchoice) //根据用户的选择进行相应的操作{case '1':returnvalue=listface.create();if(returnvalue==success)cout<<"链表创建已完成"<<endl;break;case '2':cout<<"请输入插入位置："<<endl;cin>>position;cout<<"请输入插入数据："<<endl;cin>>item;returnvalue = listface.insert(position,item);if(returnvalue==range_error)cout<<"数据个数超出范围"<<endl;elsecout<<"操作成功！！！"<<endl;break;case '3':cout<<"输入你要删除的位置："<<endl;cin>>position;returnvalue = listface.remove(position);if(returnvalue==underflow)cout<<"链表已空"<<endl;else if(returnvalue==range_error)cout<<"删除的数据位置超区范围"<<endl;elsecout<<"操作成功！！！"<<endl;break;case '4':listface.traverse();break;case '0':cout<<endl<<endl<<"您已经成功退出本系统，欢迎再次使用!!!"<<endl;system("pause");exit(1);default:cout<<"对不起，您输入的功能编号有错!请重新输入!!!"<<endl;break;}}void main(){interfacebase interfacenow;linklist listnow;system("color f0");interfacenow.clearscreen();while(1){interfacenow.showmenu();interfacenow.processmenu();system("pause");interfacenow.clearscreen();}}/* 功能：用双向循环链表存储数据1.创建链表2.增加结点3.删除结点4.遍历链表制作人：余帅内容：239行*/#include<iostream.h>#include<windows.h>const MAX=5;enum returninfo{success,fail,overflow,underflow,range_error}; int defaultdata[MAX]={11,22,33,44,55};class node{public:int data;node * next; //指向后续节点node * pre; //指向前面的节点};class linklist{private:node *headp;protected:int count;public:linklist();~linklist();bool empty();void clearlist();returninfo create(void);returninfo insert(int position,const int &item);returninfo remove(int position) ;returninfo traverse(void);};linklist::linklist(){headp = new node;headp->next = NULL;headp->pre = NULL;count=0;}linklist::~linklist(){clearlist();delete headp;}bool linklist::empty(){if(headp->next==NULL)return true;elsereturn false;}void linklist::clearlist(){node *searchp=headp->next,*followp=headp;while(searchp->next!=NULL){followp=searchp;searchp=searchp->next;delete followp;}headp->next = NULL;headp->pre = NULL;count = 0;}returninfo linklist::create(){node *searchp=headp,*newnodep;for(int i=0;i<MAX;i++){newnodep = new node;newnodep->data = defaultdata[i];newnodep->next = NULL;searchp->next = newnodep;newnodep->pre = searchp;searchp = searchp->next;count++;}searchp->next = headp;headp->pre = searchp;traverse();return success;}returninfo linklist::insert(int position,const int &item) //插入一个结点{if(position<=0 || position>count+1)return range_error;node *newnodep=new node;node *searchp=headp->next,*followp=headp;for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}newnodep->data=item; //给数据赋值newnodep->next = searchp;searchp->pre = newnodep;followp->next = newnodep;newnodep->pre = followp;count++; //计数器加一return success;}returninfo linklist::remove(int position) //删除一个结点{if(empty())return underflow;if(position<=0||position>=count+1)return range_error;node *searchp=headp->next,*followp=headp; //这里两个指针的初始值设计一前一后for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}followp->next=searchp->next; //删除结点的实际语句searchp->next->pre = followp;delete searchp; //释放该结点count--; //计数器减一return success;}returninfo linklist::traverse(void){node *searchp1,*searchp2;if(empty())return underflow;searchp1 = headp;searchp2 = headp;cout<<"连表中的数据为："<<endl;cout<<"从左至右读取：";while (searchp1->next!=headp ) {searchp1 = searchp1 ->next;cout << searchp1->data<<" ";}cout<<endl;cout<<"从右至左读取：";while (searchp2->pre!=headp ) {searchp2 = searchp2 ->pre;cout << searchp2->data<<" ";}cout<<endl;return success;}class interfacebase{public:linklist listface; //定义一个对象Cskillstudyonface void clearscreen(void);void showmenu(void);void processmenu(void);};void interfacebase::clearscreen(void){system("cls");}void interfacebase::showmenu(void){cout<<"================================"<<endl;cout<<" 功能菜单 "<<endl;cout<<" 1.创建链表 "<<endl;cout<<" 2.增加结点 "<<endl;cout<<" 3.删除结点 "<<endl;cout<<" 4.遍历链表 "<<endl;cout<<" 0.结束程序 "<<endl;cout<<"======================================"<<endl;cout<<"请输入您的选择：";}void interfacebase::processmenu(void){int returnvalue,item,position;char menuchoice;cin >>menuchoice;switch(menuchoice) //根据用户的选择进行相应的操作{case '1':returnvalue=listface.create();if(returnvalue==success)cout<<"链表创建已完成"<<endl;break;case '2':cout<<"请输入插入位置："<<endl;cin>>position;cout<<"请输入插入数据："<<endl;cin>>item;returnvalue = listface.insert(position,item);if(returnvalue==range_error)cout<<"数据个数超出范围"<<endl;elsecout<<"操作成功！！！"<<endl;break;case '3':cout<<"输入你要删除的位置："<<endl;cin>>position;returnvalue = listface.remove(position);if(returnvalue==underflow)cout<<"链表已空"<<endl;else if(returnvalue==range_error)cout<<"删除的数据位置超区范围"<<endl;elsecout<<"操作成功！！！"<<endl;break;case '4':listface.traverse();break;case '0':cout<<endl<<endl<<"您已经成功退出本系统，欢迎再次使用!!!"<<endl;system("pause");exit(1);default:cout<<"对不起，您输入的功能编号有错!请重新输入!!!"<<endl;break;}}void main(){interfacebase interfacenow;linklist listnow;system("color f0");interfacenow.clearscreen();while(1){interfacenow.showmenu();interfacenow.processmenu();system("pause");interfacenow.clearscreen();}}运行结果：1.创建链表：2.增加结点3．删除结点心得体会：本次实验使我们对链表的实质了解更加明确了，对链表的一些基本操作也更加熟练了。
实验链表实验报告
实验链表实验报告一、实验目的本次实验的主要目的是深入理解链表这种数据结构的概念、特点和操作方法，并通过实际编程实现来提高对链表的应用能力。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验原理链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
与数组不同，链表的内存分配是动态的，并且可以方便地进行插入和删除操作，而不需要移动大量的元素。
链表分为单向链表、双向链表和循环链表等多种类型。
在本次实验中，我们主要实现单向链表。
单向链表的节点结构通常包含数据域和指针域。
数据域用于存储节点的数据，指针域用于指向下一个节点。
通过遍历链表的指针，可以访问链表中的每个节点。
四、实验内容1、链表节点的定义｀｀｀cppstruct ListNode ｛int data;ListNode next;ListNode(int x) ： data(x)， next(NULL) ｛｝｝；｀｀｀2、链表的创建｀｀｀cppListNode createList(）｛ListNode head ＝ NULL;ListNode tail ＝ NULL;int num;cout ＜＜＂请输入链表中的数字（输入－1 结束）：＂；cin ＞＞ num;while （num!＝－1) ｛ListNode newNode ＝ new ListNode(num)；if （head ＝＝ NULL) ｛head ＝ newNode;tail ＝ newNode;｝ else ｛tail>next ＝ newNode;tail ＝ newNode;｝cin ＞＞ num;｝return head;｝｀｀｀3、链表的遍历｀｀｀cppvoid traverseList(ListNode head) ｛ListNode curr ＝ head;while （curr!＝ NULL) ｛cout ＜＜ curr>data ＜＜＂＂；curr ＝ curr>next;｝cout ＜＜ endl;｝｀｀｀4、链表的插入｀｀｀cppvoid insertNode(ListNode& head, int position, int value) ｛ListNode newNode ＝ new ListNode(value)；if （position ＝＝ 0) ｛newNode>next ＝ head;head ＝ newNode;return;｝ListNode curr ＝ head;int count ＝ 0;while （curr!＝ NULL ＆＆ count ＜ position 1) ｛curr ＝ curr>next;count+＋；｝if （curr ＝＝ NULL) ｛cout ＜＜＂插入位置超出链表长度" ＜＜ endl; return;｝newNode>next ＝ curr>next;curr>next ＝ newNode;｝｀｀｀5、链表的删除｀｀｀cppvoid deleteNode(ListNode& head, int position) ｛if （head ＝＝ NULL) ｛cout ＜＜＂链表为空，无法删除" ＜＜ endl; return;｝if （position ＝＝ 0) ｛ListNode temp ＝ head;head ＝ head>next;delete temp;return;｝ListNode curr ＝ head;ListNode prev ＝ NULL;int count ＝ 0;while （curr!＝ NULL ＆＆ count ＜ position) ｛prev ＝ curr;curr ＝ curr>next;count+＋；｝if （curr ＝＝ NULL) ｛cout ＜＜＂删除位置超出链表长度" ＜＜ endl; return;｝prev>next ＝ curr>next;delete curr;｝｀｀｀五、实验结果通过对上述链表操作函数的调用，我们成功地创建、遍历、插入和删除了链表中的节点。
单链表的实现实验报告
单链表的实现实验报告篇一：数据结构单链表实验报告一、设计人员相关信息1. 设计者姓名、学号和班号：12地信李晓婧120122429832. 设计日期：2014.3. 上机环境：VC++6.0二、程序设计相关信息1. 实验题目：编写一个程序，实现单链表的各种基本运算（假设单链表的元素类型为char），并在此基础上设计一个程序，完成如下功能：（1）初始化单链表；（2）采用尾插法依次插入元素a,b,c,d,e;（3）输出单链表（4）输出单链表长度（5）判断单链表是否为空（6）输出单链表第3个元素（7）输出元素a的位置（8）在第4个元素位置上插入元素f（9）输出单链表（10）删除第三个元素（11）输出单链表（12）释放单链表2. 实验项目组成：（1）插入和删除节点操作（2）建立单链表尾插法建表（3）线性表基本运算在单链表中的实现初始化线性表销毁线性表判断线性表是否为空表求线性表的长度3. 实验项目的程序结构（程序中的函数调用关系图）：4. 实验项目包含的各个文件中的函数的功能描述：? 尾插法建表CreateListR：将新节点插到当前链表的表尾上，为此必须增加一个尾指针r，使其始终指向当前链表的尾节点。
? 初始化线性表InitList：该运算建立一个空的单链表，即创建一个头节点；? 销毁线性表DestroyList：释放单链表占用的内存空间，即逐一释放全部节点的空间； ? 判断线性表是否为空表ListEmpty：若单链表没有数据节点，则返回真，否则返回假； ? 求线性表的长度ListLength：返回单链表中数据节点的个数；? 输出线性表DispList：逐一扫描单链表的每个数据节点，并显示各节点的data域值；? 求线性表中某个数据元素值GetElem：在单链表中从头开始找到第i个节点，若存在第i个数据节点，则将其data域值赋给变量e；? 按元素值查找LocateElem：在单链表中从头开始找第一个值域与e相等的节点，若存在这样的节点，则返回逻辑序号，否则返回0；? 插入数据元素ListInsert：先在单链表中找到第i1个节点*p，若存在这样的节点，将值为e的节点*s插入到*p节点的后面；? 删除数据元素ListDelete：先在单链表中找到第i1个节点*p，若存在这样的节点，且也存在后继节点*q；删除*q节点，返回TRUE；否则返回FALSE表示参数i错误。
链表的合并 实验报告
链表的合并实验报告一、实验目的本次实验的主要目的是深入理解链表的数据结构，并通过编程实现链表的合并操作，以提高对数据结构和算法的理解与应用能力。
二、实验环境本次实验使用的编程语言为 Python，开发环境为 PyCharm。
三、实验原理链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
在合并两个链表时，需要比较两个链表节点的值，将较小的值依次添加到新的合并链表中。
当其中一个链表遍历完后，将另一个链表剩余的节点直接添加到合并链表的末尾。
四、实验步骤1、定义链表节点类｀｀｀pythonclass ListNode:def ＿_init__(self, val=0, next=None)：selfval ＝ val｀｀｀2、合并链表函数｀｀｀pythondef mergeTwoLists(l1, l2)：dummy ＝ ListNode(0) curr ＝ dummywhile l1 and l2:if l1val ＜ l2val:currnext ＝ l1l1 ＝ l1nextelse:currnext ＝ l2l2 ＝ l2nextcurr ＝ currnextif l1:currnext ＝ l1if l2:return dummynext｀｀｀3、测试函数｀｀｀pythondef test_mergeTwoLists(）：构建测试链表 l1l1 ＝ ListNode(1)l1next ＝ ListNode(2)l1nextnext ＝ ListNode(4)构建测试链表 l2l2 ＝ ListNode(1)l2next ＝ ListNode(3)l2nextnext ＝ ListNode(4)merged_list ＝ mergeTwoLists(l1, l2)打印合并后的链表while merged_list:print(merged_listval, end=＂＂）merged_list ＝ merged_listnext｀｀｀五、实验结果与分析运行测试函数，得到合并后的链表输出为：1 1 2 3 4 4 。
c课程设计链表实验报告
c课程设计链表实验报告一、教学目标本节课的教学目标是让学生掌握链表的基本概念和操作，包括链表的定义、节点的结构、链表的创建、插入、删除和遍历等操作。
通过本节课的学习，学生应该能够理解链表的工作原理，熟练使用链表进行数据存储和操作，并能够编写相应的程序实现链表功能。
具体来说，知识目标包括：1.了解链表的定义和特点；2.掌握链表的基本操作及其时间复杂度；3.理解链表在数据存储和处理中的应用场景。
技能目标包括：1.能够使用编程语言实现链表的创建、插入、删除和遍历等基本操作；2.能够分析链表程序的正确性和性能；3.能够运用链表解决实际问题，如实现一个简单的链表排序算法。
情感态度价值观目标包括：1.培养学生的逻辑思维能力和问题解决能力；2.激发学生对计算机科学和编程的兴趣；3.培养学生的团队合作意识和代码规范意识。
二、教学内容本节课的教学内容主要包括链表的基本概念和操作。
具体安排如下：1.链表的定义和特点：介绍链表的概念、节点结构以及链表的两种类型（单向链表和双向链表）；2.链表的创建：讲解如何创建一个链表，包括初始化节点和链接节点的方法；3.链表的插入操作：介绍如何在链表中插入一个新节点，包括头插法和中插法的实现；4.链表的删除操作：讲解如何删除链表中的一个节点，包括头删法和中删法的实现；5.链表的遍历操作：介绍如何遍历链表，实现链表中各个节点的访问和打印；6.链表的应用场景：举例说明链表在实际编程中的应用，如链表排序算法。
三、教学方法为了达到本节课的教学目标，将采用以下教学方法：1.讲授法：讲解链表的基本概念和原理，引导学生理解链表的工作方式；2.案例分析法：通过分析典型链表程序，让学生掌握链表的操作方法和技巧；3.实验法：让学生动手编写链表程序，培养学生的实际编程能力和问题解决能力；4.讨论法：学生进行小组讨论，分享学习心得和编程经验，提高学生的团队合作意识。
四、教学资源为了支持本节课的教学内容和教学方法的实施，将准备以下教学资源：1.教材：《数据结构与算法》；2.参考书：《链表：原理与实现》；3.多媒体资料：PPT课件、链表操作视频教程；4.实验设备：计算机、编程环境。
链表的基本操作实验报告
链表的基本操作实验报告链表的基本操作实验报告引言：链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
链表相较于数组拥有更灵活的操作，能够动态地增删节点。
本实验旨在通过实际操作链表，加深对链表基本操作的理解和掌握。
实验目的：1. 理解链表的基本概念和结构；2. 学会链表的插入、删除和遍历操作；3. 掌握链表的相关算法。
实验过程：1. 创建链表首先，我们需要创建一个链表。
链表可以是单链表、双链表或循环链表，本次实验我们选择创建一个单链表。
创建链表的过程如下：（1）定义一个链表的节点结构，包含数据和指向下一个节点的指针；（2）创建头节点，并将头节点的指针指向NULL，表示链表为空。
2. 插入节点链表的插入操作可以在链表的任意位置插入节点。
我们可以选择在链表的头部、尾部或指定位置插入节点。
下面以在链表头部插入节点为例，介绍插入节点的过程：（1）创建一个新节点，设置新节点的数据；（2）将新节点的指针指向原头节点；（3）将头节点的指针指向新节点，完成插入操作。
3. 删除节点链表的删除操作可以删除链表中的任意节点。
同样，我们可以选择删除链表的头部、尾部或指定位置的节点。
以下是删除链表头部节点的步骤：（1）将头节点的指针指向下一个节点，跳过原头节点；（2）释放原头节点的内存空间。
4. 遍历链表链表的遍历操作用于访问链表中的每个节点。
通过遍历链表，我们可以获取链表中的所有数据或执行特定的操作。
链表的遍历操作如下：（1）从链表的头节点开始，依次访问每个节点；（2）对每个节点执行相应的操作，如打印节点的数据。
实验结果：通过以上实验过程，我们成功地创建了一个链表，并实现了链表的插入、删除和遍历操作。
链表的基本操作能够灵活地处理数据，适用于各种场景。
链表的插入和删除操作可以在O(1)时间内完成，相较于数组的插入和删除操作具有更高的效率。
实验总结：链表作为一种常见的数据结构，具有灵活性和高效性的特点。
数据结构实验报告-链表
数据结构实验报告-链表院系：计算机学院实验课程：数据结构实验实验项⽬：实验⼆利⽤链表实现学⽣健康系统指导⽼师：开课时间：专业：计算机类班级：学⽣：学号：实验⼆利⽤链表实现学⽣健康系统1.综设实验题⽬利⽤链表实现学⽣健康系统2.中⽂摘要本实验是利⽤链表这⼀经典的数据结构来实现⼀个学⽣健康系统，从⽽学⽣的健康信息和相应的个⼈信息可以很⽅便地通过这个系统进⾏增、删、查、改等操作。
3.关键词课程名称数据结构实验实验项⽬利⽤链表实现学⽣健康系统实验时间年⽉⽇实验指导⽼师实验评分链表健康系统C++4.前⾔实验⽬的：想要通过链表这⼀数据结构来实现学⽣健康情况管理的⼏个操作功能。
实验意义：⽅便相关⼈员对学⽣健康信息的管理和操作。
实验内容：主要是新建学⽣健康系统、插⼊学⽣的数据、删除学⽣的数据、从⽂件读取学⽣健康数据、将学⽣的健康等信息写⼊到⽂件、查询指定学⽣的相关信息、在屏幕上输出学⽣相关信息等功能。
健康表中学⽣的信息有学号、姓名、出⽣⽇期、性别、⾝体状况等。
5.实验设计由于该实验主要涉及到链表这⼀存储结构，因此整个实验的关键点便在于对链表这个数据结构的建⽴和操作上。
常见的链表的操作有：建⽴链表、往链表中插⼊数据、从链表中删除数据、查找链表中的元素、修改链表中的元素、销毁链表。
由此，经过对问题的仔细分析之后，发现我们所要实现的健康系统的增、删、查、改等功能与链表这⼀数据结构的关系是：增加学⽣数据相当于往链表中的插⼊数据的操作；删除学⽣数据相当于从链表中的删除数据的操作；查找学⽣数据相当于链表中的查找元素的操作；修改学⽣数据相当于链表中的修改元素的操作；因此，我们可以直接⽤链表来存储所有学⽣的信息，每⼀个学⽣的信息集就是链表中的⼀个节点，这样，就使得我们的健康系统的问题归约到了链表的实现问题上了。
在这个链表的设计上，每⼀个节点包含有相应学⽣的所有信息和⼀个指向下⼀个节点的指针，学⽣的信息包括：学号、姓名、出⽣⽇期、性别和健康信息，分别采⽤C++中的string, string, int, bool 和string类型来表⽰。
链表-实验报告
实验2 链表实验概述：一、实验目的本次实习的主要目的是为了使学生熟练掌握链表的基本操作以及在链式存储结构上的实现，包括创建、插入、删除、查找、以及合并等操作。
二、实验要求掌握链表存储方式，熟悉链式存储结构。
三、实验步骤用链表结构实现对多项式初始化、创建、插入、删除等运算。
步骤：输入第一个多项式：7x+2x3输入第二个多项式：8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果：15x+2x3+9x5实验结果如图：四、实验环境（使用的软件和设备）（1）实习器材：多媒体计算机。
（2）实习地点：校内多媒体机房。
（3）实习软件: Win-TC实验内容：【实验过程】（实验步骤、记录、数据、分析）实验过程（提示）输入第一个多项式：7x+2x3输入第二个多项式：8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果：15x+2x3+9x5【结果实验记录】（图形或图像）1.说明掌握情况#include<stdio.h>#include<stdlib.h>typedef struct{int sat1,sat2,sat3,sat4;}ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;LinkList InitList(){ LinkList L;L=(LinkList)malloc(sizeof(LNode)); L->next=NULL;return(L);}void InsLNode(LinkList L,ElemType x){ LinkList s,p;s=(LinkList)malloc(sizeof(LNode));s->data=x;p=L;while(p->next)p=p->next;s->next=NULL;p->next=s;}void AddPolyn(LinkList La,LinkList Lb){int sum;int a,b;LinkList pa,pb;pa=La->next;pb=Lb->next;a=pa->data.sat1;b=pb->data.sat1;sum=a+b;printf(" %dx%d exp",sum,pa->data.sat2);printf("+");printf(" %dx%d exp+",pa->data.sat3,pa->data.sat4); printf(" %dx%d exp\n",pb->data.sat3,pb->data.sat4);}void Print(LinkList L){ LinkList p;p=L->next;printf(" %dx%d exp",p->data.sat1,p->data.sat2); printf("+");printf(" %dx%d exp",p->data.sat3,p->data.sat4);}main() {LinkList La,Lb;ElemType c,b;int a,i;La=InitList();Lb= InitList();printf("Please input polynomial La:\n");scanf("%d %d",&c.sat1,&c.sat2);scanf("%d %d",&c.sat3,&c.sat4);InsLNode(La,c);printf("Please input polynomial Lb:\n");scanf("%d %d",&b.sat1,&b.sat2);scanf("%d %d",&b.sat3,&b.sat4);InsLNode(Lb,b);printf("polynomial La:");printf("\n");Print(La);printf("\n");printf("polynomial Lb:");printf("\n");Print(Lb);printf("\n");printf("La+Lb:");printf("\n");AddPolyn(La,Lb);printf("\n");getch();}2.裁图说明实验结果【心得体会、问题和建议】成绩：指导教师签名批阅日期：。
链表的基本操作实验报告
《数据结构》实验报告学号1445203105 姓名王胜博班级软件5班成绩实验名称实验三链表的基本操作是否原创是一、实验要求编程实现链表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。
二、实验目的通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C语言中指针的操作。
和实验2对比，掌握线性结构两种不同存储方式的区别。
三、设计思想用函数执行各个功能，随机插入元素四、主要源代码#include<stdio.h>#include<stdlib.h>#include<time.h>typedef int ElemType;typedef struct Node{ElemType data;struct Node *next;}Node, *LinkList;void InitList(LinkList *L){*L=(LinkList)malloc(sizeof(Node));if(!(*L))printf("存储分配失败\n");(*L)->next=NULL;}void DestroyList(LinkList L){LinkList p;while(L){p=L->next;free(L);L=p;}}int ListLength(LinkList L){LinkList p;int i=0;p=L->next;while(p){i++;p=p->next;}return i;}int GetElem(LinkList L,int i,ElemType &e){ LinkList p;p=L->next;int j=1;while(p&&j<i){p=p->next;++j;}e=p->data;return e;}int GetElemLo(LinkList L,int i,ElemType &e){ LinkList p;p=L->next;int j=1;while(p->data!=i&&j<=ListLength(L)){p=p->next;++j;}e=j;return e;}void FindPre(LinkList L,int x){LinkList p;p=L;if(p->next->data==x){printf("第一个元素没有前驱\n");}else{while(p->next){if(p->next->data==x){printf("%d的前驱结点是:%d\n",x,p->data);break;}else{p=p->next;}}}}void FindNext(LinkList L,int x){LinkList p;p=L->next;while(p){if(p->data==x){printf("%d的后继结点是:%d\n",x,p->next->data);break;}else{p=p->next;}if(p->next==NULL){printf("最后一个元素没有后继\n");break;}}}void LinkInset_L(LinkList &L,int i,ElemType e){ LinkList p;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("i小于1或者i大于表长加1\n");LinkList s;s=(LinkList)malloc(sizeof (Node));s->data=e;s->next=p->next;p->next=s;}void ListDelete_L(LinkList &L,int i,ElemType &e){ LinkList p,q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!p->next ||j>i-1)printf("删除位置不合理\n");q=p->next;p->next=q->next;e=q->data;free(q);printf("已删除的元素是:%d\n",e);}void visit(ElemType e){printf("%d,",e);}void ListTraverse(LinkList L){LinkList p=L->next;while(p){visit(p->data);p=p->next;}printf("\n");}void CreatListTail(LinkList *L,int n){LinkList p,r;int i;srand(time(0));*L=(LinkList)malloc(sizeof(Node));r=*L;for(i=0;i<n;i++){p=(Node *)malloc(sizeof(Node));p->data=rand()%100+1;r->next=p;r=p;}r->next=NULL;}int main(){LinkList L;int opp;printf("可执行的操作有:\n");printf("1.初始化或重置链表\n");printf("2.随机插入元素\n");printf("3.显示链表中数据元素个数\n");printf("4.输出所输入的链表元素\n");printf("5.所指位序的元素值\n");printf("6.链表已存在元素的位序\n");printf("7.请输入元素，求直接前驱\n");printf("8.请输入元素，求直接后继\n");printf("9.在第i个位置插入元素\n");printf("10.删除第i个元素\n");printf("11.销毁链表\n");printf("12.退出\n");printf("\n");printf("请输入你的选择:\n");do{scanf("%d",&opp);switch(opp){case 1:{InitList(&L);printf("链表已初始化\n");printf("下一步操作:");break;}case 2:{int n;printf("输入插入元素个数:");scanf("%d",&n);CreatListTail(&L,n);printf("下一步操作:");break;}case 3:{printf("链表中元素的个数是:%d\n",ListLength(L));printf("下一步操作:");break;}case 4:{ListTraverse(L);printf("下一步操作:");break;}case 5:{int m,e;printf("输入要取元素的位置:");scanf("%d",&m);if(m>ListLength(L)){printf("输入有误\n");}else{GetElem(L,m,e);printf("该元素是:%d\n",e);}printf("下一步操作:");break;}case 6:{int i,e;printf("输入要取的元素:");scanf("%d",&i);GetElemLo(L,i,e);printf("该元素的位置是:%d\n",e);printf("下一步操作:");break;}case 7:{int x;printf("要求哪个元素的前驱？");scanf("%d",&x);FindPre(L,x);printf("下一步操作:");break;}case 8:{int x;printf("要求哪个元素的后继？");scanf("%d",&x);FindNext(L,x);printf("下一步操作:");break;}case 9:{int i,e;printf("在哪个位置插入元素?");scanf("%d",&i);if(i>ListLength(L))printf("输入有误\n");else{printf("插入的新元素是:");scanf("%d",&e);LinkInset_L(L,i,e);printf("新链表:");ListTraverse(L);}printf("下一步操作:");break;}case 10:{int i,e;printf("要删除哪个位置的元素？");scanf("%d",&i);if(i>ListLength(L))printf("输入有误\n");else{ListDelete_L(L,i,e);printf("新链表:");ListTraverse(L);}printf("下一步操作:");break;}case 11:{DestroyList(L);printf("链表已销毁!\n");printf("下一步操作:");break;}case 12:{printf("谢谢使用\n");break;}default:{printf("输入错误，请重新输入\n");break;}}}while(opp!=12);return 0;}五、调试与测试数据六、实验总结。
多项式的链表表示及运算实验报告
多项式的链表表示及运算实验报告
一、实验目的
本次实验旨在了解多项式的链表表示及运算，学习应用链表实现多项式的加减乘除运算。
二、实验原理
多项式是数学中一种常见的运算方式，它由若干个单项式（即常数、未知数以及未知数不同次幂的积）求和组成。
多项式通常可以用数组或链表来表示。
本实验采用链表表示多项式。
链表表示多项式可以用一个链表来存储多项式中的每一项，链表节点存储着每一项的系数和指数。
链表的头节点指向第一项。
在链表表示多项式时，我们可以定义一个结构体来表示节点，包含两个成员变量：系数和指数。
当我们对多项式进行加减乘除运算时，首先需要将多项式转换成链表形式，然后按照运算规则进行运算，最后将运算结果转换为多项式形式。
三、实验步骤
1、定义多项式节点结构体，包含系数和指数两个成员变量；
2、编写函数从命令行读取用户输入的多项式，按照指数降序的方式将多项式转换成链表形式；
3、编写函数完成多项式相加、相减、相乘、相除等运算，每种运算均需要将两个多项式转换成链表形式后进行；
4、编写函数将链表形式的多项式转换成多项式字符串；
5、在主函数中调用上述函数，进行多项式的读取、运算、转换并输出结果。
四、实验总结
本次实验学习了多项式的链表表示及运算，掌握了链表的基本操作，了解了多项式的四则运算的实现。
在实验中，我们成功地用链表实现了多项式的加减乘除运算，实现了从命令行读取多项式，并将其转换为链表，最后将链表转换为多项式字符串输出。
通过本次实验，我更加深刻地理解了链表及其应用，学会了运用链表实现算法，提高了编码能力。
创建链表和链表操作实验报告
创建链表和链表操作实验报告数据结构实验报告报告名称创建链表和链表操作专业网络工程班级1001 学号20XX03120XX9 姓名张剑指导教师陈淑红李珍辉黄哲20XX年5月4 日、实验目的：掌握线性表的基本操作：插删除、查找以及线性表入、合并等运算在顺序存储结构和链接存储结构上的运算。
二、实验内容与基本要求：实验内容：1. 创建单链表2. 在链表上进行插入、删除操作；3 .设计一个程序，用两个单链表分别表示两个集合，并求出这两个集合的并集。
实验要求：1. 在上机前写出全部源程序； 2 .能在机器上正确运行程序；3 .用户界面友好；三、概要设计：1.单链表的存储结构：teypedef structLNode{ ElemType date;struct LNond *next; }LNode *LinkList;2. 单链表的插入操作：Status ListTnsert-L(LinkLIst &L, int i, ElemType e ){//再带头结点的单链线性表L中的第i个位置之前插入元素 e P=l; j=0;While(p&&jnext;++j;}//寻找第i-1个结点if(!p||j>i-1) return ERROR; //i 小小于1 或者大于表长+1 s=(LinkList) malloc (sizeof(LNode)); //生成新结点s->date=e; s->next=p->next; // 插入L 中p->next=s; return ok;}//ListTnsert L3. 单链表的删除操作：Status ListDelete-L(LinkLlst &L, int i, ElemType &e ){//在带头结点单链线性表L中，删除低i个元素，并e返回其值p=l; j=0;while(p->next&&jnext; ++j; }if(!(p->next)||j>i-1)return ERROR; // 删除位置不合理q=p->n ext ; p->n ext=q->n ext; //删除并释放结点e=q->date free(q); return OK;} //ListDelete-L4. 链表的合并操作：void MergeList-L(LinkList & La, LinkList & Lb, LinkList &Lc){ // 已知单链表La和Lb的元素值//合并单链表La和Lb，得到新的单链表Lc pa=La->next; pb=Lb->next;lc=pc=La; //用La的头结点作为Lc的头结点while(pa&&pb){ if(pa->datedate){pc->n ext =pa; pc=pa; pa=pa->n ext; }else {pc->n ext=pb;pc=pb;pb=pb->n ext;} }Pc->next=pa pa:pb; // 插入剩余段free(Lb); // 释放Lb头结点} //MergeList-L 四、详细设计：#include #include #include #include typedefint status;typedef char ElemType; typedef struct Lnode {ElemType data;//定义链表结点类型 struct Lnode *next; }Lnode,*Linklist;status initlist(Linklist *L) {// 单链表的初始化 *L=(Lnode *)malloc(sizeof(Lnode)); //创建头结点(*L)->next=NULL;return 1;}status Createlist(Linklist L) { Lnode *p,*q;int i,j=1,n;ElemType m,M; q=L;请输入你要输入单链中元素的个数\\n\{p=(Lnode *)malloc(sizeof(Lnode)); 请输入％个元素:\scanf(\p->n ext=q->n ext;j++;} return 1;}status Listinsert(Linklist { int j=0;输入错误!\\n\ returnscanf(\ scanf(\for(i=n;i>0;i--)scanf(\ p->data=M; q->n ext=p;q=p;L,int i,ElemType e)++j; }Lnode *p=L,*s; while(p&&jnext;0; }s=(Lnode *)malloc(sizeof(Lnode)); s->data=e;//创建自己规定长度的单链表//回车缓冲区//回车缓冲区//向单链表指定位置插入一个元素s->next=p->next; p->next=s; return 1; }status Listdelete(Linklist L,int i,ElemType *e){ //删除单链表指定位置的元素，返回删除后的。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
链表实验报告————————————————————————————————作者: ————————————————————————————————日期：《数据结构》实验报告二系别:嵌入式系统工程系班级:嵌入式1１0０3班学号:１1160400３１4姓名：孙立阔日期：2012年４月９日指导教师:申华一、上机实验的问题和要求：单链表的查找、插入与删除。
设计算法,实现线性结构上的单链表的产生以及元素的查找、插入与删除。
具体实现要求:1.从键盘输入1０个字符，产生不带表头的单链表，并输入结点值。
2.从键盘输入1个字符,在单链表中查找该结点的位置。
若找到,则显示“找到了”；否则,则显示“找不到”。
3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出单链表所有结点值,观察输出结果。
4.从键盘输入１个整数,表示欲删除结点的位置，输出单链表所有结点值,观察输出结果。
5.将单链表中值重复的结点删除,使所得的结果表中个结点值均不相同,输出单链表所有结点值,观察输出结果。
6.删除其中所有数据值为偶数的结点，输出单链表所有结点值,观察输出结果。
7.（★)将单链表分解成两个单链表A和B，使A链表中含有原链表中序号为奇数的元素,而B链表中含有原链表中序号为偶数的元素，且保持原来的相对顺序，分别输出单链表Ａ和单链表B的所有结点值，观察输出结果。
二、程序设计的基本思想，原理和算法描述:(包括程序的结构,数据结构，输入/输出设计,符号名说明等）创建一个空的单链表，实现对单链表的查找，插入,删除的功能。
三、源程序及注释：#dｅfiｎｅOK 1#defｉne EＲＲOR 0#ｄefiｎe INFEASIBLE －1#defｉne OVEＲFＬOW －2#deｆine TRUE 1#deｆine FAＬSE ０#defiｎe List_Init_Sｉze10＃defineＬｉstIncreｍent 2ｔyｐｅｄef char ET;tyｐeｄef ET *Ep;ｔｙpedeｆｉnt Statｕs;tｙpedｅｆstｒuct LNode{ﻩＥＴdaｔa;sｔrｕct ＬＮode *nｅxt;}LＮode, *ＬinkＬist;／*ＬiｎkＬｉsｔLa,Ｌb,Lc;*／ﻺ#ｉncｌuｄe"sｔdio.h＂#inclｕdｅ"alｌｏｃ.h"/＊Dｉsplay theｌｉnkｌｉｓt＇s eｌｅmｅnts. ＊/vｏid prｉnｔlk（ＬinkLｉst L) {LinkLiｓt p;ｐ=L->nｅｘt;while (p){ｐrｉntf(＂%c -＞",p->data);ｐ＝p->nｅxｔ;}ｐrinｔf("NＵLL\n＂);}/*Crｅａt ｌinｋlist from head node. *／voｉd CreatＬist(ＬinkＬisｔ＊L,iｎｔn){int i；LiｎkLｉｓｔｐ，q;EＴstr[20],c;p=（ＬinkList)mａｌｌoc(sｉzｅｏf（LＮｏde))；p->nexｔ=ＮＵＬＬ;*L = q = p;prｉntf("Ｐlｅase input thｅｄata: ")；for(ｉ=n;i＞０；i--) {p=(LｉnkLｉｓｔ)maｌｌoｃ(siｚｅof(LNoｄe）);c = getcｈe（)；/*sｃanf(＂％ｃ",&c);＊/printf("\ｎ\n");ｐ->ｄaｔa = c；ｐ－>next = q-＞next;q->next = p；}｝/*Iniｔｔhｅｌｉｎklist. */void Ｉnｉt（LｉnkＬist *L) {int n;printf("Pｌease ｉｎｐuｔthe ｎuｍｂｅr of the node : "); sｃanf（＂%d",&n);CreatLiｓt(L,n）;}/* Ｇet tｈe ｖａluｅoｆeleｍent I; *／int GｅtElem(LiｎkList L,int i,ET *e) {ｉnｔj=1；LinkLiｓt p；p=Ｌ-＞neｘｔ;while（p＆&j<i) {p=ｐ－>next;++j;}if(!ｐ|｜j>ｉ）rｅturn TRUE;*e=ｐ->data；reｔuｒn ＦALＳＥ；}/*Inｓeｒt a eleｍeｎt after Ｉ*／int ＬistInserｔ(ＬinkＬisｔ*L,inｔi,ET e) ｛/＊Ａdd ｙour owｎｃｏdes．*／}/*Deleｔｅthe elｅment I＊/int LisｔDｅletｅ（LinkList *Ｌ，iｎt i,ET*e){／* Adｄyour own ｃodes. *／}inｔInsert(LｉnｋList *L){ｉnt i,flａg;ET ｄaｔａ;printf("Ｐlease inpuｔｔｈeｐoｓｉtiｏn : ");ｓｃaｎf(＂％d",&ｉ);prｉnｔf("Please ｉnput tｈｅdaｔa : ＂）;daｔa ＝getche();/*scａnｆ("%c＂,&ｄatａ);＊／fｌaｇ= LiｓtIｎsert(L，i,dａta);retｕｒn flag;}Statｕs Dｅlｅte(LｉnkList*L）｛inｔi,flag;ＥT e；printf(＂Pｌeasｅinpｕt the nuｍber：");sｃanf("%d",＆i);fｌag ＝ＬｉstDelｅte（Ｌ,ｉ，&e)；printf("Ｄｅlｅｔedｅlemenｔiｓ%c\n",e);rｅｔurnｆlａg;}／＊Fｉnd tｈe eｌemeｎt'ｓposｉtｉoｎ．*/inｔLocateＥleｍ（ＬiｎkLiｓt Ｌ,ＥＴe) {int i＝0;LｉｎkLiｓt p；p ＝L->next;wｈile (p) {i++；if(p-＞dａtａ== ｅ)retuｒｎi;｝return 0;｝/*Adｄthe Lb afteｒthe Lａ．*/ｖｏｉd Uｎion( LiｎkList *Ｌa ,ＬｉｎkLｉst*Lb)｛LinkLisｔpa,pb;／*Aｄd yoｕｒowｎcodes. *／}／*Merge tｗo seqｕence into oｎe,dｏn＇t cｈange anyｅlemｅnts intｈeｓe tｗｏlｉnk ｌiｓts. Joiｎｔｗoｓeｑｕence to one. ＊/voｉd MeｒｇｅLisｔ（LinkList*Ｌ1,LｉｎｋLｉst ＊L2，LinkLｉsｔ*L3) ｛LinkLｉｓt pa，pb,pｃ;/＊Ａddｙour own codes. */}／*Liｓt the Mｅnｕ*/voidＭｅｎuLiｓｔ（){printf("\n\n\ｎ＝＝==＝===＝＝========＝＝====＝=\n");pｒiｎtf(" １**＊**＊＊Iｎseｒt LA＼ｎ＂);printf(" 2*****＊* Inｓｅrt LＢ\ｎ")；pｒｉnｔf(＂3＊****** Ｄelｅte LA＼n");priｎtf(" 4 ******* Dｅleｔe LB＼n＂);priｎtf（" 5 ******* Uniｏn LA and LB＼n"）；printf(" 6 ＊***＊**MergｅLＡand LB to LC\n＂); prｉntf(" 7 ＊**＊**＊prinｔLinｋList\n＂);ｐrinｔｆ（" 8 ***＊*＊＊Ｅxit\n＂);ｐrｉｎｔf(＂＝====＝=＝==＝=====＝====＝==＝=\n＂); }/*Seｌｅcｔthｅｍenu*/voｉｄMenuSeｌecｔ(LiｎkLｉst *La,LiｎkＬist *Lb){ inｔsｅlｅct,ｄone=1;ＬｉnkLｉst Ｌc;whｉle (ｄone) {MeｎuＬiｓｔ（);prinｔf(＂input thｅoｐｅrating ｃode : "）;scanf（＂%ｄ＂,&seｌeｃt);swiｔcｈ(ｓelect)｛caｓe1：Inseｒt(La）；brｅaｋ;ﻩ case 2：Insert(Lb）;brｅａk;ﻩ case３：Deletｅ(La);ｂreaｋ;ﻩ case ４: Delete(Lｂ);bｒeａk;ﻩ case５: Unｉon（Ｌａ，Ｌｂ);brｅak；ﻩ caｓｅ6: MergeLiｓｔ(La,Lb,&Lc)；ﻩﻩｐrｉntf("LC: ＂);printlｋ（Lc）；ﻩbreａk;case 7：ｐrintf("LA: ");prinｔｌk（*Lａ)；ﻩ pｒｉntf("ＬB: ＂);printlk(*Lb);break；ｃasｅ８: done=０;bｒeaｋ;ﻩｄefault: pｒiｎtf(＂ERROR\n");}｝}mａin( ){LinkList La,Ｌb;ｐrｉntf(＂LA");Iｎit（＆Ｌa) ；ｐrintｌk（La);prｉntf（＂ＬB");Inｉt(&Lb) ；pｒｉntlk(Lb);MenuSeleｃｔ(&La,&Lb)；｝调试后的代码:#ｉncｌude<ｓtdio.h>#ｉnｃlude＜ｍａllｏc.h>typｅdef iｎｔ DataType;ｔypｅdef struct ＬinkList{int data；ｓｔruct LinｋList ＊ｎext;}LinｋList；void PｒiｎtList(LｉnkＬist *h)；LinkLisｔ* IniｔLisｔ()；vｏiｄ InsList(ＬinｋＬisｔ *h,int i,ＤatａＴyｐe x）; voｉd LocLisｔ（LiｎkLiｓt *h,int i);vｏid DelList(LｉｎkList *ｈ,iｎｔi）；void maｉn(){iｎt i,ｎ，ｘ；LinkList *ｈ；ﻩh＝IniｔＬist()；PrinｔList（h);printｆ("\ｎ==＝＝=====＝=\n");printf("０--－－－-EXIT\n＂）；ﻩｐrｉntf("1--－---INSEＲT\ｎ");ﻩprｉnｔf（"２--－－-－DEＬEＲＴ\n＂);ﻩpｒｉｎtf("３--－---LOCＥＲT\n")；pｒintｆ(＂\n＝=＝＝＝＝＝＝===\ｎ\n＼n");ﻩwhile(1)ﻩ｛ﻩprintｆ("＼nＳelect\n");ﻩsｃaｎf("%d",&ｎ);switcｈ(n)ﻩ{ﻩcaｓe 0：ﻩﻩﻩexit（０);ﻩbｒｅaｋ；ﻩﻩcase 1:ﻩprintf(＂please inｐuｔｔhｅ position:\n");ﻩｓcanｆ(＂%d",&ｎ);ﻩﻩﻩpｒintf("please ｉｎｐuｔｔhｅ data:＼n"）;ﻩｓcanf("%ｄ",&x);IｎsLｉsｔ(h,n,x);ﻩＰrinｔLisｔ(h);break;ﻩcase 2:pｒintｆ("pｌease input you wanｔｔo delete poｓitiｏn：\n＂);ﻩﻩﻩｓcanf("%d",＆i);ﻩﻩDｅlList（h,i）;ﻩﻩＰrintＬist(h);ﻩbreaｋ;ﻩcase ３:ﻩﻩprintf（"ｐleaｓe inｐut ｙou wａnt to ｓearch pｏsition:＼n")；ﻩsｃanｆ（"%ｄ＂,&i）;ﻩﻩLocList(h,ｉ)；ﻩPriｎtList(ｈ);ﻩﻩｂrｅak;ｄeｆault :ﻩprintf("eｒror＼n"）;ﻩｂｒｅａk；ﻩ｝}ﻩ}LinkLｉst＊ IｎitＬist(）{ﻩ LinｋLｉst *ｈ,*s,*r;ﻩ int a，ｃ,ｉ;ﻩ h=(ＬiｎkLｉst*)mａlｌoｃ(sizeｏf(LinｋLiｓt）)；ﻩh-＞ｎｅxt=NＵＬＬ;r＝h;ﻩ prｉnｔf（"ｐleａse inpuｔ some linｋ's leｎgｔh:"）;ﻩscaｎｆ(＂%d"，&c）；ﻩ for(ｉ=０;i<c;i+＋){sｃanf("%ｄ＂,&ａ);ﻩ s=(LinｋＬｉst*)maｌloc(sizeｏf（LinkLiｓt)）; ﻩ s-＞ｄata＝a;ﻩﻩｓ->nexｔ=ｒ->nｅｘt；ﻩr->nｅxt=s；ﻩﻩ r=ｒ-＞nｅxt;｝ﻩｒetuｒn h;｝voｉd IｎsLisｔ(LinkList *h,ｉnt i,DataType x){LinkＬist *s，*p；ﻩiｎt j＝1;ﻩp=h;ｓ=（LinkList＊)maｌｌoｃ(siｚeｏf(LｉｎkＬist)); ﻩfoｒ(j=1;j<i ＆＆p!=NULL；j+＋)p＝ｐ－＞next;ﻩif(p=＝NUＬＬ)pｒintf("erｒor!\n");ﻩelｓe{ﻩs-＞datａ=x;ﻩs－>next=p->ｎｅｘt;p-＞ｎeｘt＝s;ﻩﻩ}}voｉｄ DelLiｓt(LinkLiｓt ＊h,int i）{ＬiｎｋList *p,*q;ﻩinｔ j=１;p=h->ｎｅｘｔ;ﻩq=ｐ->next;ｗhilｅ（j!=i-1 ＆& q!=NULL)ﻩ｛ﻩp=ｐ-＞nｅxt;ﻩｑ=q－>next;ﻩﻩj++;ﻩ｝if(q=＝ＮULL）pｒｉntf（"ｅrror!\n"）;elｓeﻩ{ｐ->nｅｘt=q－＞ｎeｘt;ﻩﻩfreｅ(ｑ)；}｝voiｄ LｏcＬist(LinｋLisｔ＊h,int i){LinkLｉｓt ＊p;ｉnｔj=1;p=h－＞neｘt;ﻩwhile(p!=ＮULL){ﻩiｆ(p->data==i)ﻩ{ﻩpｒintf（＂position iｓ％d\n",ｊ);ﻩbrｅak;ﻩ}ﻩp＝ｐ->neｘt;ﻩﻩj+＋；}iｆ(p==NULL)ﻩprinｔf("NＯ thiｓ data ｉｎthｅ link＼ｎ"); }void ＰriｎtLｉst（LｉnkLｉst*h）{LinｋＬist *p;ｐ=h->ｎｅxｔ;ﻩwhilｅ（ｐ！=NULＬ)ﻩ{ﻩprintf(" %ｄ->",ｐ->datａ);ｐ=p-＞neｘｔ;ﻩ｝}四、运行输出结果：五、调试和运行程序过程中产生的问题及采取的措施：问题:子函数和主函数前后的调用出现问题,指针的调用不是太明白。