实验报告:链表
创建链表和链表操作实验报告
![创建链表和链表操作实验报告](https://img.taocdn.com/s3/m/cead8d8ca8114431b80dd83d.png)
创建链表和链表操作实验报告数据结构实验报告报告名称创建链表和链表操作专业网络工程班级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){ //删除单链表指定位置的元素,返回删除后的。
链表实验报告
![链表实验报告](https://img.taocdn.com/s3/m/314609b5910ef12d2bf9e715.png)
《数据结构》实验报告二系别:嵌入式系统工程系班级:嵌入式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;}}四、运行输出结果:五、调试和运行程序过程中产生的问题及采取的措施:问题:子函数和主函数前后的调用出现问题,指针的调用不是太明白。
链表实验报告
![链表实验报告](https://img.taocdn.com/s3/m/4faa3eb7d1f34693daef3e64.png)
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);六.运行结果七.心得体会通过本次实验我对链表有了更深的了解,对链表的插删操作、遍历、查找等基本上掌握了。
链表的实验报告
![链表的实验报告](https://img.taocdn.com/s3/m/e3fffe73011ca300a6c390ec.png)
front->next=alist.front->next;
cout<<"复制构造函数"<<endl;
}
//touchafa
template<class T>
linklist<T>::linklist(T a[],int n)
{
front=new Node<T>;
front->next=NULL;
找到要插入的结点的前一个结点新结点的指针域指向p然后p前面的结点指向这个新的结点这样这个新的结点就插入到了链表里面3代码的时间复杂度
数据结构实验报告
1.
2.
2.1
2.2
2.3
算法一:
template<class T>
linklist<T>::linklist(T a[],int n)
{
front=new Node<T>;
T x=q->data;
delete q;
return x;
}
[1]算法功能:删除链表中的某个元素
[2]思想:删除就是先找到要删除的元素的前面的元素,然后前面的这个结点直接指向这个结点的下一个结点,然后再把这个指针删除。
[3]时间复杂度:O(n)
[4]代码逻辑:
1.从第一个结点开始,查找第i-1个元素,设为P指向该结点,如果查找失败则抛出异常
front->next=NULL;
for(int i=n-1;i>=0;i--)
{
Node<T>*s=new Node<T>;
s->data=a[i];
链表基本操作实验报告
![链表基本操作实验报告](https://img.taocdn.com/s3/m/569e66685ef7ba0d4a733b91.png)
实验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("其他键退出。
链表实验报告1
![链表实验报告1](https://img.taocdn.com/s3/m/fd00ea4bdcccda38376baf1ffc4ffe473368fd1e.png)
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
![链表实验报告总结doc](https://img.taocdn.com/s3/m/79940511d5bbfd0a78567320.png)
链表实验报告总结篇一:顺序表,链表总结实验报告实验报告实验目的:学生管理系统(顺序表)实验要求: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下的图形界面以及学会文件的操作等功能,为以后的学习打下基础。
数据结构顺序表链表试验报告
![数据结构顺序表链表试验报告](https://img.taocdn.com/s3/m/e4e4ee5ea9114431b90d6c85ec3a87c241288a7c.png)
数据结构顺序表链表试验报告数据结构试验报告一、引言数据结构是计算机科学中非常重要的一个概念,它用于组织和存储数据,以便能够高效地进行检索和操作。
顺序表和链表是两种常见的数据结构,它们在实际应用中都有各自的优势和局限性。
本报告将对顺序表和链表进行试验比较,以评估它们在不同场景下的性能和适合性。
二、实验目的本次试验的目的是比较顺序表和链表在插入、删除和查找操作上的性能差异,并分析其时间复杂度和空间复杂度。
通过实验结果,可以对不同场景下选择合适的数据结构提供参考。
三、实验内容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。
链表实验报告
![链表实验报告](https://img.taocdn.com/s3/m/8ac16925a9956bec0975f46527d3240c8447a1f1.png)
链表实验报告一、实验目的链表是一种常见的数据结构,本次实验的主要目的是深入理解链表的概念、原理和操作,通过实际编程实现链表的创建、插入、删除、遍历等基本操作,掌握链表在数据存储和处理中的应用,提高对数据结构的理解和编程能力。
二、实验环境本次实验使用的编程语言为 C 语言,开发工具为 Visual Studio Code。
三、实验原理链表是一种动态的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
链表的优点是可以灵活地进行插入和删除操作,不需要像数组那样移动大量的数据。
链表分为单向链表、双向链表和循环链表等。
单向链表只有一个指向下一个节点的指针,双向链表有指向前一个节点和后一个节点的指针,循环链表的尾节点指向头节点,形成一个环形结构。
四、实验步骤1、单向链表的创建定义链表节点结构体,包含数据域和指针域。
编写创建链表的函数,通过动态分配内存创建链表节点,并将节点连接起来。
2、单向链表的插入操作实现头部插入、尾部插入和中间插入的函数。
在插入时,需要处理指针的更新,确保链表的连接正确。
3、单向链表的删除操作编写删除指定节点的函数。
删除节点时,要释放被删除节点的内存,并更新相邻节点的指针。
4、单向链表的遍历实现遍历链表并打印节点数据的函数。
5、双向链表的创建与操作类似于单向链表,定义双向链表节点结构体,并实现创建、插入、删除和遍历的函数。
注意双向链表中指针的更新方式与单向链表的不同。
6、循环链表的创建与操作定义循环链表节点结构体,创建循环链表。
实现循环链表的插入、删除和遍历操作,处理好尾节点与头节点的连接。
五、实验结果与分析1、单向链表成功创建了单向链表,并能够正确进行头部、尾部和中间的插入操作。
删除操作也能准确删除指定节点,并释放内存。
遍历输出的结果与预期相符。
2、双向链表双向链表的创建和各种操作都能正常执行,指针的更新没有出现错误。
在双向链表中,插入和删除操作的效率相对单向链表有所提高,因为可以直接通过前向指针进行操作。
实验一 链表操作实验报告
![实验一 链表操作实验报告](https://img.taocdn.com/s3/m/7fdcc61bc281e53a5802ff91.png)
实验内容按实验内容与步骤阅读理解数据结构及主函数,并完成各子函数的功能。
#include <stdio.h>#include <stdlib.h>typedef struct node{int num; //学号float height; //身高struct node *next;}Node,*Link;Link CreateLink();//创建链表Link Delete(Link H,int n); //删除节点Node *GetNode(Link H,int n);//获取节点Link Insert(Link H,Node *N);//插入节点int print(Link H);//输出/* 创建链表 */Link CreateLink(){Link H=NULL;Node *p,*q;int num=-1;//保存学号float hei=-1.0;//保存身高int min=1;//计数,至少插入3个节点printf("请输入学号:num=");scanf("%d",&num);fflush(stdin);//清空输入缓冲区,确保不影响后面的数据读取printf("请输入身高:hei=");scanf("%f",&hei);printf("\n");fflush(stdin);//清空输入缓冲区,确保不影响后面的数据读取while(num!=-1 || min<=3){if(H==NULL){p=(Node *)malloc(sizeof(Node));p->num=num;p->height=hei;p->next=NULL;min++; //计数加一H=p;}else{q=(Node *)malloc(sizeof(Node));q->num=num;q->height=hei;q->next=NULL;min++;p->next=q;p=p->next;}lab1: printf("请输入学号:num=");scanf("%d",&num);fflush(stdin);if(num==-1 && min<=3){printf("\n请至少输入3个节点\n\n");goto lab1; //跳到 lab1}if(num==-1 && min>3) //退出输入break;printf("请输入身高:hei=");scanf("%f",&hei);printf("\n");fflush(stdin);}return H;}/* 删除节点 *//* 参数 H 为表头节点 */ /* 参数 n 为删除第几个节点 */ Link Delete(Link H,int n){int i=1;Node *p,*q;if(n==1) //删除的是第一个节点{H=H->next;return H;}p=H;while(p!=NULL){if(i==(n-1)) //删除节点的前一个节点break;p=p->next;i++;}if(i==(n-1))//存在n-1个节点{q=p->next;p->next=q->next;free(q); //释放q节点}else{printf("不存在第%d个节点!\n",n);}return H;}/* 获取节点 *//* 参数 H 为表头节点 */ /* 参数 n 为第几个节点 */ Node *GetNode(Link H,int n){int i=1;Node *p,*q;p=H;q=H;if(n==1) //取的是第一个节点{p=p->next;return p;}while(p!=NULL){if(i==(n-1))//删除节点的前一个节点break;p=p->next;i++;}if(i==(n-1))//存在n-1个节点{q=p->next;p->next=q->next;return q;}else{printf("不存在第%d个节点!\n",n);return NULL;}}/* 输出 *//* 参数 H 为表头节点 */ /* 参数 N 为插入的节点节点 */Link Insert(Link H,Node *N){Node *p,*q; //q保存前一个节点if(N->num < H->num) //插入在表头之前{N->next=H;H=N;return H;}p=H;q=H;while(p!=NULL){if(N->num<=p->num){N->next=q->next;q->next=N;break;}q=p;p=p->next;}if(p==NULL) //插入在最后一个节点之后{q->next=N;N->next=NULL;}return H;}/* 输出 *//* 参数 H 为表头节点 */ int print(Link H){Node *p;p=H;if(p==NULL){printf("\n数据为空!!\n\n");return 0;}printf("\n\t学号\t\t身高\n");while(p){printf("\t %d \t\t%f\n",p->num,p->height);p=p->next;}return 0;}void main(){Link L1,L2;Node *N;printf("1:创建2个链表\n");printf("\n创建链表一\n\n");L1=CreateLink();printf("\n创建链表二\n\n");L2=CreateLink();printf("\n\n2:遍历2个链表\n");printf("\n遍历链表一:\n");print(L1);printf("\n遍历链表二:\n");print(L2);printf("\n\n3:删除第一个链表中的第二个节点 \n\n");L1=Delete(L1,2);printf("删除后的链表一:\n");print(L1);printf("\n\n 4:将第一个链表中的第二个结点移动到第二个链表适当的位置\n\n");printf("获取链表一的第二个节点...\n");N=GetNode(L1,2);printf("将链表一的第二个结点移动到链表二适当的位置");if(N!=NULL)L2=Insert(L2,N);printf("移动后的链表一\n");print(L1);printf("移动后的链表二\n");print(L2);}完成情况:(本部分详细描述运行结果情况,1)完成实验内容的要求;2)展示运行的结果。
实验链表实验报告
![实验链表实验报告](https://img.taocdn.com/s3/m/a12cf6b3541810a6f524ccbff121dd36a32dc42d.png)
实验链表实验报告一、实验目的本次实验的主要目的是深入理解链表这种数据结构的概念、特点和操作方法,并通过实际编程实现来提高对链表的应用能力。
二、实验环境本次实验使用的编程语言为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;}```五、实验结果通过对上述链表操作函数的调用,我们成功地创建、遍历、插入和删除了链表中的节点。
链表实验报告总结
![链表实验报告总结](https://img.taocdn.com/s3/m/de52cf6383c4bb4cf6ecd149.png)
链表实验报告总结篇一:顺序表,链表总结实验报告实验报告实验目的:学生管理系统(顺序表)实验要求: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完成日期: 地点:5502学时:2学时一、需求分析【实验目的】通过本次实验,对课堂上线性表的知识进行巩固,进一步熟悉线性表的链接存储及相应的基本操作;并熟练掌握VC++ 6.0操作平台,学会调试程序,以及编写电子实验报告【实验要求】编写线性表的基本操作,有构造线性表,线性表的遍历,插入,删除,查找,求表长等基本功能,在此基础上能够加入DOS下的图形界面以及学会文件的操作等功能,为以后的学习打下基础。
c课程设计链表实验报告
![c课程设计链表实验报告](https://img.taocdn.com/s3/m/bde35aba7e192279168884868762caaedc33ba0d.png)
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.实验设备:计算机、编程环境。
链表实验报告
![链表实验报告](https://img.taocdn.com/s3/m/1d76dcde05087632311212d4.png)
C语言实验报告实验目的:链表的基本操作添加,删除,排序#include <iostream.h>#include <string.h>#include <stdlib.h>struct StuNode{char ID[10];char Name[10];int Height;StuNode *next;};typedef StuNode stulist;void Addafter (stulist * list,char * id,char * name,int height){if(!list||!id) return;StuNode *p=new StuNode;strcpy(p->ID,id);strcpy(p->Name,name);p->Height=height;StuNode *q=list;while(q->next){q=q->next;}q->next=p;p->next=NULL;}void ShowNode(stulist * list){cout<<"现有数据是:"<<endl;StuNode *p=list->next;while(p){cout<<p->ID<<" "<<p->Name<<" "<<p->Height<<endl;p=p->next;}cout<<endl<<"*************************************"<<endl; }void Insert (stulist * list){char Beid[10]="2014002";char id[10]="1112223";char name[10]="狗蛋";int height=177;if(!list||!id) return;StuNode *p=new StuNode;strcpy(p->ID,id);strcpy(p->Name,name);p->Height=height;StuNode *q=list;while(strcmp(q->ID,Beid)!=0){q=q->next;}p->next=q->next;q->next=p;}void Delete(stulist * list){char id[10]="2014001";StuNode *q=list;StuNode *d=q->next;while(strcmp(d->ID,id)!=0){q=q->next;d=d->next;}q->next=d->next;delete d;}void main(){stulist list_1;list_1.next=NULL;char name[10],id[10];int height;Addafter(&list_1,"2014001","张三",175);Addafter(&list_1,"2014002","李四",180);Addafter(&list_1,"2014003","王二",173);Addafter(&list_1,"2014004","麻子",179);ShowNode(&list_1);cout<<"现在添加马六"<<endl;Addafter(&list_1,"2014999","马六",180);ShowNode(&list_1);cout<<"现在把狗蛋插入到李四后面"<<endl;Insert(&list_1);ShowNode(&list_1);cout<<"现在删除张三"<<endl;Delete(&list_1);ShowNode(&list_1);}实验总结:通过学习链表的操作,让知道了C语言和C++是有着紧密联系的,让我能更加熟练了数组,指针,结构体等一些基本的c++语言知识,而且知道了怎么添加修改和排序的一些方法。
数据结构实验报告-链表
![数据结构实验报告-链表](https://img.taocdn.com/s3/m/825bc16600f69e3143323968011ca300a6c3f622.png)
数据结构实验报告-链表院系:计算机学院实验课程:数据结构实验实验项⽬:实验⼆利⽤链表实现学⽣健康系统指导⽼师:开课时间:专业:计算机类班级:学⽣:学号:实验⼆利⽤链表实现学⽣健康系统1.综设实验题⽬利⽤链表实现学⽣健康系统2.中⽂摘要本实验是利⽤链表这⼀经典的数据结构来实现⼀个学⽣健康系统,从⽽学⽣的健康信息和相应的个⼈信息可以很⽅便地通过这个系统进⾏增、删、查、改等操作。
3.关键词课程名称数据结构实验实验项⽬利⽤链表实现学⽣健康系统实验时间年⽉⽇实验指导⽼师实验评分链表健康系统C++4.前⾔实验⽬的:想要通过链表这⼀数据结构来实现学⽣健康情况管理的⼏个操作功能。
实验意义:⽅便相关⼈员对学⽣健康信息的管理和操作。
实验内容:主要是新建学⽣健康系统、插⼊学⽣的数据、删除学⽣的数据、从⽂件读取学⽣健康数据、将学⽣的健康等信息写⼊到⽂件、查询指定学⽣的相关信息、在屏幕上输出学⽣相关信息等功能。
健康表中学⽣的信息有学号、姓名、出⽣⽇期、性别、⾝体状况等。
5.实验设计由于该实验主要涉及到链表这⼀存储结构,因此整个实验的关键点便在于对链表这个数据结构的建⽴和操作上。
常见的链表的操作有:建⽴链表、往链表中插⼊数据、从链表中删除数据、查找链表中的元素、修改链表中的元素、销毁链表。
由此,经过对问题的仔细分析之后,发现我们所要实现的健康系统的增、删、查、改等功能与链表这⼀数据结构的关系是:增加学⽣数据相当于往链表中的插⼊数据的操作;删除学⽣数据相当于从链表中的删除数据的操作;查找学⽣数据相当于链表中的查找元素的操作;修改学⽣数据相当于链表中的修改元素的操作;因此,我们可以直接⽤链表来存储所有学⽣的信息,每⼀个学⽣的信息集就是链表中的⼀个节点,这样,就使得我们的健康系统的问题归约到了链表的实现问题上了。
在这个链表的设计上,每⼀个节点包含有相应学⽣的所有信息和⼀个指向下⼀个节点的指针,学⽣的信息包括:学号、姓名、出⽣⽇期、性别和健康信息,分别采⽤C++中的string, string, int, bool 和string类型来表⽰。
数据结构实验报告链表
![数据结构实验报告链表](https://img.taocdn.com/s3/m/c81050810d22590102020740be1e650e52eacf02.png)
数据结构实验报告链表
《数据结构实验报告:链表》
在计算机科学领域,数据结构是一门重要的课程,它对于计算机程序的设计和性能有着至关重要的作用。
其中,链表是一种常见的数据结构,它在实际应用中有着广泛的用途。
在本次实验中,我们将深入研究链表这一数据结构,并通过实验来验证其性能和应用。
首先,我们需要了解链表的基本概念。
链表是由一系列节点组成的数据结构,每个节点包含数据和指向下一个节点的指针。
相比于数组,链表具有动态的内存分配和插入/删除操作的优势,但在访问元素时性能稍逊色。
因此,链表适用于需要频繁插入/删除操作的场景。
在本次实验中,我们将实现一个简单的链表数据结构,并进行一系列的操作。
首先,我们将实现链表的创建、插入、删除和遍历等基本操作,并通过实验验证其正确性和性能。
其次,我们将对比链表和数组在不同场景下的性能差异,以便更好地理解链表的适用场景和特点。
通过本次实验,我们将深入了解链表这一数据结构的原理和应用,掌握其基本操作和性能特点,为今后的程序设计和优化提供重要的参考。
同时,我们也将通过实验数据和分析来验证链表的优势和不足,为选择合适的数据结构提供依据。
希望本次实验能够为大家对数据结构和算法有更深入的理解和掌握提供帮助。
通过本次实验,我们对链表这一数据结构有了更深入的了解,并通过实验验证了其性能和应用。
链表作为一种常见的数据结构,在实际应用中有着广泛的用途,掌握其原理和操作对于程序设计和性能优化至关重要。
希望本次实验能够
为大家对数据结构和算法有更深入的理解和掌握提供帮助。
链表-实验报告
![链表-实验报告](https://img.taocdn.com/s3/m/74833944f11dc281e53a580216fc700abb68523e.png)
实验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.裁图说明实验结果【心得体会、问题和建议】成绩:指导教师签名批阅日期:。
链表的基本操作实验报告
![链表的基本操作实验报告](https://img.taocdn.com/s3/m/6cec0d34ccbff121dd36835e.png)
《数据结构》实验报告学号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、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告(实验二)
专业班级姓名学号课程名称
学年学期第二学期课程类别专业必修
●实验内容:实验时间:2012年3 月27日
1. 编写函数,实现随机产生或键盘输入一组元素,建立一个带头结点的单链表(无序)。
2. 编写函数,实现遍历单链表。
3. 编写函数,实现把单向链表中元素逆置(不允许申请新的结点空间)。
4. 编写函数,建立一个非递减有序单链表。
5. 编写函数,利用以上算法,建立两个非递减有序单链表,然后合并成一个非递减链表。
6. 编写函数,在非递减有序单链表中插入一个元素使链表仍然有序。
7. 编写函数,实现在非递减有序链表中删除值为x的结点。
8. 编写一个主函数,在主函数中设计一个简单的菜单,分别调试上述算法。
●实验目的及要求:
1. 掌握单链表的存储结构形式及其描述
2. 掌握单链表的建立、查找、插入和删除操作
●方法与步骤:
详见源代码。
●小结:
经过这次的实验:
⒈使我链表方面的知识更加熟练。
包括:链表中元素的逆置;非递减有序单链表的建立;建立两个非递减有序单链表,然后合并成一个非递减链表;还有在非递减有序链表中删除值为x的结点。
⒉让我了解我链表的知识还是不牢固;但有做顺序表的基础还可以做。
但对两个非递减链表合并的方法并不会,后来经过自己看书和问同学才能完成。
以后我会更加努力学习数据结构。
分数:批阅老师:2012年月日
实验结果:
#include <stdio.h>
#include <stdlib.h> typedef int ElemType;
typedef struct LNode
{ElemType data;
struct LNode *next;
}LNode,*Linklist;
void Createlist(Linklist &L) //建立一个带头结点的单链表(无序),当x=0时结束{Linklist p,s;
ElemType x;
L=(Linklist)malloc(sizeof(LNode));
L->next=NULL;
p=L;
scanf("%d",&x);
while(x){
s=(Linklist)malloc(sizeof(LNode));
s->data=x;
s->next=NULL;
p->next=s;
p=s;
scanf("%d",&x);}
}
void printlist(Linklist &L) //以输出的形式实现遍历单链表
{Linklist p;
p=L;
while(p->next!=NULL){
p=p->next;
printf("%d ",p->data);}
printf("\n");
}
void nizhi(Linklist &L) //逆置
{Linklist p,s;
p=L->next;
L->next=NULL;
while(p){
s=p;
p=p->next;
s->next=L->next;
L->next=s;}
}
void Insert(Linklist &L,ElemType x) //在非递减有序单链表中插入一个元素使链表仍然有序
{Linklist p,s;
s=(Linklist)malloc(sizeof(LNode));
s->data=x;
p=L;
while(p->next&&p->next->data<=x)
p=p->next;
s->next=p->next;
p->next=s;
}
void Creat_Sort(Linklist &L) //建立一个非递减有序单链表
{ElemType x;
L=(Linklist)malloc(sizeof(LNode));
L->next=NULL;
printf("建立有序表,输入任意个整形数据以0结束:\n");
scanf("%d",&x);
while(x){
Insert(L,x);
scanf("%d",&x);}
}
void merger(Linklist La,Linklist Lb,Linklist &Lc) //建立两个非递减有序单链表,然后合并成一个非递减链表
{Linklist p,q,s,rear;
p=La->next;
q=Lb->next;
Lc=rear=La;
free(Lb);
while(p&&q){
if(p->data<q->data) {s=p;p=p->next;}
else {s=q;q=q->next;}
rear->next=s;
rear=rear->next;}
if(p) rear->next=p;else rear->next=q;
}
void Delete(Linklist &L,ElemType x) //在非递减有序链表中删除值为x的结点{Linklist p,q;
p=L;
q=L->next;
while(q&&q->data!=x){
p=q;
q=q->next;}
if(!q) printf("\nnot deleted");
else {p->next=q->next;free(q);}
}
void main()
{Linklist La,Lb,Lc;
ElemType x;
int n;
printf("1.随机盘输入一组元素,建立无序的单链表,以0结束\n");
printf("2.以输出的形式遍历单链表\n");
printf("3.把单向链表中元素逆置\n");
printf("4.建立一个非递减有序单链表\n");
printf("5.建立两个非递减有序单链表,然后合并成一个非递减链表\n"); printf("6.在非递减有序单链表中插入一个元素\n");
printf("7.删除指定的元素\n");
while(1){
printf("请选择:");
scanf("%d",&n);
switch(n)
{case 1:Createlist(La);break;
case 2:printlist(La);break;
case 3:nizhi(La);
printlist(La);break;
case 4:Creat_Sort(La);
printlist(La);break;
case 5:Creat_Sort(La);
Creat_Sort(Lb);
merger(La,Lb,Lc);
printlist(Lc);break;
case 6:Creat_Sort(La);
printlist(La);
printf("请输入要插入的元素x:");
scanf("%d",&x);
Insert(La,x);
printlist(La);break;
case 7:Creat_Sort(La);
printlist(La);
printf("请输入要删除的元素x:");
scanf("%d",&x);
Delete(La,x);
printlist(La);break;
default :printf("输入有误,请重新选择!\n");
}
}
}。