实验二单链表基本操作技巧
单链表的基本操作实验报告
单链表的基本操作实验报告单链表的基本操作实验报告引言:单链表是一种常见的数据结构,它由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。
在本次实验中,我们将学习和实践单链表的基本操作,包括创建链表、插入节点、删除节点以及遍历链表等。
一、实验目的本次实验的主要目的是掌握单链表的基本操作,包括链表的创建、插入节点、删除节点和遍历链表。
通过实践操作,加深对单链表的理解,并掌握如何应用单链表解决实际问题。
二、实验过程1. 创建链表首先,我们需要创建一个空链表。
链表可以通过一个头节点来表示,头节点不存储数据,只用于标识链表的起始位置。
我们可以定义一个指针变量head,将其指向头节点。
2. 插入节点在链表中插入节点是常见的操作。
我们可以选择在链表的头部、尾部或者指定位置插入节点。
插入节点的过程可以分为以下几个步骤:a. 创建一个新节点,并为其赋值;b. 找到要插入位置的前一个节点;c. 将新节点的指针指向前一个节点的下一个节点;d. 将前一个节点的指针指向新节点。
3. 删除节点删除节点是另一个常见的操作。
我们可以选择删除链表的头节点、尾节点或者指定位置的节点。
删除节点的过程可以分为以下几个步骤:a. 找到要删除节点的前一个节点;b. 将前一个节点的指针指向要删除节点的下一个节点;c. 释放要删除节点的内存空间。
4. 遍历链表遍历链表是为了查看链表中的元素。
我们可以从头节点开始,依次访问每个节点,并输出节点的值。
三、实验结果在本次实验中,我们成功完成了单链表的基本操作。
通过创建链表、插入节点、删除节点和遍历链表等操作,我们可以方便地对链表进行增删改查操作。
四、实验总结通过本次实验,我们对单链表的基本操作有了更深入的了解。
单链表是一种非常重要的数据结构,广泛应用于各个领域。
掌握了单链表的基本操作,我们可以更好地解决实际问题,并且为以后学习更复杂的数据结构打下坚实的基础。
在实验过程中,我们还发现了一些问题和不足之处。
单链表的基本操作
10)调用头插法的函数,分别输入10,20,分别回车:
11)调用尾插法的函数,分别输入30,40
12)查找单链表的第四个元素:
13)主函数中传入参数,删除单链表的第一个结点:
14)主函数传入参数,删除第0个未位置的元素,程序报错:
15)最后,输出单链表中的元素:
return 0;
}
6)编译,连接,运行源代码:
7)输入8,回车,并输入8个数,用空格分隔开,根据输出信息,可以看出,链表已经拆分为两个
五、实验总结
1.单链表采用的是数据+指针的表示形式,指针域总是指向下一个结
点(结构体)的地址,因此,在内存中的地址空间可以是不连续的,操作比顺序存储更加的方便
2.单链表使用时,需要用malloc函数申请地址空间,最后,删除元
素时,使用free函数释放空间。
数据结构实验报告--单链表
数据结构实验报告--单链表数据结构实验报告--单链表1.引言1.1 研究目的本实验旨在通过实践的方式,深入了解单链表的数据结构以及相关操作,提升对数据结构的理解和应用能力。
1.2 实验内容本实验主要包括以下几个方面的内容:●单链表的基本定义和实现●单链表的插入、删除、遍历操作●单链表的逆置操作●单链表的查找和修改操作2.理论基础2.1 单链表的定义单链表是一种常见的线性数据结构,它由一系列的节点组成,每个节点包含数据和指向下一个节点的指针。
2.2 单链表的基本操作①单链表的插入操作在单链表中,可以通过插入操作在指定位置插入一个新节点,该操作主要包括以下步骤:●创建一个新的节点,并为其赋值●将新节点的next指针指向插入位置的后一个节点●将插入位置的前一个节点的next指针指向新节点②单链表的删除操作在单链表中,可以通过删除操作删除指定位置的节点,该操作主要包括以下步骤:●将删除位置的前一个节点的next指针指向删除位置的后一个节点●释放删除节点的内存③单链表的遍历操作单链表的遍历操作主要是依次访问链表中的每一个节点,并执行相应的操作。
④单链表的逆置操作单链表的逆置操作可以将一个单链表中的节点顺序进行颠倒。
⑤单链表的查找操作在单链表中,可以通过查找操作找到指定值的节点。
⑥单链表的修改操作在单链表中,可以通过修改操作修改指定位置的节点的值。
3.实验过程3.1 实验环境本次实验使用C语言进行编程,需要先安装相应的编程环境,如gcc编译器。
3.2 实验步骤①单链表的创建和初始化首先创建一个空链表,并初始化链表的头指针。
②单链表的插入操作按照需求,在链表的指定位置插入一个新节点。
③单链表的删除操作按照需求,删除链表中的指定位置的节点。
④单链表的遍历操作依次访问链表中的每一个节点,并输出其值。
⑤单链表的逆置操作将单链表中的节点顺序进行逆置。
⑥单链表的查找操作按照需求,在链表中查找指定值的节点。
3.2.7 单链表的修改操作按照需求,修改链表中指定位置的节点的值。
数据结构 单链表基本操作代码
数据结构单链表基本操作代码```一、单链表基本概念单链表是一种常见的线性存储结构,由一系列节点组成。
每个节点包括数据域和指针域,数据域存储具体的数据,指针域指向下一个节点。
二、单链表基本操作2.1 创建链表创建一个空链表,即没有任何节点。
可以选择初始化一个头节点,也可以直接初始化为空。
2.2 在链表头部插入节点在链表头部插入新节点。
将新节点的指针域指向原头节点,然后更新头节点指针,使其指向新节点。
2.3 在链表尾部插入节点在链表尾部插入新节点。
遍历链表找到尾节点,然后将尾节点的指针域指向新节点。
2.4 在指定位置插入节点在链表的指定位置插入新节点。
遍历链表找到指定位置的节点,然后将新节点的指针域指向下一个节点,再将指定位置的节点的指针域指向新节点。
2.5 删除链表头节点删除链表头节点,即将头节点的指针指向下一个节点,然后删除原头节点。
2.6 删除链表尾节点删除链表尾节点,即遍历链表找到尾节点的上一个节点,将其指针域置空,然后删除尾节点。
2.7 删除指定位置的节点删除链表的指定位置节点,即遍历链表找到指定位置节点的上一个节点,将其指针域指向下一个节点,然后删除指定位置节点。
2.8查找链表中是否存在某个元素遍历链表,逐个比较节点的数据域与目标元素,直到找到匹配或遍历到链表末尾。
2.9获取链表长度遍历链表,计数节点的个数,直到遍历到链表末尾。
三、附件暂无附件。
四、法律名词及注释本文档未涉及任何法律名词及其注释。
```。
实验2-链表的应用
实验2 链表的应用一、实验目的●了解并掌握链表的概念与定义●能够实现并运用链表●熟练运用链表的基本操作二、实验环境●个人计算机一台,CPU主频1GHz以上,1GB以上内存,2GB以上硬盘剩余空间。
●Windows2000、Windows XP或Win 7操作系统●Code::Blocks(版本12.11或近似版本,英文版),或VC++ 6.0三、实验内容1 基本部分(必做)1.单向链表的创建与操作设单向链表中节点的数据域的数据类型为整型,编写函数实现以下操作:(1)实现单向链表的创建(包括初始化)与输出操作,节点的个数及节点的数据由用户输入。
(源代码:ds3-1.c)(2)查找给定的单链表中的第i个节点,并将其地址返回。
若不存在第i 个节点,则返回空地址。
(源代码:ds3-2.c)(3)查找给定的单链表中值为n的节点,并将其地址返回。
若不存在值为n的节点,则返回空地址。
同时,还应通过参数传回该节点的序号。
(源代码:ds3-3.c)(4)删除给定的单链表中的第i个节点,成功返回1,失败返回0。
(源代码:ds3-4.c)(5)删除给定的单链表中值为n的节点,成功返回1,失败返回0。
(源代码:ds3-5.c)(6)在给定的单链表的第i位上插入值为n的节点。
(源代码:ds3-6.c)(7)在给定单链表的值为m的节点的前面插入一个值为n的节点。
(源代码:ds3-7.c)2.双向循环链表的创建与操作设双向链表中节点的数据域的数据类型为整型,编写函数实现以下操作:(1)实现双向循环链表的创建(包括初始化)与输出操作,节点的个数及节点的数据可以在程序中直接确定。
(源代码:ds4-1.c)(2)删除给定的双向循环链表中值为n的节点,成功返回1,失败返回0。
(源代码:ds4-2.c)(3)在给定的双向循环链表中的第i位上插入值为n的节点,成功返回1,失败返回0。
(源代码:ds4-3.c)2 提高部分(选做)已知链表A和B中节点的值都按照从小到大的顺序排序,且任何两个节点的值都不相同。
数据结构单链表实验报告
数据结构单链表实验报告一、实验目的1、深入理解单链表的数据结构及其基本操作。
2、掌握单链表的创建、插入、删除、查找等操作的实现方法。
3、通过实际编程,提高对数据结构和算法的理解和应用能力。
二、实验环境1、操作系统:Windows 102、编程语言:C 语言3、开发工具:Visual Studio 2019三、实验原理单链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据域和指针域。
指针域用于指向下一个节点,从而形成链表的链式结构。
单链表的基本操作包括:1、创建链表:通过动态分配内存创建链表的头节点,并初始化链表为空。
2、插入节点:可以在链表的头部、尾部或指定位置插入新的节点。
3、删除节点:根据给定的条件删除链表中的节点。
4、查找节点:在链表中查找满足特定条件的节点。
四、实验内容(一)单链表的创建```cinclude <stdioh>include <stdlibh>//定义链表节点结构体typedef struct Node {int data;struct Node next;} Node;//创建单链表Node createList(){Node head =(Node)malloc(sizeof(Node));if (head == NULL) {printf("内存分配失败!\n");return NULL;}head>data = 0;head>next = NULL;return head;}int main(){Node list = createList();//后续操作return 0;}```在创建单链表时,首先为头节点分配内存空间。
若内存分配失败,则提示错误信息并返回`NULL`。
成功分配内存后,初始化头节点的数据域和指针域。
(二)单链表的插入操作插入操作分为三种情况:头部插入、尾部插入和指定位置插入。
1、头部插入```cvoid insertAtHead(Node head, int data) {Node newNode =(Node)malloc(sizeof(Node));if (newNode == NULL) {printf("内存分配失败!\n");return;}newNode>data = data;newNode>next = head>next;head>next = newNode;}```头部插入时,创建新节点,将新节点的数据域赋值,并将其指针域指向原头节点的下一个节点,然后更新头节点的指针域指向新节点。
实验二 链表操作实现
实验二链表操作实现实验日期:2017 年 3 月16 日实验目的及要求1. 熟练掌握线性表的基本操作在链式存储上的实现;2. 以线性表的各种操作(建立、插入、删除、遍历等)的实现为重点;3. 掌握线性表的链式存储结构的定义和基本操作的实现;4. 通过本实验加深对C语言的使用(特别是函数的参数调用、指针类型的应用)。
实验内容已知程序文件linklist.cpp已给出学生身高信息链表的类型定义和基本运算函数定义。
(1)链表类型定义typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别,0为男生,1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;(2)带头结点的单链表的基本运算函数原型LinkList initList();/*置一个空表(带头结点)*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/* 创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*对单链表进行结点倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*/任务一创建程序文件linklist.cpp,其代码如下所示,理解LinkList类型和基本运算函数后回答下列问题。
#include <stdio.h>#include <stdlib.h>/*单链表结点类型*/typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别,0为男生,1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;/*带表头的单链表的基本运算函数*/LinkList initList();/*置一个空表(带头结点)*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/*创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*单链表倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*//*置一个空表*/LinkList initList(){ LinkList p;p=(LinkList)malloc(sizeof(LinkNode));p->next=NULL;return p;}/*创建单链表*/void createList_1(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=head->next;head->next=p;}fclose(fp);}/*创建单链表*/void createList_2(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p,rear;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}rear=head;while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=NULL;rear->next=p;rear=p;}fclose(fp);}/*单链表排序*/void sort_xh(LinkList head){LinkList q,p,u;p=head->next;head->next=NULL;/*利用原表头结点建新的空表*/while(p){ q=p; /*q为被插入的结点*/p=p->next;/*用p记录后继结点*//*遍历新链表查找插入位置*/u=head;while(u->next!=NULL)/*查找插入位置*/{ if(u->next->data.xh>q->data.xh)break;u=u->next;}/*插入在u结点的后面*/q->next=u->next;u->next=q;}}/*单链表倒置*/void reverse(LinkList head){ LinkList p, r;p=head->next;head->next=NULL;while(p){ r=p;p=p->next;/*r指向结点头插到链表*/r->next=head->next;head->next=r;}}/*输出单链表*/void pntList(LinkList head){ LinkList p;p=head->next;while(p!=NULL){printf("%2d: %.2f %d\n",p->data.xh,p->data.sg,p->data .sex);p=p->next;}}/*自定义错误处理函数*/void Error(char *s){ printf("\n %s", s);exit(1); /*返回OS,该函数定义在stdlib.h中*/}/*保存单链表到文件*/void save(LinkList head,char strname[]){ FILE *fp;LinkList p;if((fp=fopen(strname,"w"))==NULL){ printf("can not open file !");return ;}p=head->next;while(p!=NULL){ fprintf(fp,"%2d %5.2f %2d\n",p->data.xh,p->data.sg,p->data.sex);p=p->next;}fclose(fp);}请回答下列问题:(1)由单链表结点类型定义可知,该链表结点类型名为 LinkNode ,结点的指针类型为 LinkList ,向系统申请一个学生结点空间并把起始地址存于上述结点指针变量new 中的语句是: p=(LinkList)malloc(sizeof(LinkNode)); 。
数据结构实验二链表
数据结构实验二1、实验目的∙熟练掌握线性表的链式存储结构定义及基本操作∙理解循环链表和双链表的特点和基本运算2、实验内容:建立单链表,完成链表(带表头结点)的基本操作:建立链表、插入、删除、查找、输出、求前驱、求后继、两个有序链表的合并操作。
其他基本操作还有销毁链表、将链表置为空表、求链表的长度、获取某位置结点的内容、搜索结点。
1.问题描述:利用线性表的链式存储结构,设计一组输入数据(假定为一组整数),能够对单链表进行如下操作:∙初始化一个带表头结点的空链表;∙创建一个单链表是从无到有地建立起一个链表,即一个一个地输入各结点数据,并建立起前后相互链接的关系。
又分为逆位序(插在表头)输入n 个元素的值和正位序(插在表尾)输入n 个元素的值;∙插入结点可以根据给定位置进行插入(位置插入),也可以根据结点的值插入到已知的链表中(值插入),且保持结点的数据按原来的递增次序排列,形成有序链表。
∙删除结点可以根据给定位置进行删除(位置删除),也可以把链表中查找结点的值为搜索对象的结点全部删除(值删除);∙输出单链表的内容是将链表中各结点的数据依次显示,直到链表尾结点;∙求前驱结点是根据给定结点的值,在单链表中搜索其当前结点的后继结点值为给定的值,将当前结点返回;∙求后继结点是根据给定结点的值,在单链表中搜索其当前结点的值为给定的值,将后继结点返回;∙两个有序链表的合并是分别将两个单链表的结点依次插入到第3 个单链表中,继续保持结点有序;编写主程序,实现对各不同的算法调用。
其它的操作算法描述略。
2.实现要求:对链表的各项操作一定要编写成为C(C++)语言函数,组合成模块化的形式,还要针对每个算法的实现从时间复杂度和空间复杂度上进行评价。
∙“初始化算法”的操作结果:构造一个空的线性表L,产生头结点,并使L 指向此头结点;∙“建立链表算法”初始条件:空链存在;操作结果:选择逆位序或正位序的方法,建立一个单链表,并且返回完成的结果;∙“链表(位置)插入算法”初始条件:已知单链表L 存在;操作结果:在带头结点的单链线性表L 中第i 个位置之前插入元素e;∙“链表(位置)删除算法”初始条件:已知单链表L 存在;操作结果:在带头结点的单链线性表L 中,删除第i 个元素,并由e 返回其值;∙“输出算法”初始条件:链表L 已存在;操作结果:依次输出链表的各个结点的值;∙“求前驱算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是第一个,则用pre_e 返回它的前驱;∙“求后继算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是最后一个,则用next_e 返回它的后继;∙“两个有序链表的合并算法”初始条件: 线性表单链线性表La 和Lb 的元素按值非递减排列;操作结果:归并La 和Lb 得到新的单链表。
单链表的基本操作
实验二:单链表的基本操作编写一个完整的程序,实现单链表的建立、插入、删除、输出等基本操作。
(1)建立一个带头结点的单链表。
(2)计算单链表的长度,然后输出单链表。
(3)查找值为x的直接前驱结点q。
(4)删除值为x的结点。
(5)把单向链表中元素逆置(不允许申请新的结点空间)。
(6)已知单链表中元素递增有序,请写出一个高效的算法,删除表中所有值大于mink且小于maxk的元素(若表中存在这样的元素),同时释放被删结点空间,并分析你的算法的时间复杂度(注意:mink和maxk是给定的两个参变量,他们的值可以和表中的元素相同,也可以不同)。
(7)同(6)的条件,试写一高效的算法,删除表中所有值相同的多余元素(使得操作后的线性表中所有元素的值均不相同),同时释放被删结点空间,并分析你的算法时间复杂度。
(8)利用(1)建立的链表,实现将其分解成两个链表,其中一个全部为奇数,另一个全部为偶数(尽量利用已知的存储空间)。
(9)在主函数中设计一个简单的菜单,分别测试上述算法。
# include <stdio.h># include <stdlib.h>typedef struct node{int data;struct node * next;}Lnode, * LinkList;int m=sizeof(Lnode);//建立新的链表void Bulid_List(LinkList root){int num;LinkList s,p;s=root->next;int n;printf("请输入新建链表的长度n数据:\n"); scanf("%d",&n);printf("请依次建立链表:");for(int i=0;i<n;i++){scanf("%d",&num);s->data=num;p=(LinkList)malloc(m);s->next=p;s=p;s->next=NULL;}printf("链表已建立!\n");}//对链表的输出,包括长度和元素void OutPut_list(LinkList root) {int len=0;LinkList s;s=root->next;if(s->next==NULL)printf("单链表无数据,请先新建单链表。
实验二:单链表基本运算实现
{
int data; //存放表结点值
struct node *next; //存放表结点的直接后驱元素的地址
} ListNode,*LinkList;
//头插法创建初始链表
LinkList create_h(int size)
{
;//将工作指针p指向后一个结点
;//计数器累加
}
return i;
}
//打印链表中的现有元素
printList(LinkList head)
{
LinkList p;
;//将工作指针p指向第1个结点
{
p=(LinkList)malloc(sizeof(ListNode));//申请新结点的存储空间
scanf("%d",&p->data);//读入新结点的值到data域中
;//将新增结点插到头结点的后面
;//将新增结点插到头结点的后面
printf("————头插法建立链表(1)\n");
printf("————尾插法建立链表(2)\n");
printf("————按位查找元素(3)\n");
printf("————按值查找元素(4)\n");
printf("————插入元素(5)\n");
printf("————删除元素(6)\n");
printList(h);
break;
case 5:
printf("插入元素,请输入要插入元素的值:\n");
实验二 单链表基本操作
实验二单链表基本操作一实验目的1.学会定义单链表的结点类型,实现对单链表的一些基本操作和具体的函数定义,了解并掌握单链表的类定义以及成员函数的定义与调用。
2.掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。
二实验要求1.预习C语言中结构体的定义与基本操作方法。
2.对单链表的每个基本操作用单独的函数实现。
3.编写完整程序完成下面的实验内容并上机运行。
4.整理并上交实验报告。
三实验内容1.编写程序完成单链表的下列基本操作:(1)初始化单链表La。
(2)在La中第i个元素之前插入一个新结点。
(3)删除La中的第i个元素结点。
(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所指的结点之后。
3.构造一个单链表L,其头结点指针为head,编写程序实现将L逆置。
(即最后一个结点变成第一个结点,原来倒数第二个结点变成第二个结点,如此等等。
)四思考与提高1.如果上面实验内容2中合并的表内不允许有重复的数据该如何操作?2.如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb,Lc,使得Lb中只含La表中奇数结点,Lc中含有La表的偶数结点?1.编写程序完成单链表的下列基本操作:(1)初始化单链表La。
(2)在La中第i个元素之前插入一个新结点。
(3)删除La中的第i个元素结点。
(4)在La中查找某结点并返回其位置。
(5)打印输出La中的结点元素值。
#include<stdio.h>#include<stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0typedef int Status;typedef int ElemType;//定义存储结构typedef struct Lnode{int data; /*每个元素数据信息*/struct Lnode *next; /*存放后继元素的地址*/} LNode,*LinkList;int main(){void Create_L(LinkList &L,int n);void Print_L(LinkList L);Status ListInsert_L(LinkList &L,int i,ElemType e);Status ListDelete_L(LinkList &L,int i,ElemType &e);Status Find_L(LinkList L,int e);LinkList La;//创建单链表Laint n;printf("请输入链表La中的元素个数:\n");scanf("%d",&n);Create_L(La,n);//初始化单链表printf("现在La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备插入元素,请输入插入位置及所插入元素的值\n");int i,e;scanf("%d %d",&i,&e);ListInsert_L(La,i,e);printf("插入后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备删除元素,请输入删除位置\n");scanf("%d",&i);ListDelete_L(La,i,e);printf("删除后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("请输入所要查找元素的值:\n");scanf("%d",&e);Find_L(La,e);printf("所要查找元素的位置为:%d\n",Find_L(La,e)); }void Create_L(LinkList &L,int n){int j=1;L=(LinkList)malloc(sizeof(Lnode));L->next =NULL;//先建立一个带头结点的单链线性表L for(int i=n;i>0;--i){LinkList p=(LinkList)malloc(sizeof(Lnode));printf("请输入链表La中的第%d个元素:\n",j++);scanf("%d",&p->data);p->next=L->next;L->next =p;}//(逆序实现)/*LinkList q=L;for(int i=1;i<=n;i++){LinkList p=(LinkList)malloc (sizeof(Lnode));q->next=p;p->next=NULL;q=q->next ;printf("请输入链表La中的第%d个元素:\n",i);scanf("%d",&p->data);}//(正序实现)*/}//初始化单链表//输出单链表void Print_L(LinkList L){LinkList p;p=L->next;while(p){printf("%d ",p->data );p=p->next;}printf("\n");}//在单链表L的第i个位置前插入元素eStatus ListInsert_L(LinkList &L,int i,ElemType e) {LinkList p=L;int j=0;while(p&&j<i-1){p=p->next; ++j;}if(!p||j>i-1) return ERROR;LinkList s=(LinkList)malloc(sizeof(LNode));s->data=e; s->next=p->next;p->next=s;return OK;} //ListInsert_L//删除单链表L中第i个位置上的元素Status ListDelete_L(LinkList &L,int i,ElemType &e) {LinkList p=L;int j=0;while( p->next && j<i-1){p=p->next; ++j;}if(!p->next||j>i-1) return ERROR;LinkList q=p->next; p->next=q->next;e=q->data;free(q);return OK;}//LinkDelete_L/*查找元素并返回位置*/Status Find_L(LinkList L,int e){LinkList p=L->next;int j=1;while(p->data!=e&&p->next){p=p->next;j++;}if(p->data==e) return j;else{printf("无当前元素\n");return ERROR;}if(!p){printf("无当前元素\n");return ERROR;}}//定位2 .构造两个带有表头结点的有序单链表La、Lb,编写程序实现将La、Lb合并成一个有序单链表Lc。
单链表的基本操作(查找,插入,删除)
单链表的基本操作(查找,插⼊,删除)这周⽼师给的作业跟上周貌似差不多。
只是⽤了单链表。
完成单链表的基本操作函数。
1) 初始化单链表2) 给定的数据元素存放在⼀维数组中,分别完成头插法和尾插法建⽴单链表3) 将数据元素从键盘依次输⼊,分别完成头插法和尾插法建⽴单链表4) 输出单链表的长度5) 实现按位查找和按值查找6) 实现插⼊和删除操作7) 实现遍历单链表操作#include <cstdio>#include <cstring>#include <cstdlib>//查找1.内容2.序号//插⼊//删除typedef struct student{int num;char name[10];}STU;typedef struct Node{STU data;struct Node * next;}Node;void denglu(Node *L);//登录函数void chazhao(Node *L);//查找函数void Printf(Node *L);//输出函数void CreateFromHead(Node *L);//头插法void CreateFormTail(Node *L);//尾插法void panduan(Node *L);//判断头插还是尾插void Get(Node *L);//按序号结点查找void Locate(Node *L);//按内容查找(值)void Inslist(Node *L);//插⼊void Dellist(Node *L);//删除void Dellist(Node *L)//删除{system("CLS");int n;printf("请输⼊要删除的结点\n");scanf("%d",&n);if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Dellist(L);}Node *pre,*r;int k=0;pre=L;while(pre->next !=NULL&&k<n-1){pre=pre->next;k=k+1;}if(pre->next==NULL){printf("没有找到该结点,请重新输⼊\n");Dellist(L);}r=pre->next;pre->next=r->next;free(r);printf("删除成功!\n");denglu(L);}void Inslist(Node *L)//插⼊{system("CLS");int n;printf("请输⼊在第⼏个位置插⼊数据\n");scanf("%d",&n);printf("请输⼊插⼊的学号,姓名\n");int num1;char name1[10];scanf("%d %s",&num1,name1);Node *pre,*s;int k=0;if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Inslist(L);}pre=L;while(pre!=NULL&&k<n-1){pre=pre->next;k=k+1;}if(pre==NULL){printf("⽆法找到该节点,请重新输⼊\n");Inslist(L);}s=(Node*)malloc(sizeof(Node));strcpy(s->data .name ,name1);s->data.num=num1;s->next =pre->next ;pre->next =s;printf("插⼊成功!\n");denglu(L);}void Locate(Node *L)//按内容查找(值){system("CLS");int n;printf("请输⼊要查找的学号\n");scanf("%d",&n);Node *p;p=L->next;while(p!=NULL){if(p->data.num!=n){p=p->next;}elsebreak;}printf("你要查找的学号所对应的信息为%d %s\n",p->data.num,p->);denglu(L);}void Get(Node *L)//按序号结点查找{system("CLS");int n;printf("请输⼊你要查找的结点\n");scanf("%d",&n);if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Get(L);}Node *p;p=L;int j=0;while((p->next!=NULL)&&(j<n)){p=p->next;j++;}if(n==j){printf("你要查找的结点的储存位置的数据为%d %s\n",p->data.num,p->); }denglu(L);}void Printf(Node *L){int q=0;Node *p=L->next;while(p!=NULL){q++;printf("%d %s\n",p->data.num,p->); p=p->next;}printf("单链表长度为%d\n",q);denglu(L);}void chazhao(Node *L){printf("1.按序号查找\n");printf("2.按内容查找\n");printf("3.返回主界⾯\n");int aa;scanf("%d",&aa);switch(aa){case 1:Get(L);case 2:Locate(L);case 3:denglu(L);break;default:printf("输⼊错误请重新输⼊\n");chazhao(L);}}void denglu(Node *L){int a;printf("请选择你要做什么\n");printf("1.查找\n");printf("2.插⼊\n");printf("3.删除\n");printf("4.打印现有的学⽣信息及单链表长度\n"); printf("5.退出\n");scanf("%d",&a);switch(a){case 1:chazhao(L);case 2:Inslist(L);case 3:Dellist(L);case 4:Printf(L);case 5:printf("谢谢使⽤\n");exit(0);default:printf("输⼊错误请重新输⼊\n");denglu(L);}}void CreateFromHead(Node *L)//头插法{Node *s;int n;//n为元素个数printf("请输⼊元素个数\n");scanf("%d",&n);printf("请输⼊学号姓名\n");for(int i=1;i<=n;i++){s=(Node *)malloc(sizeof(Node));scanf("%d %s",&s->data.num,s->); s->next=L->next;L->next=s;}}void CreateFormTail(Node *L)//尾插法{Node *s,*r;r=L;int n;//n为元素个数printf("请输⼊元素个数\n");scanf("%d",&n);printf("请输⼊学号姓名\n");for(int i=1;i<=n;i++){s=(Node *)malloc(sizeof(Node));scanf("%d %s",&s->data.num,s->);r->next=s;r=s;if(i==n){r->next=NULL;}}}Node *InitList(Node *L)//初始化单链表{L=(Node *)malloc(sizeof(Node));L->next=NULL;return L;}void panduan(Node *L){int q;printf("请选择⽤哪种⽅式建⽴链表\n");printf("1.头插法\n");printf("2.尾插法\n");scanf("%d",&q);switch(q){case (1):CreateFromHead(L);printf("输⼊成功!\n");break;case (2):CreateFormTail(L);printf("输⼊成功!\n");break;default:printf("输⼊错误请重新输⼊\n");panduan(L);}}int main(){Node *L=NULL;L=InitList(L);panduan(L);denglu(L);return 0;}ps.贴上来的代码空格有点⼩奇怪啊。
数据结构c++顺序表、单链表的基本操作,查找、排序代码
} return 0; }
实验三 查找
实验名称: 实验3 查找 实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序 树和哈希表的构造和查找方法。通过上机操作,理解如何科学地组织信 息存储,并选择高效的查找算法。 实验内容:(2选1)内容1: 基本查找算法;内容2: 哈希表设计。 实验要求:1)在C++系统中编程实现;2)选择合适的数据结构实现查 找算法;3)写出算法设计的基本原理或画出流程图;4)算法实现代码 简洁明了;关键语句要有注释;5)给出调试和测试结果;6)完成实验 报告。 实验步骤: (1)算法设计 a.构造哈希函数的方法很多,常用的有(1)直接定址法(2)数字分析法;(3) 平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法;本实验采用的是除 留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈 希地址 (2)算法实现 hash hashlist[n]; void listname(){ char *f; int s0,r,i; NameList[0].py="baojie"; NameList[1].py="chengቤተ መጻሕፍቲ ባይዱoyang"; ……………………………… NameList[29].py="wurenke"; for(i=0;i<q;i++){s0=0;f=NameList[i].py; for(r=0;*(f+r)!='\0';r++) s0+=*(f+r);NameList[i].k=s0; }} void creathash(){int i;
v[k-1]=v[k]; nn=nn-1; return ; } int main() {sq_LList<double>s1(100); cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.ins_sq_LList(0,1.5); s1.ins_sq_LList(1,2.5); s1.ins_sq_LList(4,3.5); cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.del_sq_LList(0); s1.del_sq_LList(2); cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); return 0; } 运行及结果:
实验二 单链表的插入和删除
实验二 单链表的插入和删除1.实验目的:了解单链表的基本概念、结构的定义及在单链表上的基本操作(插入、删除、查找以及线性表合并),通过在VC 实现以上操作更好的了解书本上的内容并体会线性表的两种存储结构的区别。
2.实验预备知识:⑴ 复习C 语言中指针的用法,特别是结构体的指针的用法;⑵ 了解单链表的概念,单链表的定义方法;单链表是线性表的链式存储表示,是用一组任意的存储单元依次存储线性表的数据元素。
因此,为了表示每个数据元素a i 与其直接后继元素a i+1之间的逻辑关系,对数据元素ai 来说,,除了存储其本身的信息之外,还需存储一个指示其直接后继的信息(即直接后继的存储位置),而这部分就是用指针来完成的。
⑶ 掌握线性表在链式存储结构上实现基本操作:查找、插入、删除的算法; 在实现这些算法的时候,要注意判断输入数据的合法性,除此之外还要要注意以下内容:在实现查找的时候,首先要判断该顺序表是否为空,其次要判断查找后的结果(查到时输出查到的数据,未查到时给出错误提示)。
在实现插入的时候,由于是链式存储,它可以随机产生和回收存储空间,所以它不要判断线性表是否为满,但仍需判断要插入的位置是否合法,原因同实验一,其次要注意插入的时候语句的顺序不可颠倒,否则出错。
例如:s 所指向结点要插入在p 所指向的结点之后,则:正确形式:s->next=p->nextp->next=s错误形式:p->next=ss->next=p->next(因为此时p->next 已经指向s 了)在实现删除的时候,首先要判断线性表是否为空,为空则不能删除; 其次在删除后要回收空间。
例如:删除如上图所示s 所指向的结点p->next=p->next->nextfree s3.实验内容:⑴ 单链表的插入算法⑵ 单链表的删除算法⑶循环链表的插入和删除算法4.部分实验代码:⑴单链表的结构定义:#include <stdio.h>typedef int elemtype;typedef struct lnode{ elemtype data;struct lnode *next;}*linklist;⑵建立单链表的算法int n; /*n作为整个程序的全局变量*/linklist *creat(void){ linklist *head, *p1, *p2;n=0;p1=p2=(linklist *)malloc(sizeof(linklist));scanf(“%d”,&p1->data);head=null;while(p1->data!=0){ n=n+1;if(n==1) head=p1;else p2->next=p1;p2=p1;p1=(linklist *)malloc(sizeof(linklist));scanf(“%d”,&p1->data);}p2->next=null;return(head);}⑶单链表的插入算法int insert(linklist *head, int i,elemtype e) { linklist *p, *s;int j;p=head; j=0;while(p && j<i-1){ p=p->next;++j;}if(!p||j>i-1){ printf(“无法插入”);return 0;}s=(linklist *)malloc(sizeof(lnode));s->data=e;s->next=p->next;p->next=s;return 1;}⑷单链表的删除算法int deltree(linklist *head,int i,elemtype e){ linklist *p, *q;int j;lp=head; 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);return 1;}。
数据结构 实验二:单链表的基本操作
数据结构实验二:单链表的基本操作数据结构实验二:单链表的基本操作实验二:单链表的基本操作一、【实验目的】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、单链表的基本操作2.1 初始化链表初始化链表时,将头指针置空,表示链表为空。
2.2 插入节点插入节点可以分为头插法和尾插法。
- 头插法:将新节点插入链表头部,新节点的指针域指向原头节点,头指针指向新节点。
- 尾插法:将新节点插入链表尾部,新节点的指针域置空,原尾节点的指针域指向新节点。
2.3 删除节点删除节点可以分为按位置删除和按值删除两种方式。
- 按位置删除:给定要删除节点的位置,修改前一节点的指针域即可。
- 按值删除:给定要删除节点的值,遍历链表找到对应节点,修改前一节点的指针域即可。
2.4 遍历链表遍历链表即按顺序访问链表的每个节点,并输出节点的数据。
2.5 查找节点查找节点可以分为按位置查找和按值查找两种方式。
- 按位置查找:给定节点的位置,通过遍历链表找到对应节点。
- 按值查找:给定节点的值,通过遍历链表找到第一个匹配的节点。
实验步骤:1、根据实验目的,定义单链表的结构体和基本操作函数。
2、实现初始化链表的函数,将头指针置空。
3、实现头插法或尾插法插入节点的函数。
4、实现按位置删除节点的函数。
5、实现按值删除节点的函数。
6、实现遍历链表的函数,输出节点的数据。
7、实现按位置查找节点的函数。
8、实现按值查找节点的函数。
9、设计实验样例,测试单链表的各种操作。
实验结果与分析:通过测试实验样例,我们可以验证单链表的各种操作是否正确。
如果出现异常情况,可通过调试找出问题所在,并进行修改。
单链表的操作时间复杂度与操作的位置有关,对于查找操作,时间复杂度为O(n);对于插入和删除操作,时间复杂度也为O(n)。
附件:1、单链表的定义和基本操作的源代码文件。
实验二 单链表操作
实验二单链表操作一、实验目的1.掌握握单链表的基本操作:插入、删除、查找等运算。
二、实验要求1.认真阅读和掌握本实验的程序。
2.上机运行本程序。
3.保存和打印出程序的运行结果,并结合程序进行分析。
4.按照你对单链表的操作需要,重新改写主程序并运行,打印出文件清单和运行结果三、实验内容单链表基本操作的实现四、实验步骤1、定义单链表的结构typedef struct Lnode{int *base;int *top;int stacksize;} *LinkList;2、定义单链表的几个常用操作:单链表的创建、插入、删除和查找。
void CreateList_L(LinkList &L,int n){L=(LinkList)malloc(sizeof(LNode));L->next=NULL;LNode *p;printf("请输入%d个元素\n",n);for(int i=n;i>0;--i){p=(LinkList)malloc(sizeof(LNode));scanf("%d",&p->data);p->next=L->next;L->next=p;}}单链表插入,删除和查找int ListInsert_L(LinkList &L,int i,int e){//找到第i-1个元素,让p指向它LNode *p=L;int j=0;while(p&&j<i-1){p=p->next;j++;}//没有找到的情况,i<1或者i>表长if(!p||j>i-1)return -1;//为新结点申请内存LNode *s=(LinkList)malloc(sizeof(LNode));s->data=e;//插入新结点s->next=p->next;p->next=s;return 1;}3、编写主函数测试单链表的操作void main(){LinkList L;int length;printf("输入你要创建单链表的长度\n");scanf("%d",&length);CreateList_L(L,length);Output(L);length=Listlen(L);printf("单链表的长度是:%d\n",length);int i;ElemType element;printf("输入你要查找的元素的位置:\n");scanf("%d",&i);GetElem_L(L,i,element);printf("第%d个元素的值是: ",i);printf(" %d\n",element);printf("输入你要插入的元素的位置:\n");scanf("%d",&i);printf("输入你要插入的元素的值:\n");scanf("%d",&element);ListInsert_L(L,i,element);printf("插入后的线性表是: ");Output(L);printf("输入你要删除的元素的位置:\n");scanf("%d",&i);ListDelete_L(L,i,element);printf("删除后的线性表是: ");Output(L);五、实验总结:附录:完整程序#include<malloc.h>#include <stdio.h>typedef int ElemType; //定义数据元素的类型为int,你也可以在这里把它改成其它数据类型//单链表结点的定义typedef struct LNode{int *base;int *top;int stacksize;} *LinkList;/*创建单链表*****************************************/void CreateList_L(LinkList &L,int n){L=(LinkList)malloc(sizeof(LNode));L->next=NULL;LNode *p;printf("请输入%d个元素\n",n);for(int i=n;i>0;--i){p=(LinkList)malloc(sizeof(LNode));scanf("%d",&p->data);p->next=L->next;L->next=p;}}/*输出单链表*****************************************/void Output(LinkList &L){//……//部分代码printf("开始输出单链表各个元素\n");//……printf("\n单链表结束!\n");}/*单链表的长度*****************************************/int Listlen(LinkList &L){//1、分配内存L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem)//申请内存失败的情况exit(OVERFLOW);L.length=0; //线性表的长度L.listsize=LIST_INIT_SIZE;//线性表L的容量return OK;}/*得到单链表中第i个元素的值*****************************************/ int GetElem_L(LinkList &L,int i,ElemType &e){}/*删除第i个元素*****************************************/int ListDelete_L(LinkList &L,int i,ElemType &e)/*在第i个位置上插入一个新的元素*****************************************/int ListInsert_L(LinkList &L,int i,ElemType e){//1、判断插入位置i是不是正确if(i<1||i>L.length+1)return ERROR;//2、判断线性表的存储空间是否已满if(L.length>=L.listsize){//满则追加内存ElemType *newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType) );//判断申请内存是否成功if(!newbase)//申请失败exit(OVERFLOW);//申请成功L.elem=newbase;L.listsize+=LISTINCREMENT;}//从第n个元素至第i个元素依次向后移动一个位置ElemType * q= &(L.elem[i-1]);//用q保存第i个元素的地址ElemType *p=&(L.elem[L.length-1]);//用p保存第n个元素的地址for( ;p>=q;--p){*(p+1)=*p;}*q=e;//将q插入到第i个位置++L.length;return OK;}/******************************************/void main(){LinkList L;int length;printf("输入你要创建单链表的长度\n");scanf("%d",&length);CreateList_L(L,length);Output(L);length=Listlen(L);printf("单链表的长度是:%d\n",length);int i;ElemType element;printf("输入你要查找的元素的位置:\n");scanf("%d",&i);GetElem_L(L,i,element);printf("第%d个元素的值是: ",i);printf(" %d\n",element);printf("输入你要插入的元素的位置:\n");scanf("%d",&i);printf("输入你要插入的元素的值:\n");scanf("%d",&element);ListInsert_L(L,i,element);printf("插入后的线性表是: ");Output(L);printf("输入你要删除的元素的位置:\n");scanf("%d",&i);ListDelete_L(L,i,element);printf("删除后的线性表是: ");Output(L);}。
链表基本操作实验报告
实验2链表基本操作实验一、实验目的1. 定义单链表的结点类型。
2. 熟悉对单链表的一些基本操作和具体的函数定义。
3. 通过单链表的定义掌握线性表的链式存储结构的特点。
二、实验内容与要求该程序的功能是实现单链表的定义和主要操作。
女口:单链表建立、输出、插入、删除、查找等操作。
该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。
程序中的单链表(带头结点)结点为结构类型,结点值为整型。
要求:同学们可参考指导书实验2程序、教材算法及其他资料编程实现单链表相关操作。
必须包括单链表创建、输出、插入、删除操作,其他操作根据个人情况增减。
三、算法分析与设计。
1•创建单链表:头结点LA1 A2An A2.单链表插入void LinkedListlnsert(LinkedList L,int i,ElemType x) 链表插入函数(L头指针,i插入位置,x插入兀素)LinkedList p,s;疋义结构体类型指针p,sj=1;p=L;疋义整型j计数,寻找插入位置,p指针指向头结点p=p->next;j++; 满足条件时p指针后移,j自加1while(p&&j<i) 当p为真且j<i时循环j 〜____ p=NULL||j<i一一printf("插入位置不正确\n");s=(LNode *)malloc(sizeof(LNode));使用malloc函数动态分配存储空间,指针s指向新开辟的结点,并将插入元素x存放到新开辟结点s的数据域,将结点s指向i+1 结点位置,第i个结点指向s,实现了链表元素插入。
by1s->data=x; s->n ext=p->n ext; p->n ext=s;3.单链表的删除:p->n ext=p->n ext- >n ext;15 x=表 -俞弹i tl 度 書翁的琴素汕6.从链表中查找元素四、运行结果1.单链表初始化骨选择夷进行的操作、遍历链表 J 从链表中査找元素1.如程輕巴章兰与竽疋匹菇值里同門元素在顺序aw 位置 迥链五Fs 已元壽上也库吏卬删除更10^5^性表 毒他键退出。
单链表的基本操作实验问题与对策
【单链表的基本操作实验问题与对策】01. 简介在计算机科学领域,数据结构是学习和理解的重要基础,而单链表作为其中的一种基本数据结构,在学习过程中通常需要进行一些操作实验。
然而,很多学生在进行单链表的基本操作实验时会遇到一些问题,本文将对这些问题进行全面评估,并提出对策,帮助读者更好地理解和掌握单链表的基本操作。
02. 常见问题在进行单链表的基本操作实验时,学生常常会遇到以下一些问题:- 对单链表的基本概念理解不深:学生可能对单链表的定义、结构和操作方法理解不够透彻,导致在实验中无法正确编写相关代码。
- 插入、删除和查找操作的实现困难:学生在实验中往往会遇到关于单链表插入、删除和查找等操作的实现困难,无法正确理解和编写相关算法。
03. 对策建议针对上述问题,本文提出以下对策建议:- 加强基础知识的学习:在进行单链表操作实验之前,学生首先应加强对单链表的基本概念的学习,包括单链表的定义、结构、操作方法等,以确保对单链表有一个清晰透彻的理解。
- 多实践、多编程:学生在进行实验的过程中,应多进行实践操作,多编写单链表操作的相关代码,熟练掌握插入、删除和查找等操作的实现方法,加深对单链表操作的理解和掌握。
- 多思考、多讨论:在实验中,学生还应不断思考和讨论单链表操作的相关问题,尝试寻找不同的解决方法和思路,加深对单链表操作问题的理解和掌握。
04. 个人观点和理解对于单链表的基本操作问题,我个人认为加强基础知识的学习是至关重要的,只有对单链表的基本概念有一个清晰透彻的理解,才能更好地解决在实验中遇到的各类问题。
多实践、多编程也是非常重要的,只有通过不断的实践操作和编写代码,才能更好地掌握单链表的基本操作,提高解决问题的能力和水平。
总结通过对单链表的基本操作实验问题的全面评估,并提出对策建议,希望能帮助学生更好地理解和掌握单链表的基本操作,提高实验的效果和水平。
至此,我们共享了解单链表的基本操作实验问题和对策建议,希望对您有所帮助。
单链表基本操作总结
单链表基本操作总结链表,⼀种线性表,但并不会按线性的顺序存储数据。
⽽是在每⼀个节点⾥存到下⼀个节点的指针(Pointer)。
由于不必须按顺序存储,链表在插⼊的时候可以达到O(1)的复杂度,⽐另⼀种线性表顺序表快得多,但是查找⼀个节点或者访问特定编号的节点则需要O(n)的时间,⽽顺序表相应的时间复杂度分别是O(logn)和O(1)。
单链表结点类型描述typedef struct LinkList{ElemType data; //数据域struct Node *next; //指针域}Node, *LinkList;初始化LinkList initList(){LinkList L = (LinkList)malloc(sizeof(Node));L->next = NULL;return L;}头插法LinkList List_headInsert(LinkList L){Node *s;int x;printf("input the Node number:\n");scanf("%d",&x);while(x!=9999) //输⼊9999时结束{s = (Node*)malloc(sizeof(Node));s->data = x;s->next = L->next;L->next = s;scanf("%d",&x);}return L;}尾插法LinkList List_TailInsert(LinkList L){int x;Node *s;Node *r = L;printf("input the Node number:\n");scanf("%d",&x);while(x!=9999){s = (Node*)malloc(sizeof(Node));s->data = x;r->next = s;r = s; //指向新的表尾结点scanf("%d",&x);}r->next = NULL;return L;}查找//按序号查找结点值,取出链表L中第i个位置结点Node *GetElem(LinkList L,int i){int num = 1;Node *p = L->next;if(i==0)return L;if(i<1)return NULL;while(p && num<i){p = p->next;num++;}return p;}//按值查找结点Node *LocateElem(LinkList L,ElemType e){Node *p = L->next;while(p!=NULL && p-data!=e){p = p->next;}return p;}插⼊将值为e的新结点插⼊到单链表的第i个位置LinkList NodeInsert(LinkList L,int i,ElemType e){Node *p = L;int num = 0;Node *s = (Node*)malloc(sizeof(Node));//这⾥也可以直接调⽤前⾯的GetElem函数//p = GetElem(L,i-1);while(p && num<i-1){p = p->next;num++;}s->data = e;s->next = p->next;p->next = s;return L;}删除将某个给定的结点删除,按照序号删除,或者按照值删除,下⾯实现按序号删除LinkList NodeDelete(LinkList L,i){Node *p;Node *q;p = GetElem(L,i-1);q = p->next;p->next = p->next->next;free(q);return L;}求表长int ListLength(LinkList L){Node *p = L->next;int i = 0;while(p){i++;p = p->next;}return i;}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验二单链表基本操作一实验目的1.学会定义单链表的结点类型,实现对单链表的一些基本操作和具体的函数定义,了解并掌握单链表的类定义以及成员函数的定义与调用。
2.掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。
二实验要求1.预习C语言中结构体的定义与基本操作方法。
2.对单链表的每个基本操作用单独的函数实现。
3.编写完整程序完成下面的实验内容并上机运行。
4.整理并上交实验报告。
三实验内容1.编写程序完成单链表的下列基本操作:(1)初始化单链表La。
(2)在La中第i个元素之前插入一个新结点。
(3)删除La中的第i个元素结点。
(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所指的结点之后。
3.构造一个单链表L,其头结点指针为head,编写程序实现将L逆置。
(即最后一个结点变成第一个结点,原来倒数第二个结点变成第二个结点,如此等等。
)四思考与提高1.如果上面实验内容2中合并的表内不允许有重复的数据该如何操作?2.如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb,Lc,使得Lb中只含La表中奇数结点,Lc中含有La表的偶数结点?1.编写程序完成单链表的下列基本操作:(1)初始化单链表La。
(2)在La中第i个元素之前插入一个新结点。
(3)删除La中的第i个元素结点。
(4)在La中查找某结点并返回其位置。
(5)打印输出La中的结点元素值。
#include<stdio.h>#include<stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0typedef int Status;typedef int ElemType;//定义存储结构typedef struct Lnode{int data; /*每个元素数据信息*/struct Lnode *next; /*存放后继元素的地址*/} LNode,*LinkList;int main(){void Create_L(LinkList &L,int n);void Print_L(LinkList L);Status ListInsert_L(LinkList &L,int i,ElemType e);Status ListDelete_L(LinkList &L,int i,ElemType &e);Status Find_L(LinkList L,int e);LinkList La;//创建单链表Laint n;printf("请输入链表La中的元素个数:\n");scanf("%d",&n);Create_L(La,n);//初始化单链表printf("现在La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备插入元素,请输入插入位置及所插入元素的值\n");int i,e;scanf("%d %d",&i,&e);ListInsert_L(La,i,e);printf("插入后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备删除元素,请输入删除位置\n");scanf("%d",&i);ListDelete_L(La,i,e);printf("删除后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("请输入所要查找元素的值:\n");scanf("%d",&e);Find_L(La,e);printf("所要查找元素的位置为:%d\n",Find_L(La,e)); }void Create_L(LinkList &L,int n){int j=1;L=(LinkList)malloc(sizeof(Lnode));L->next =NULL;//先建立一个带头结点的单链线性表L for(int i=n;i>0;--i){LinkList p=(LinkList)malloc(sizeof(Lnode));printf("请输入链表La中的第%d个元素:\n",j++);scanf("%d",&p->data);p->next=L->next;L->next =p;}//(逆序实现)/*LinkList q=L;for(int i=1;i<=n;i++){LinkList p=(LinkList)malloc (sizeof(Lnode));q->next=p;p->next=NULL;q=q->next ;printf("请输入链表La中的第%d个元素:\n",i);scanf("%d",&p->data);}//(正序实现)*/}//初始化单链表//输出单链表void Print_L(LinkList L){LinkList p;p=L->next;while(p){printf("%d ",p->data );p=p->next;}printf("\n");}//在单链表L的第i个位置前插入元素eStatus ListInsert_L(LinkList &L,int i,ElemType e) {LinkList p=L;int j=0;while(p&&j<i-1){p=p->next; ++j;}if(!p||j>i-1) return ERROR;LinkList s=(LinkList)malloc(sizeof(LNode));s->data=e; s->next=p->next;p->next=s;return OK;} //ListInsert_L//删除单链表L中第i个位置上的元素Status ListDelete_L(LinkList &L,int i,ElemType &e) {LinkList p=L;int j=0;while( p->next && j<i-1){p=p->next; ++j;}if(!p->next||j>i-1) return ERROR;LinkList q=p->next; p->next=q->next;e=q->data;free(q);return OK;}//LinkDelete_L/*查找元素并返回位置*/Status Find_L(LinkList L,int e){LinkList p=L->next;int j=1;while(p->data!=e&&p->next){p=p->next;j++;}if(p->data==e) return j;else{printf("无当前元素\n");return ERROR;}if(!p){printf("无当前元素\n");return ERROR;}}//定位2 .构造两个带有表头结点的有序单链表La、Lb,编写程序实现将La、Lb合并成一个有序单链表Lc。
合并思想是:程序需要3个指针:pa、pb、pc,其中pa,pb分别指向La表与Lb表中当前待比较插入的结点,pc 指向Lc表中当前最后一个结点。
依次扫描La和Lb中的元素,比较当前元素的值,将较小者链接到*pc之后,如此重复直到La或Lb结束为止,再将另一个链表余下的内容链接到pc所指的结点之后。
#include<stdio.h>#include<stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0typedef int Status;typedef int ElemType;//定义存储结构typedef struct Lnode{int data; /*每个元素数据信息*/struct Lnode *next; /*存放后继元素的地址*/} LNode,*LinkList;void main(){void Create_L(LinkList &L,int n);void Print_L(LinkList L);void MergeList_L(LinkList &La, LinkList &Lb,LinkList &Lc);LinkList La,Lb,Lc;//创建单链表La,Lb,Lcint n;printf("请输入链表La中的元素个数:\n");scanf("%d",&n);Create_L(La,n);//初始化单链表printf("现在La中的元素为:\n");Print_L(La);printf("请输入链表Lb中的元素个数:\n");scanf("%d",&n);Create_L(Lb,n);//初始化单链表printf("现在Lb中的元素为:\n");Print_L(Lb);Create_L(Lc,0);printf("-------------------------------------\n\n");printf("开始合并:\n");MergeList_L(La, Lb,Lc);printf("-------------------------------------\n\n");printf("合并后,Lc的元素为\n");Print_L(Lc);}void Create_L(LinkList &L,int n){int j=1;L=(LinkList)malloc(sizeof(Lnode));L->next =NULL;//先建立一个带头结点的单链线性表L for(int i=n;i>0;--i){LinkList p=(LinkList)malloc(sizeof(Lnode));printf("请输入链表中的第%d个元素:\n",j++);scanf("%d",&p->data);p->next=L->next;L->next =p;}//(逆序实现)/*LinkList q=L;for(int i=1;i<=n;i++){LinkList p=(LinkList)malloc (sizeof(Lnode));q->next=p;p->next=NULL;q=q->next ;printf("请输入链表La中的第%d个元素:\n",i);scanf("%d",&p->data);}//(正序实现)*/}//初始化单链表//有序单链表La和Lb的归并void MergeList_L(LinkList &La, LinkList &Lb,LinkList &Lc) {LinkList pa=La->next;LinkList pb=Lb->next;LinkList pc;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);printf("ppppppppppppppp");}//MergeList//输出单链表void Print_L(LinkList L){LinkList p;p=L->next;while(p){printf("%d ",p->data );p=p->next;}printf("\n");}3.构造一个单链表L,其头结点指针为head,编写程序实现将L逆置。