单链表基本操作实验报告[1]
单链表的基本操作实验报告
单链表的基本操作实验报告单链表的基本操作实验报告引言:单链表是一种常见的数据结构,它由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。
在本次实验中,我们将学习和实践单链表的基本操作,包括创建链表、插入节点、删除节点以及遍历链表等。
一、实验目的本次实验的主要目的是掌握单链表的基本操作,包括链表的创建、插入节点、删除节点和遍历链表。
通过实践操作,加深对单链表的理解,并掌握如何应用单链表解决实际问题。
二、实验过程1. 创建链表首先,我们需要创建一个空链表。
链表可以通过一个头节点来表示,头节点不存储数据,只用于标识链表的起始位置。
我们可以定义一个指针变量head,将其指向头节点。
2. 插入节点在链表中插入节点是常见的操作。
我们可以选择在链表的头部、尾部或者指定位置插入节点。
插入节点的过程可以分为以下几个步骤:a. 创建一个新节点,并为其赋值;b. 找到要插入位置的前一个节点;c. 将新节点的指针指向前一个节点的下一个节点;d. 将前一个节点的指针指向新节点。
3. 删除节点删除节点是另一个常见的操作。
我们可以选择删除链表的头节点、尾节点或者指定位置的节点。
删除节点的过程可以分为以下几个步骤:a. 找到要删除节点的前一个节点;b. 将前一个节点的指针指向要删除节点的下一个节点;c. 释放要删除节点的内存空间。
4. 遍历链表遍历链表是为了查看链表中的元素。
我们可以从头节点开始,依次访问每个节点,并输出节点的值。
三、实验结果在本次实验中,我们成功完成了单链表的基本操作。
通过创建链表、插入节点、删除节点和遍历链表等操作,我们可以方便地对链表进行增删改查操作。
四、实验总结通过本次实验,我们对单链表的基本操作有了更深入的了解。
单链表是一种非常重要的数据结构,广泛应用于各个领域。
掌握了单链表的基本操作,我们可以更好地解决实际问题,并且为以后学习更复杂的数据结构打下坚实的基础。
在实验过程中,我们还发现了一些问题和不足之处。
单链表的实验报告
单链表的实验报告单链表的实验报告引言:单链表是一种常用的数据结构,它由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。
在本次实验中,我们将学习如何使用单链表来实现一些基本的操作,并通过实验验证其功能和效率。
一、实验目的本次实验的主要目的是掌握单链表的基本概念和操作方法,包括插入、删除、查找等操作,并通过实际操作来验证其正确性和效率。
二、实验过程1. 单链表的定义和初始化首先,我们需要定义一个单链表的结构,并初始化一个空链表。
链表的结构可以使用C语言中的结构体来表示,其中包含一个数据域和一个指向下一个节点的指针。
2. 插入操作在已有链表中插入一个新的节点,可以分为两种情况:在链表头部插入和在链表中间插入。
我们可以通过修改指针的指向来实现插入操作。
3. 删除操作删除链表中的一个节点,同样可以分为两种情况:删除头节点和删除中间节点。
删除操作需要注意指针的重新连接,以防止链表断裂。
4. 查找操作在链表中查找指定的元素,可以通过遍历链表的方式来实现。
从链表头开始,依次比较节点的数据域,直到找到目标元素或者遍历到链表尾部。
5. 其他操作在实际应用中,还可以对链表进行排序、逆序、合并等操作,这些操作都可以通过适当的算法来实现。
三、实验结果通过实际操作,我们验证了单链表的各种操作方法的正确性和效率。
在插入、删除和查找操作中,链表的时间复杂度为O(n),其中n为链表的长度。
而在其他操作中,时间复杂度则根据具体算法的实现方式而定。
四、实验总结通过本次实验,我们深入了解了单链表的结构和操作方法,并通过实际操作来验证了其功能和效率。
单链表作为一种常用的数据结构,在实际应用中具有广泛的用途,例如链表可以用来实现栈、队列等其他数据结构,也可以用于解决一些实际问题,如链表的反转、环的检测等。
总之,掌握单链表的基本概念和操作方法对于学习和理解数据结构具有重要意义。
通过实验的方式,我们不仅能够加深对单链表的理解,还能够提高编程能力和解决实际问题的能力。
数据结构单链表实验报告
数据结构单链表实验报告实验目的:掌握单链表的基本操作,学会使用单链表实现各种算法。
实验内容:实现单链表的基本操作,包括创建、插入、删除、访问等。
利用单链表完成以下算法:- 单链表逆序- 查找单链表中的中间节点- 删除单链表中的倒数第K个节点- 合并两个有序单链表为一个有序单链表实验步骤:1. 创建单链表在创建单链表时,先定义一个结构体Node来表示链表中的节点,节点包括数据域和指针域,指针域指向下一个节点。
然后,用指针p指向链表的头节点,将头节点的指针域初始化为NULL。
2. 插入节点在单链表中插入节点的操作分为两种情况:- 在链表头插入节点- 在链表中间或尾部插入节点无论是哪种情况,先将新节点的指针域指向要插入的位置的下一个节点,再将要插入的位置的指针域指向新节点即可。
3. 删除节点删除链表节点的操作同样分为两种情况:- 删除头节点- 删除中间或尾部节点要删除头节点,先用一个指针将头节点指向的下一个节点保存起来,再将头节点释放掉。
要删除中间或尾部节点,先用一个指针指向要删除节点的前一个节点,然后将指向要删除节点的前一个节点的指针域指向要删除节点的下一个节点,最后将要删除的节点释放掉。
4. 单链表逆序单链表逆序可以使用三个指针来完成,分别为pre指针、cur指针和next指针。
首先将pre指针和cur指针指向NULL,然后循环遍历链表,将cur指针指向当前节点,将next指针指向当前节点的下一个节点,然后将当前节点的指针域指向pre指针,最后将pre指针和cur指针向前移动一个节点,继续进行循环。
5. 查找单链表中的中间节点查找单链表中的中间节点可以使用双指针法,将两个指针p1和p2都指向链表头,然后p1每次向前移动一个节点,而p2每次向前移动两个节点,当p2指向了链表尾部时,p1指向的节点即为中间节点。
6. 删除单链表中的倒数第K个节点删除单链表中的倒数第K个节点可以使用双指针法,在链表中定义两个指针p1和p2,p1指向链表头,p2指向第K个节点,然后p1和p2同时向前移动,直到p2指向链表尾部,此时p1指向的节点即为要删除的节点。
链表基本操作实验报告
实验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("其他键退出。
单链表的基本操作实验报告
湖南第一师范学院信息科学与工程系实验报告课程名称:数据结构与算法成绩评定:实验项目名称:单链表的基本操作指导教师:学生姓名:沈丽桃学号: 10403080118 专业班级: 10教育技术实验项目类型:验证实验地点:科B305 实验时间: 2011 年 10 月20 日一、实验目的与要求:实验目的:实现线性链表的创建、查找、插入、删除与输出。
基本原理:单链表的基本操作二、实验环境:(硬件环境、软件环境)1.硬件环境:奔ⅣPC。
2.软件环境:Windows XP 操作系统,TC2.0或VC++。
三、实验内容:(原理、操作步骤、程序代码等)#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct celltype{int element;struct celltype*next;};typedef int position;void main(){struct celltype*head,*p;int x,choice;void INSERT(int x,struct celltype*p);void LOCATE(int x,struct celltype*p);void DELETE(int x,struct celltype*p);p=(struct celltype*)malloc(sizeof(struct celltype));head=p;p->element=0;p->next=NULL;printf(“Please option:1:Insert 2:Locate 3:Delete\n”);printf(“Please choose:”);scanf(“%d”,&choice);switch(choice)case 1:printf(“Please input a node:”);scanf(“%d”,&x);p=head;INSERT(x,p);for(p=head;p!=NULL;p=p->next)printf(“%d”,p->element);printf(“\n”);break;case 2:printf(“Please input the data you want to locate:”); scanf(“%d”,&x);p=head;LOCATE(x,p);break;case 3:printf(“Please input the data you want to delete:”); scanf(“%d”,&x);DELETE(x,p);for(p=head;p!=NULL;p=p->next)printf(“%d”,p->next);printf(“\n”);break;}void INSERT(int x,struct celltype*p){struct celltype*t,*q;q=(struct celltype*)malloc(sizeof(struct celltype)); q->next=x;while((x>p->element)&&(p!=NULL)){t=p;p=p->next;}if((x>p->element)&&(p->next!=NULL)){p->next=q;q->next=NULL;}else{q->next=p;t->next=q;}}void LOCATE(int x,struct celltype*p){while(p->next!=NULL)if(p->next->element==x)printf(“the number %d is in %d\n”,x,p);else printf(“the number not exist!\n”);}void DELETE(int x,struct celltype*p){while((p->element!=x)&&(p->next!=NULL)){t=p;p=p->next;}if(p->element==x)t->next=p->next}error C2018:unknown character ’Oxal’error C2065:’Please’:undeclared identifiererror C4024:’printf’:different types for formal and actual parameter 1error C4047:’function’:’const*differs in levers of indirection from ’int’error C2146:syntaxerror:missing’)’before identifier’option’error C2017:illegal escape sequenceerror C2059:syntax error:’)’error C2143:syntax error:missing’)’before’%’出现了很多错误,主要是因为printf里的一对双引号不是英文状态下的。
数据结构单链表实验报告
数据结构单链表实验报告范本:数据结构单链表实验报告一、引言本实验旨在掌握数据结构中单链表的基本概念、操作和应用。
通过实际操作,理解单链表的结构与实现,提高数据结构的编程能力和问题解决能力。
二、实验目的1. 理解单链表的概念和特点;2. 掌握单链表的基本操作,包括插入、删除、遍历;3. 学会使用单链表解决实际问题。
三、实验内容1. 单链表的定义和结构设计;2. 单链表的基本操作的实现,包括插入节点、删除节点、遍历;3. 针对具体的问题,设计相应的单链表操作。
四、实验步骤1. 单链表的定义和结构设计:(1)定义单链表的结构体,包含数据域和指针域;(2)实现单链表的初始化函数;(3)实现单链表的销毁函数。
2. 单链表的基本操作的实现:(1)实现单链表的插入节点操作;(2)实现单链表的删除节点操作;(3)实现单链表的遍历操作。
3. 针对具体问题的单链表操作:(1)根据具体需求,设计并实现相应的操作函数;(2)利用单链表解决具体问题。
五、实验结果与分析1. 在实验过程中,成功实现了单链表的定义和结构设计,包括数据域和指针域的正确设置。
2. 实验中实现了插入节点、删除节点和遍历等基本操作。
3. 针对具体问题,通过单链表操作解决了相应的问题。
六、实验总结通过本次实验,加深了对单链表的理解和掌握。
掌握了单链表的基本操作和应用实现,提高了数据结构的编程能力和问题解决能力。
附件:1. 本文所涉及的代码文件;2. 实验过程中所用到的数据文件。
法律名词及注释:1. 数据结构:指的是一组数据的表示方法和相应的操作。
在计算机科学中,数据结构是计算机中存储、组织数据的方式。
2. 单链表:是一种链式存储结构,每个节点包含数据域和指针域。
数据域用于存储数据,指针域用于指向下一个节点。
数据结构单链表实验报告1
实验报告实验课程数据结构实验项目实验一专业计算机类姓名xxxx学号123456实验时间第9周计算机科学与技术学院算法基本思想:1. 1链表中插入元素,申请内存后将读入的元素存入并加入到尾节点的指针域中,利用循环遍历来查找尾节点;2而顺序表则直接向数组中插入。
时间复杂度:T(n) = O(n)2.排序操作设定为递减,将第一个节点存储的值依次与后一个节点比较,如果小于后一个,则交换值,后再继续向后比较,直至到尾节点,再将第二个向后比较,依次类推,利用嵌套循环来实现;时间复杂度:T(n) = O(n^2)3.查找制定值的元素,利用循环遍历表,并制定一个int 型变量来存储位置,查找到则结束循环,并返回这个int 值,循环如果完成,找不到返回0;时间复杂度:T(n) = O(n)4.删除指定值:1.链表中则先查找,然后将前一个节点的指针域指向此节点指向的节点,并删除这个节点的内存;2.顺序表中,则先查找,然后将后一个值存储到这个节点,将其后所有的值都按依次移动一次;时间复杂度:T(n) = O(n)5.插入一个元素,并保持有序:设计为先插入,然后再排序。
在此提出一个想法:将要存储的值先与表中的元素比较,然后插入到合适的位置,链表则重新制定位置。
数组则进行数据的移动操作;时间复杂度:T(n) = O(n^3)6.利用一个while循环判断当前的节点是否为空,不为空则输出其中的值;时间复杂度:T(n) = O(n)程序代码:链表实现程序代码:#include <stdio.h>#include <stdlib.h>struct Node{int data;struct Node *next;};typedef struct Node ListNode;//向链表中插入元素ListNode * InsertNode(int NodeData,ListNode *head){ListNode *p = NULL;ListNode *pre = head;p =(ListNode*)malloc(sizeof(ListNode));if(head == NULL){head = p;}else{while(pre->next != NULL){pre = pre->next;}pre->next = p;}pre = p;pre->data = NodeData;pre->next = NULL;return head;}//输出链表中的元素void Display(ListNode *head){ListNode *p = head;while(p!= NULL){printf("%d\t",p->data);p = p->next;}printf("\n");}//查找值为x的元素,返回它在线性表中的位置,0表示查找失败;int FindElem(ListNode *head){ListNode *p = head;int f=0,count = 1;printf("请输入要查找的元素:\n");scanf("%d",&f);while(p->next!=NULL){if(p->data == f){return count;break;}count++;p=p->next;}if(p->next==NULL){return 0;}}// 删除值为x的元素;ListNode * DeleteElem(ListNode *head) {ListNode *pre = head;ListNode *p = head;int cut=0;printf("请输入要删除的元素:\n");scanf("%d",&cut);if(head->data == cut){head=head->next;free(p);return head;}else{while(p!= NULL){pre = p;pre=pre->next;if(pre->data == cut){p->next=pre->next;free(pre);break;}p=p->next;}return head;}}//对当前链表中的元素进行排序ListNode * Sort(ListNode *head){ListNode *pre =head;ListNode *p = head;ListNode *temp = NULL;int cat;for(pre; pre->next != NULL; pre = pre->next) {temp = pre;for(p=pre; p!= NULL; p = p->next){if(p->data >= temp->data){cat = temp->data;temp->data = p->data;p->data = cat;}}}return head;}// 插入元素x,并使线性表L仍需保持有序。
实验三 单链表操作(1)
实验三单链表操作一、实验目的1、掌握单链表的基本操作:建立、查找、插入、删除等运算。
二、实验要求1、补充主程序。
2、调试运行本实验程序并进行结果分析。
三、实验内容本程序功能在于演示单链表的建立、查找、插入、删除等运算,给出了部分程序,请补充完整并调试运行。
部分程序如下:#include <stdio.h>#include <stdlib.h>#define flag -1typedef int datatype;typedef struct node{datatype data;struct node *next;}LNode,*LinkList;/*尾部插入结点建立带有头结点单链表*/LinkList Creat_LinkList(){ LinkList L;L= (LNode *)malloc(sizeof(LNode));L->next=NULL;LNode *s,*r=NULL;int x; /*设数据元素的类型为int*/scanf("%d,",&x);while (x!=flag){ s= (LNode *)malloc(sizeof(LNode));s->data=x;if (L->next==NULL) L->next=s; /*头结点的处理*/else r->next=s; /*其它结点的处理*/r=s; /*r 指向新的尾结点*/scanf("%d,",&x);}if ( r!=NULL) r->next=NULL; /*对于非空表,最后结点的指针域放空指针*/return L;}/* 求带头结点单链表长度*/int Length_LinkList(LinkList L){ LNode * p=L; /* p指向头结点*/int j=0;while (p->next){ p=p->next; j++; } /* p所指的是第j 个结点*/return j;}/* 按序号查找*/LNode * Get_LinkList(LinkList L, int i)/*在带头结点的单链表L 中查找第i 个元素结点,找到返回其指针,否则返回空*/ { LNode * p=L;int j=0;while (p->next !=NULL && j<i ){ p=p->next; j++; }if (j==i) return p;else return NULL;}/*按值查找*/LNode * Locate_LinkList( LinkList L, datatype x)/*在带头结点的单链表L中查找值为x的结点,找到后返回其指针,否则返回空*/ { int i=0;LNode * p=L->next;while ( p!=NULL && p->data != x){i=i+1;p=p->next;}return p;}/*单链表插入结点*/int Insert_LinkList(LinkList L,int i,datatype x)/*在带头结点的单链表L的第i个位置上插入值为x的元素*/{ LNode * p,*s;p=Get_LinkList(L,i-1); /*查找第i-1个结点*/if (p==NULL){printf("参数i错!\n");return 0; } /*第i-1个结点不存在不能插入*/else{ s=(LNode *)malloc(sizeof(LNode));/*申请、填装结点*/s->data=x;s->next=p->next;/*新结点插入在第i-1个结点的后面*/p->next=s;return 1;}}/*单链表删除结点*/int Del_LinkList(LinkList L,int i)/*删除带头结点的单链表L上的第i个数据结点*/{ LinkList p,s;p=Get_LinkList(L,i-1); /*查找第i-1个结点*/if (p==NULL){ printf("第i-1个结点不存在");return -1; }else if (p->next==NULL){ printf("第i个结点不存在");return 0; }else{ s=p->next; /*s指向第i个结点*/p->next=s->next; /*从链表中删除*/free(s); /*释放*s */return 1;}}/*显示单链表结点*/void Print_LinkList(LinkList L){LNode * p=L; /* p指向头结点*/printf("单链表为:\n");while (p->next){printf("%d,",p->next->data);p=p->next;}printf("\n");}void main(){LinkList L;int len;LNode *p;int i,j;int x;printf("尾部插入结点建立带有头结点单链表\n");L=Creat_LinkList();Print_LinkList(L);printf("求带头结点单链表长度\n");len=Length_LinkList(L);printf("单链表的长度为:\n");printf("%d\n",len);printf("按序号查找\n");printf("输入查找结点的序号:"); scanf("%d",&i);p=Get_LinkList(L,i);if(p!=NULL) printf("%d\n",p->data); else printf("\n查找结点不存在!"); printf("按值查找\n");printf("输入查找结点的值:");scanf("%d",&x);p=Locate_LinkList(L,x);if(p!=NULL) printf("%d\n",p->data); else printf("\n查找结点不存在!"); printf("单链表插入结点\n");printf("输入插入结点的序号、值:"); scanf("%d,%d",&i,&x);j=Insert_LinkList(L,i,x);if(j==1){printf("插入成功!\n");Print_LinkList(L);}printf("单链表删除结点\n");printf("输入删除节点的序号\n"); scanf("%d",&i);j=Del_LinkList(L,i);if(j==1){printf("删除成功!\n");Print_LinkList(L);}}。
单链表基本操作实验报告[1]
数学与计算机科学系实验报告
课程:数据结构地点:实验室时间:2010年12月7日
学生姓名
孙彩玲
班级
计本(2)班
学号
090312259
成绩
组别
无
同组姓名
无
scanf("%d",&i);
p=L;
j=0;
while(p->next&&j<i-1)
{
p=p->next;
++j;
}
if(!(p->next)||j>i-1)
{
printf("删除位置不合法!");
return 0;
}
q=p->next;
p->next=q->next;
e=q->data;
free(q);
for(i=0;i<a;i++)
{
q=(Linklist)malloc(sizeof(LNode));
scanf("%d",&q->data);
q->next=p->next;
p->next=q;
p=p->next;
}
printf(L);
return 0;
}
int ListInsert(Linklist &L)
}
s=(Linklist)malloc(sizeof(LNode));
s->data=e;
单链表的各种基本运算的实现 实验报告
软件技术基础实验一——单链表的各种基本运算的实现一、实验题目编写一个程序,实现单链表的各种基本运算,并在此基础上设计一个主程序完成如下功能:(1)初始化单链表(2)依次采用尾插法插入a,b,c,d,e元素(3)输出单链表(4)在第四个元素位置上插入f元素(5)删除该单链表的第三个元素二、实验目的1、理解单链表的概念及结构特点;2、掌握单链表的基本操作:查找、插入、删除等运算在链接存储结构上的运算。
三、调试通过并正确执行给定功能要求的实验代码#include "stdafx.h"#include<malloc.h>#include<iostream.h>struct link{char data;link *next;};link *rcreat(link *head,char x) //尾插法建立单链表{link *s,*r;r=head;s=new link;s->data=x;r->next=s;r=s;r->next=NULL;return r;}link *get(link *head,int i) //查找第i个元素,返回其地址{int j;link *p;j=1;p=head->next ;while((j<i-1)&&(p!=NULL)){j++;p=p->next;}return p;}void insert(link *head,int num,char y) //元素y之后插入x {link *p,*s;s=new link;s->data=y;if(head->next==NULL){head->next=s;s->next=NULL;}p=get(head,num);if(p==NULL) cout<<"插入位置非法";else{s->next=p->next;p->next=s;}}void delet(link *head,char x) //将指定元素x删除{link * p, * q;q=head;p=head->next;while((p!=NULL)&&(p->data!=x)){q=p;p=p->next;}if(p==NULL) cout<<"要删除的元素不存在";else{q->next=p->next;delete(p);}}void print(link *head) //输出单链表{link *p;p=head->next;while(p->next!=NULL){cout<<p->data<<"->";p=p->next;}cout<<p->data<<endl;}void main(int argc, char* argv[]){link *head,*p,*q,*r;char x,y;int n,dele,i=1,j=1;head=new link;head->next=NULL;r=head;while(j<=5){cout<<"请输入要插入的元素:";cin>>x;r=rcreat(r,x);j=j+1;}print(head);cout<<"请输入要插入元素的位置:";cin>>n;cout<<"请输入要插入的元素:";cin>>y;insert(head,n,y);cout<<"输出插入后的单链表:"<<endl;print(head);cout<<"请输入要删除元素的位置:";cin>>dele;q=head;p=head->next;while(i<dele){q=p;p=p->next;i=i+1;}q->next=p->next;delete (p);cout<<"删除后的链表如下:"<<endl;print(head);}四、实验结果。
单链表实验报告总结
单链表实验报告总结单链表实验报告总结篇一:单链表实验报告实验一线性表基本操作的编程实现 --线性表在链表存储下的主要操作实现班级:T523-1 姓名:王娟学号:33 完成日期:201X.0 4.04 地点:5502 学时:2学时一、需求分析【实验目的】通过本次实验,对课堂上线性表的知识进行巩固,进一步熟悉线性表的链接存储及相应的基本操作;并熟练掌握VC++6.0操作平台,学会调试程序,以及编写电子实验报告【实验要求】编写线性表的基本操作,有构造线性表,线性表的遍历,插入,删除,查找,求表长等基本功能,在此基础上能够加入DS下的图形界面以及学会文件的操作等功能,为以后的学习打下基础。
【实验任务】(1).线性表基本操作的编程实现,掌握线性表的建立、遍历、插入、删除等基本操作的编程实现,也可以进一步编程实现查找、逆序、排序等操作,存储结构可以在顺序结构或链表结构中任选,可以完成部分主要功能,也可以用菜单进行管理完成大部分功能。
还鼓励学生利用基本操作进行一些更实际的应用型程序设计。
(2).用菜单管理,把线性表的顺序存储和链表存储的数据插入、删除运算进行程序实现。
建议实现键盘数据输入实现改实验的通用性。
为了体现功能的正常性,至少要编制遍历数据的函数.(3).注意事项:开发语言使用C++,尽量使用面向对象的思想和实现方法,可以改编成应用软件. 【实验类型】验证型实验二、概要设计需要实现线性表的以下功能:1、创建单链表2、删除链表中的某个结点3、输出单链表(遍历)4、释放结点所占空间5、查找第i个结点6、插入一个结点7、求链表的长度二、详细设计(1).数据结构线性表的线性结构觉决定了它的性质:数据元素之间是一种线性关系,数据元素一个接一个的排列,除了最后一个数据,其他的数据面临的下一个数据有且仅有一个。
单链表的操作实验报告
单链表的操作实验报告《单链表的操作实验报告》在计算机科学领域,数据结构是非常重要的基础知识之一。
而单链表作为一种常见的数据结构,经常被用来存储和操作数据。
在本次实验中,我们将对单链表的操作进行实验,并撰写实验报告以总结和分享我们的实验结果。
实验目的:1. 了解单链表的基本概念和操作方法。
2. 掌握单链表的插入、删除、查找等操作。
3. 通过实际操作加深对单链表的理解和掌握。
实验环境:1. 编程语言:C/C++2. 开发环境:Visual Studio Code3. 实验工具:GCC编译器实验步骤:1. 定义单链表的结构体,并实现初始化、插入、删除、查找等操作的函数。
2. 编写测试用例,对单链表的各种操作进行测试。
3. 分析实验结果,总结操作的时间复杂度和空间复杂度。
4. 撰写实验报告,分享实验过程和结果。
实验结果:经过实验,我们成功实现了单链表的初始化、插入、删除、查找等操作,并对这些操作进行了充分的测试。
我们发现单链表的插入和删除操作的时间复杂度为O(1),而查找操作的时间复杂度为O(n),其中n为链表的长度。
这些结果与我们的预期相符合,说明我们对单链表的操作有了较好的掌握。
实验总结:通过本次实验,我们不仅加深了对单链表的理解,还提高了编程能力和数据结构的应用能力。
我们对单链表的操作有了更深入的了解,为以后在实际项目中应用单链表打下了良好的基础。
结语:单链表作为一种常见的数据结构,在实际应用中具有重要的作用。
通过本次实验,我们对单链表的操作有了更深入的了解,相信在以后的学习和工作中能够更好地应用和运用单链表。
希望本次实验报告能够对读者有所帮助,也欢迎大家对实验结果进行讨论和交流。
数据结构实验报告-单链表的基本操作
湖南文理学院实验报告课题名称:数据结构实验实验名称:单链表的基本操作学生姓名:学号:专业:计算机科学与技术班级:计科11102班实验日期:2012.11.02成绩:一、实验目的1.学会定义单链表的结点类型,实现对单链表的一些基本操作和具体的函数定义,了解并掌握单链表的类定义以及成员函数的定义与调用。
2.掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。
二、实验内容1.编写程序完成单链表的下列基本操作:(1)初始化单链表La。
(2)在La中插入一个新结点。
(3)删除La中的某一个结点。
(4)在La中查找某结点并返回其位置。
(5)打印输出La中的结点元素值。
2.构造两个带有表头结点的有序单链表La、Lb,编写程序实现将La、Lb合并成一个有序单链表Lc。
合并思想是:程序需要3个指针:pa、pb、pc,其中pa,pb分别指向La表与Lb表中当前待比较插入的结点,pc指向Lc表中当前最后一个结点。
依次扫描La和Lb中的元素,比较当前元素的值,将较小者链接到*pc之后,如此重复直到La或Lb 结束为止,再将另一个链表余下的内容链接到pc所指的结点之后。
三、实验源代码1.建立新链表void INlist(linklist&head,int n){linklist q;head=(list*)malloc(LEN);head->next=NULL;q=head;for(int i=0;i<n;i++){p=(list*)malloc(LEN);scanf("%d",&(p->data));p->next=NULL;q->next=p;q=p;}q->next=NULL;p=head;//head=head->next;}2.输出链表void printlist(linklist L){L=L->next;while(L){printf("%d",L->data);L=L->next;}printf("\n");}3.插入节点bool listinsert(linklist&L,int n){p=L;linklist q;int j=0;while(p&&j<n-1){p=p->next;j++;}if(!p||j>n-1)return false;q=(list*)malloc(LEN);printf("请输入你需要的值:");scanf("%d",&(q->data));q->next=p->next;p->next=q;return true;}4.删除节点bool delist(linklist&L,int n){p=L;linklist q;int i=0;if(p->next==NULL)return false;/*if(n==1){q=p;p=p->next;free(q);}*/while(p->next&&i<n-1){p=p->next;i++;}if(!(p->next)&&i>n-1)return false;q=p->next;printf("删除的值为:%d\n",q->data);p->next=q->next;free(q);return true;}5.合并两个链表void merlist(linklist&La,linklist&Lb,linklist&Lc){linklist pa,pb;Lc=p=La;pb=Lb->next;pa=La->next;while(pa&&pb){if(pa->data<=pb->data){p->next=pa;p=pa;pa=pa->next;} else{p->next=pb;p=pb;pb=pb->next;}}p->next=pa?pa:pb;free(Lb);}6.主函数int main(){int n;linklist la,lb,lc;printf("请输入第一个链表的长度:");scanf("%d",&n);printf("请输入这些数:");INlist(la,n);printf("输入这些数为:");printlist(la)printf("请输入你需要在哪个节点前插入:");scanf("%d",&n);if(listinsert(la,n))printf("插入成功!\n");elseprintf("失败!\n");printf("输出这些数为:");printlist(la);printf("请输入第二个链表的长度:");scanf("%d",&n);printf("请输入这些数:");INlist(lb,n);printf("输出这些数为:");printlist(lb);printf("请输入你需要删除哪个节点:");scanf("%d",&n);if(delist(lb,n))printf("删除成功!\n");else printf("失败!\n");printf("输出这些数为:");printlist(lb);printf("合并并输出两个链表为:");merlist(la,lb,lc);printlist(lc);return0;}7.头文件#include<stdio.h>#include<malloc.h>#define LEN sizeof(list)typedef int ET;typedef struct list{ET data;struct list*next;}list,*linklist;linklist p;四、实验结果五、实验分析1.刚开始运行程序时我将数字无序输入,导致无序输出,不符合实验要求,后来有序输入结果符合要求;2.主函数中“printf("合并并输出两个链表为:");merlist(la,lb,lc);printlist(lc);”语句必须写在最后面,否则将无法实现合并两条链表的功能,甚至导致程序运行出错。
单链表的操作实验报告
单链表的操作实验报告单链表的操作实验报告引言:单链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
在本次实验中,我们将学习如何使用C语言实现单链表的基本操作,包括插入、删除和查找等。
一、单链表的定义和初始化单链表由节点组成,每个节点包含数据和指向下一个节点的指针。
首先,我们需要定义一个节点的结构体,如下所示:```struct Node {int data; // 节点数据struct Node* next; // 指向下一个节点的指针};```在初始化单链表之前,我们需要创建一个头节点,它不存储任何数据,只用于指向第一个节点。
初始化单链表的代码如下:```struct Node* head = NULL; // 头节点初始化为空```二、单链表的插入操作插入操作是向单链表中添加新节点的过程。
我们可以在链表的头部、尾部或者指定位置插入新节点。
下面以在链表头部插入新节点为例进行说明。
首先,我们需要创建一个新节点,并为其分配内存空间:```struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));```然后,为新节点赋值并将其插入到链表头部:```newNode->data = 10; // 赋值新节点的数据newNode->next = head; // 将新节点的指针指向原头节点head = newNode; // 将头节点指向新节点```三、单链表的删除操作删除操作是从单链表中删除指定节点的过程。
我们可以根据节点的位置或者数据进行删除。
下面以删除链表中指定数据的节点为例进行说明。
首先,我们需要遍历链表找到要删除的节点,并记录其前一个节点的地址:```struct Node* current = head;struct Node* previous = NULL;int targetData = 10; // 要删除的节点数据while (current != NULL && current->data != targetData) {previous = current;current = current->next;}```然后,将前一个节点的指针指向要删除节点的下一个节点,并释放要删除节点的内存空间:```previous->next = current->next;free(current);```四、单链表的查找操作查找操作是在单链表中查找指定数据的节点。
单链表操作实验报告
线性表一、实验目的1. 了解线性表的逻辑结构特征,以及这种特性在计算机内的两种存储结构。
2. 掌握线性表的顺序存储结构的定义及其 C语言实现。
3. 掌握线性表的链式村粗结构一一单链表的定义及其C语言实现。
4. 掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5. 掌握线性表在链式存储结构一一单链表中的各种基本操作。
二、实验要求1. 认真阅读和掌握本实验的程序。
2. 上机运行本程序。
3. 保存和打印出程序的运行结果,并结合程序进行分析。
4. 按照对顺序表和单链表的操作需要,重新改写主程序并运行,打印出文件清单和运行结果三、实验内容请编写C程序,利用链式存储方式来实现线性表的创建、插入、删除和查找等操作。
具体地说,就是要根据键盘输入的数据建立一个单链表,并输出该单链表;然后根据屏幕菜单的选择,可以进行数据的插入或删除,并在插入或删除数据后,再输出单链表;然后在屏幕菜单中选择 0,即可结束程序的运行。
四、解题思路本实验要求分别写出在带头结点的单链表中第 i (从1开始计数)个位置之后插入元素、创建带头结点的单链表中删除第 i个位置的元素、顺序输出单链表的内容等的算法。
五、程序清单#i nclude<stdio.h>#i nclude<stdlib.h>#in clude<math.h>typedef int ElemType;typedef struct LNode{ ElemType data;struct LNode *n ext;}LNode;LNode *L;LNode *creat_L();void out_L(LNode *L);void in sert_L(LNode *L,i nt i,ElemType e); ElemType delete_L(LNode *L,i nt i); int locat_L(LNode *L,ElemType e);void mai n(){ int i,k,loc;ElemType e,x;char ch;do{ printf("\n");prin tf("\n1. printf("\n 2.prin tf("\n3. prin tf("\n4. prin tf("\n 0. 建立单链表"); 插入元素"); 删除元素"); 查找元素"); 结束程序运行"); ======================================")请输入您的选择(1, 2, 3, 4, 0)");请输入插入位置:"); 请输入要插入元素的值:"); prin tf("\n prin tf("\nscan f("%d",&k);switch(k){ case 1:{ L=creat_L();out_L(L);}break;case 2:{ prin tf("\nscan f("%d",&i); printf("\n scanf("%d",&e); insert_L(L,i,e);out_L(L); }break;case 3:{ prin tf("\nscan f("%d",&i);删除的元素为:%d\n",x);删除%4后的单链表为:\n",x);out_L(L);}else prin tf("\n }break;case 4:{ prin tf("\n scan f("%d",&e);loc=locat_L(L,e);if(loc==-1) prin tf("\nelse prin tf("\n请输入要删除元素的位置:")x=delete_L(L,i); out_L(L); if(x!=-1) {pri ntf("\nprintf("要删除的元素不存在!");请输入要查找的元素值:");为找到指定元素!");已找到,元素位置是%d",loc);}break;}printf("\n ------- ");}while(k>=1 &&k<5);printf("\n 按回车键,返回...\n");ch=getchar();}LNode *creat_L(){ LNode *h,*p,*s; ElemType x;h=(LNode *)malloc(sizeof(LNode));h-> next=NULL;p=h;prin tf("\n 请输入第一个数据元素:");sca nf("%d", &x);while(x!=-999){ s=(LNode *)malloc (sizeof(LNode));s->data=x; s->n ext=NULL;p->n ext=s; p=s;printf(" 请输入下一个数据:(输入-999表示结束。
单链表操作实验报告
单链表基本操作报告姓名:张航学号:201100814205辅导老师:高艳霞实验日期:2012.09.27实现单链表的各种基本运算一、实验目的1、帮助读者复习C++语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现,其中以熟悉链表的操作为侧重点。
二、实验内容单链表的基本操作实现带头结点的单链表的建立、求长度,取元素、修改元素、插入、删除等单链表的基本操作。
三、实验步骤1.程序源码#include<stdio.h>#include<stdlib.h>#define LEN sizeof(linklist)#define NULL 0typedef struct nodeint data; /*结点的数据域*/struct node *next; /*结点的指针域*/}linklist;linklist *Linkcreat() /*建立单链表函数*/{int x;linklist *head,*p,*rear;printf("\t你选择的是尾插法建立链表功能:\n");head=(struct node*)malloc(LEN);head->data=-999; /* rear=head; / printf("\t请输入一组正整数以0结束输入:\n\t");scanf("%d",&x);while(x!=0){p=(struct node*)malloc(LEN); /*生成一个新结点*/p->data=x;rear->next=p; /*新结点插入到表尾*rear之后*/rear=p;scanf("%d",&x);}rear->next=NULL;printf("\t建立链表成功!\n");return(head);}void Linksearch(linklist *head) /*查找单链表结点函数*/ {int x;int i=0;linklist *p;printf("\t你选择的是查找功能:\n");printf("\t请输入要查找节点的值:");scanf("%d",&x);p=head;while((p->next!=NULL)&&(p->data!=x)){p=p->next;i++;}if(p->data==x){printf("\t查找成功!\n");printf("\t输出查找的数据所在位置为:%d\n",i);}else printf("\t查找结点不存在!\n");}linklist *Linkinsert(linklist *head) /*单链表结点插入函数*/ {int x,i,j=1;linklist *s,*q;printf("\t你选择的是尾插法插入功能:\n");printf("\t请输入要插入的位置:");scanf("%d",&i);printf("\t请输入要插入的数据:");scanf("%d",&x);s=(struct node*)malloc(LEN); /*建立插入数据的结点*/s->data=x;for(q=head;(q!=NULL)&&(j<=i-1);j++)q=q->next; /*指针后移指向下一个结点*/ if(q!=NULL){printf("\t插入成功!\n");s->next=q->next;q->next=s;}else printf("\t插入失败!\n");return(head);}linklist *Linkdelete(linklist *head) /*删除单链表结点函数*/ {linklist *p,*q;int i,j=1;printf("\t输入要删除的位置:"); /*输入删除的位置*/scanf("%d",&i);p=head;while((p->next!=NULL)&&(j<i){p=p->next;j++;}if(p->next!=NULL) /*若该结点存在删除该结点*/ {q=p->next;printf("\t删除成功!\n");printf("\t删除的数据为:");printf("%d\n",q->data); /*输出删除结点数据*/p->next=q->next;free(q); /*释放删除结点空间q*/ }else printf("\t删除失败!");return(head);}void Linkprint(linklist *head) /*输出单链表函数*/{linklist *p;p=head;if(p==NULL)printf("\t输出失败!\n");printf("\t输出链表为:");while(p->next!=NULL){p=p->next;printf("%3d",p->data);}printf("\n");}int Select() /*菜单显示函数*/ {int k;printf(" -------------------------------\n");printf("\t1.建立单链表\n");printf("\t2.查找单链表\n");printf("\t3.插入结点\n");printf("\t4.删除结点\n");printf("\t5.输出单链表\n");printf("\t6.退出\n");do{printf("\t请输入选择的功能:");scanf("%d",&k); /*输入选择的功能*/ printf(" -------------------------------\n");}while((k<1)||(k>6));return(k);}void main() /*主函数*/{int n;linklist *head;while(1){n=Select(); /*输入选择功能*/switch(n){case 1:head=Linkcreat();Linkprint(head);break; /*建立单链表函数*/case 2:Linksearch(head);break; /*建立单链表函数*/case 3:head=Linkinsert(head);Linkprint(head);break; /*单链表结点插入函数*/ case 4:head=Linkdelete(head);Linkprint(head);break; /*删除单链表结点函数*/ case 5:Linkprint(head);break; /*输出单链表函数*/case 6:exit(0);}}2.运行程序}四、实验总结(结果分析和体会)通过本次实验我对链表有了更深的了解,对链表的插删操作、遍历、查找等基本上掌握了。
数据结构 实验二:单链表的基本操作
数据结构实验二:单链表的基本操作数据结构实验二:单链表的基本操作实验二:单链表的基本操作一、【实验目的】1、理解和掌握单链表的类型定义方法和结点生成方法。
2、掌握建立单链表和显示单链表元素的算法。
3、掌握单链表的查找、插入和删除算法二、【实验内容】1、建立一个整形数的单链表,手动输入10个数,并从屏幕显示单链表元素列表。
2、从键盘输入一个数,查找在以上创建的单链表中是否存在该数;如果存在,显示它的位置;如果不存在,给出相应提示。
3、删除上述单链表中指定位置的元素。
以下就是程序部分代码,恳请调试并补足并使之恰当运转:1.linlist.htypedefstructnode{datatypedata;structnode*next;}slnode;voidlistinitiate(slnode**head)/*初始化*/{/*如果有内存空间,申请头结点空间并使头指针head指向头结点*/if((*head=(slnode*)malloc(sizeof(slnode)))==null)exit(1);(*head)->next=null;/*置链尾标记null*/}intlistlength(slnode*head){slnode*p=head;/*p指向首元结点*/intsize=0;/*size初始为0*/while(p->next!=null)/*循环计数*/{p=p->next;size++;}returnsize;}intlistinsert(slnode*head,inti,datatypex)/*在带头结点的单链表head的数据元素ai(0≤i≤size)结点前*//*填入一个存放数据元素x的结点*/{slnode*p,*q;intj;p=head;/*p指向首元结点*/j=-1;/*j起始为-1*/while(p->next!=null&&j<i-1)/*最终让指针p指向数据元素ai-1结点*/{p=p->next;j++;}if(j!=i-1){printf(\填入边线参数弄错!\return0;}/*生成新结点由指针q指示*/if((q=(slnode*)malloc(sizeof(slnode)))==null)exit(1);q->data=x;q->next=p->next;/*给指针q->next赋值*/p->next=q;/*给指针p->next重新赋值*/return1;}intlistdelete(slnode*head,inti,datatype*x)/*删除带头结点的单链表head的数据元素ai(0≤i≤size-1)结点*//*删除结点的数据元素域值由x带回。
单链表实验报告
单链表实验报告单链表的基本操作1.实验题目问题描述:实现带头结点的单链表的建立、求长度,取元素、修改元素、插入、删除等单链表的基本操作。
通过代码的编写理解并掌握单链表的过程编写以及作用。
2.实验要求(1)依次从键盘读入数据,建立一个单链表并将单链表的初始化设置为空;(2)通过操作选择,输出单链表中的数据元素(3)显示单链表的长度;(4)根据指定条件能够查找出元素和修改元素;(5)实现在指定位置插入和删除元素的功能(6)显示操作后的结果3.算法设计(1)用到的结构(逻辑结构、存储结构)逻辑结构:线性结构存储结构:带头结点的单链表(2)算法设计思路定义结点类型LNode,每个结点包括数据域data和指针域next。
定义头指针LinkList。
编写如下函数:1、createlist(LinkList &L);用尾插法创建一个带头结点的单链表。
2、print(LinkList L);输出该单链表中的数据元素。
3、ListLength(LinkList L);求该单链表的长度。
4、GetElem(LinkList &L,int i,ElemType &e);查找第i个元素。
5、SetElem(LinkList &L,int i,ElemType m);修改第i个元素。
6、ListInsert (LinkList &L, int i, ElemType e );在第i个元素前插入一个元素。
7、ListDelete(LinkList &L,int i,ElemType &e2);删除第i个元素。
8、main();通过case结构来调用createlist(LinkList &L)、GetElem(LinkList&L,int i,ElemType &e)、SetElem(LinkList &L,int i,ElemType m)、ListInsert (LinkList &L, int i, ElemType e )、ListDelete(LinkList &L,int i,ElemType &e2)4.调试和测试调试过程总结经过多次调试,本程序能很好的完成实验要求的各项功能。
数据结构单链表实验报告
数据结构单链表实验报告一、实验目的本次实验旨在深入理解和掌握数据结构中单链表的基本概念、操作原理及实现方法。
通过实际编程实现单链表的创建、插入、删除、查找等基本操作,提高对数据结构的理解和编程能力。
二、实验环境本次实验使用的编程环境为具体编程语言,编译工具为具体编译工具名称。
三、实验原理1、单链表的定义单链表是一种线性表的数据结构,它由一系列节点组成,每个节点包含数据域和指针域。
数据域用于存储节点的数据,指针域用于指向下一个节点的地址。
通过这种方式,将各个节点连接起来,形成一个链表。
2、单链表的基本操作创建单链表:从无到有构建一个单链表,可以通过逐个插入节点来实现。
插入节点:可以在链表的头部、尾部或指定位置插入新的节点。
删除节点:根据给定的条件或位置删除链表中的节点。
查找节点:在链表中查找满足特定条件的节点。
四、实验内容1、单链表节点的定义```具体编程语言typedef struct Node {int data;struct Node next;} Node;```2、创建单链表```具体编程语言Node createList(){Node head = NULL;Node newNode;int data;printf("请输入节点数据(输入-1 结束):");scanf("%d",&data);while (data!=-1) {newNode =(Node )malloc(sizeof(Node));newNode>data = data;newNode>next = NULL;if (head == NULL) {head = newNode;} else {Node temp = head;while (temp>next!= NULL) {temp = temp>next;}temp>next = newNode;}printf("请输入节点数据(输入-1 结束):");scanf("%d",&data);}return head;}```3、插入节点在头部插入```具体编程语言Node insertAtHead(Node head, int data) {Node newNode =(Node )malloc(sizeof(Node));newNode>data = data;newNode>next = head;head = newNode;return head;}```在尾部插入```具体编程语言void insertAtTail(Node head, int data) {Node newNode =(Node )malloc(sizeof(Node));newNode>data = data;newNode>next = NULL;Node temp = head;while (temp>next!= NULL) {temp = temp>next;}temp>next = newNode;}```在指定位置插入```具体编程语言void insertAtPosition(Node head, int position, int data) {Node newNode =(Node )malloc(sizeof(Node));newNode>data = data;if (position == 1) {newNode>next = head;head = newNode;return;}Node temp = head;int count = 1;while (temp!= NULL && count < position 1) {temp = temp>next;count++;}if (temp == NULL) {printf("位置无效\n");return;}newNode>next = temp>next;temp>next = newNode;}```4、删除节点删除头部节点```具体编程语言Node deleteAtHead(Node head) {if (head == NULL) {printf("链表为空,无法删除\n");return NULL;}Node temp = head;head = head>next;free(temp);return head;}```删除尾部节点```具体编程语言void deleteAtTail(Node head) {if (head == NULL) {printf("链表为空,无法删除\n");return;}Node prev = NULL;Node temp = head;while (temp>next!= NULL) {prev = temp;temp = temp>next;}if (prev == NULL) {head = NULL;} else {prev>next = NULL;}free(temp);}```删除指定节点```具体编程语言void deleteNode(Node head, int data) {Node prev = NULL;Node temp = head;while (temp!= NULL && temp>data!= data) {prev = temp;temp = temp>next;}if (temp == NULL) {printf("未找到要删除的数据\n");return;}if (prev == NULL) {head = temp>next;} else {prev>next = temp>next;}free(temp);}```5、查找节点```具体编程语言Node search(Node head, int data) {Node temp = head;while (temp!= NULL) {if (temp>data == data) {return temp;}temp = temp>next;}return NULL;}```6、打印单链表```具体编程语言void printList(Node head) {Node temp = head;while (temp!= NULL) {printf("%d ", temp>data);temp = temp>next;}printf("\n");}```五、实验结果1、成功创建了不同数据的单链表,并能够正确打印出链表中的数据。
实验(1)单链表操作
实验(1)单链表操作
实验(1)单链表操作
一、实验目的
掌握单链表的存储结构描述,掌握单链表的初始化、遍历等算法的描述,重点掌握单链表插入、删除算法的描述和算法应用。
二、实验原理
利用链式存储结构的特点实现单链表的基本操作和复杂操作。
三、实验设备
计算机,VC6.0开发工具
四、实验内容
1.给出单链表的存储类型描述。
2.实现单链表的初始化、插入、删除基本运算。
3.实现单链表的输入、输出运算。
4.实现单链表的逆置、有序性插入、归并等复杂运算。
5.编写主程序实现对这些运算的测试。
五、实验步骤
1.用VC建立一个控制台应用程序,命名为List。
2.新建一个头文件,命名为DataStru.h,包含标示符常量的定义和Status 类型定义。
3.新建一个头文件,命名为LinkList.h,包含单链表的存储类型描述和基本运算的实现。
4.新建一个主程序文件,命名为LinkListMain.cpp,包含单链表的逆置、有序性插入、归并等复杂运算的实现,以及对这些运算的测试。
六、实验报告要求
包含以下内容:
1.程序源代码;
2.实验测试数据和结果分析;
3.结论体会。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
请写出具体的实验步骤,并给出相应的实验结果,附上编写的程序及其运行结果截图!!
程序如下:
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef int ElemType;
typedef struct LNode
{
ElemType data;
p->next=q;
p=p->next;
}
printf(L);
return 0;
}
int ListInsert(Linklist &L)
{
Linklist p,s;
int i,j,e;
printf("请输入要插入的元素的位置和值:");
scanf("%d%d",&i,&e);
p=L;
j=0;
while(p&&j<i-1)
{
p=p->next;
++j;
}
if(!p||j<i-1)
{
printf("i的值不合法!");
return 0;
}
s=(Linklist)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;
p->next=s;
printf(L);
return 0;
}
int ListDelete(Linklist &L)
p=head->next;
while(p)
{
i++;
p=p->next;
}
return i;
}
void main()
{
Linklist La,Lb;
int i;
printf("1.插入新元素\n");
printf("2.删除新元素\n");
loop:printf("请做出选择:");
scanf("%d",&i);
if(i==1){creat(La);ListInsert(La);}
if(i==2){creat(Lb);ListDelete(Lb);}
printf("是否继续操作,是1,否2:");
scanf("%d",&i);
if(i==1)goto loop;
}
运行结果截图如下:
技术原理:程序=算法+数据结构;首先写出单链表每个操作的算法,再将这些算法有机的连接起来即得到完整的程序。
{
Linklist p,q;
int i,j,e;
printf("请输入要删除元素的位置:");
scanf("%d",&i);
p=L;
j=0;
while(p->next&&j<i-1)
{
p=p->next;
++j;
}
if(!(p->next)||j>i-1)
{
printf("删除位置不合法!");
return 0;
教师评阅意见
教师签字
签字日期
年月日
实验步骤:1、创建一个空链表;
2、用元素插入法创建链表;
3、编写元素插入的算法;
4、编写元素删除的算法;
5、编写主函数;
6、编译程序;
7、检查并修改错误至编译时无误;
8、执行程序。
实
验
心
得
平时总是眼高手低,只注重理解,忽视了动手操作的重要性,以至于在上级编写程序时错误一个接一个的出现,甚至同一个错误会出现多次;平时只写某个操作的算法,当需要将这些算法放在同一个程序中一起操作时,在连接过程中往往会有些困难;对有些操作的算法,思考的不全面;另外,对书本上的知识点理解的还不够透彻
}
q=p->next;
p->next=q->next;
e=q->data;
free(q);
printf(L);
return 0;
}
void Listsort(Linklist &head,int n)
{
Linklist p,q;
int i,j;
for(i=0;i<n;i++)
{
p=head;
q=p->next;
struct LNode *next;
}LNode,*Linklist;
int printf(Linklist &L)
{
Linklist p;
p=L->next;
if(L->next!=NULL)
do{printf("%4d",p->data);
p=p->next;}
while(p!=NULL);
printf("\n");
数学与计算机科学系实验报告
课程:数据结构地点:实验室时间:来自010年12月7日学生姓名
孙彩玲
班级
计本(2)班
学号
090312259
成绩
组别
无
同组姓名
无
仪器编号
实验项目
单链表实验
指导教师
帅小应
实验目的
掌握单链表的基本操作
实验要求
建立单链表
进行插入操作
进行删除操作
实验环境
硬件:计算机
软件:windowsXP,C
return 0;
}
int creatempty(Linklist &L)
{
L=(Linklist)malloc(sizeof(LNode));
L->next=NULL;
return 0;
}
int creat(Linklist &L)
{
Linklist p,q;
int i,a;
printf("初始化链表\n");
creatempty(L);
p=L;
printf("请输入链表元素个数:");
scanf("%d",&a);
printf("请输入元素值:");
for(i=0;i<a;i++)
{
q=(Linklist)malloc(sizeof(LNode));
scanf("%d",&q->data);
q->next=p->next;
for(j=0;j<n-1;j++)
if(p->next->data>q->next->data)
{
p->next=q->next;
q->next=q->next->next;
p->next->next=q;
p=p->next;
}
}
}
int len(Linklist &head)
{
int i=0;
Linklist p;