单链表类实现
汇编语言 链表结构
汇编语言链表结构全文共四篇示例,供读者参考第一篇示例:汇编语言是一种底层编程语言,用于直接操作计算机硬件。
在汇编语言中,链表结构是一种常见的数据结构,用于存储和组织数据。
链表可以灵活地添加或删除元素,并且可以在任意位置访问元素,使其在编程中具有重要作用。
本文将介绍汇编语言中链表结构的实现及其运用。
在汇编语言中,链表通常由节点构成。
每个节点包含两部分:数据部分和指针部分。
数据部分用于存储实际数据,而指针部分用于指向下一个节点。
通过不断跟随指针,可以在链表中遍历所有节点。
链表的头节点通常用一个特殊的指针来表示,称为头指针。
在汇编语言中,创建链表时需要定义节点的结构。
以下是一个简单的示例:```assemblynode STRUCTdata DWORD ?next DWORD ?node ENDS```上面的代码定义了一个节点结构体,包含一个数据部分和一个指向下一个节点的指针。
在实际编程中,可以根据需要定义更复杂的节点结构。
创建链表时,首先需要初始化头指针为空。
然后逐个添加节点到链表中。
以下是一个示例代码:```assembly; 初始化链表mov DWORD PTR head, 0; 添加第一个节点push 1call addNodeaddNode PROC; 申请内存空间用于新节点pushadmov edx, 8call mallocmov esi, eaxpopad; 将数据部分赋值mov DWORD PTR [esi], eax; 将指针部分赋值mov DWORD PTR [esi + 4], DWORD PTR head; 将新节点设置为头节点mov DWORD PTR head, esiretaddNode ENDP```上面的示例代码演示了如何创建一个简单的链表并向其中添加节点。
在addNode过程中,首先申请内存空间用于新节点,然后将数据部分和指针部分填充,并将新节点设置为头节点。
通过调用addNode 过程,可以逐个向链表中添加节点。
C++链表类的实现(面向对象的思想)
//节点的指针复位 pNode = g_World.getObjectLink().m_pHead;
//遍历链表(删除节点) while(pNode != NULL)
{ if(pNode->m_pObject->IsDead()) { //删除节点 g_World.getObjectLink().DeleteNode(pNode->m_pObject); cout<<"删除节点成功"<<endl; count --; break; } pNode = pNode->pNext;
2:删除节点
//
3:插入节点
//程序说明:Class Object,World,LinkObject
//
Object:是节点的数据域的数据
//
World: 用于返回链表对象
//
LinkObject:链表类,提供了对链表操作的基本方法
//代码行数:300
//作者:CreateDBW 时间:2012 年 12 月 10 日
count ++; if(count == flag) {
//为新增的节点分配内存 Node *pInsertNode = new Node(pObj); //新增节点的后一个节点的地址(pNode->pNext) //存储在新增节点(pInsertNode)的 pNext 中. pInsertNode->pNext = pNode->pNext; //把新增节点的地址 pInsertNode 存储到 pNode->pNext //中 pNode->pNext = pInsertNode; return ; } pNode = pNode->pNext; } //如果要插入的节点是在最后就用下面的函数 AddNode(pObj); } LinkObject::~LinkObject() {
实验一 线性表的基本操作实现及其应用
实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现。
2、会用线性链表解决简单的实际问题。
二、实验内容题目一、该程序的功能是实现单链表的定义和操作。
该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。
其中,程序中的单链表(带头结点)结点为结构类型,结点值为整型。
单链表操作的选择以菜单形式出现,如下所示:please input the operation:1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满6.遍历链表(设为输出元素)7.从链表中查找元素8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。
其中黑体部分必做题目二、约瑟夫环问题:设编号为1,2,3,……,n的n(n>0)个人按顺时针方向围坐一圈,每个人持有一个正整数密码。
开始时任选一个正整数做为报数上限m,从第一个人开始顺时针方向自1起顺序报数,报到m时停止报数,报m的人出列,将他的密码作为新的m值,从他的下一个人开始重新从1报数。
如此下去,直到所有人全部出列为止。
令n最大值取30。
要求设计一个程序模拟此过程,求出出列编号序列。
struct node(一)1.进入选择界面后,先选择7,进行插入:2.选择4,进行遍历,结果为:3.选择2,得出当前链表长度.4.选择3,得出当前链表为.5.选择分别选择5、6进行测试.6.选择8,分别按位置和元素值删除.7.选择9,或非1-8的字符,程序结束.(二) 实验总结通过这次实验,我对线性链表有了更深的理解,深入明白了线性存储结构与链式存储结构在内存存储的不同特点,同时我还学会了用这些知识实际解决一些问题,能够更加熟练地将算法转化为实际程序。
同时,在写程序和调试程序的过程中,学会了一些书写技巧和调试技巧,这对于自己能在短时间高效的写出正确地程序有很大作用。
四、主要算法流程图及程序清单 1. 主要算法流程图:(1) 从单链表表中查找与给定元素值相同的元素在链表中的位置p=p->nextp&&!(p->data==xtrue调用函数,传入参数L ,xp=L->next2.程序清单:#include<iostream> using namespace std; #include<>#include<>/* 预处理命令 */#define OK 1;#define ERROR 0;#define OVERFLOW -1;/* 单链表的结点类型 */typedef struct LNode{int data;struct LNode *next;}LNode,*LinkedList;/*初始化单链表*/LinkedList LinkedListInit(){空"<<endl;cout<<"\t\t\t"<<"2.求链表长度"<<endl;cout<<"\t\t\t"<<"3.检查链表是否为空"<<endl;cout<<"\t\t\t"<<"4.遍历链表"<<endl;cout<<"\t\t\t"<<"5.从链表中查找元素 "<<endl;cout<<"\t\t\t"<<"6.从链表中查找与给定元素值相同的元素在表中的位置"<<endl;cout<<"\t\t\t"<<"7.向链表中插入元素"<<endl;cout<<"\t\t\t"<<"8.从链表中删除元素"<<endl;cout<<"\t\t\t"<<"9.退出"<<endl;}/*主函数*/int main(){链表长度case 2:{cout<<"\t\t\t链表长度为:"<<LinkedListLength(L)<<endl;getch();}break;查链表是否为空case 3:{if (!LinkedListEmpty(L)){cout<<"\t\t\t链表不为空!"<<endl;}else{cout<<"\t\t\t链表为空!"<<endl;}getch();}break;历链表case 4:{LinkedListTraverse(L);getch();}break;链表中查找元素case 5:{cout<<"\t\t\t请输入要查询的位置i:";int j;cin>>j;if (LinkedListGet(L,j)){cout<<"\t\t\t位置i的元素值为:"<<LinkedListGet(L,j)->data<<endl;}else{cout<<"\t\t\ti大于链表长度!"<<endl;}getch();}break;链表中查找与给定元素值相同的元素在表中的位置case 6:{cout<<"\t\t\t请输入要查找的元素值:";int b;cin>>b;if (LinkedListGet1(L,b)){cout<<"\t\t\t要查找的元素值位置为:"<<LinkedListGet1(L,b)<<endl;cout<<"\t\t\t要查找的元素值内存地址为:"<<LinkedListLocate(L,b)<<endl;}else{cout<<"\t\t\t该值不存在!"<<endl;}getch();}break;链表中插入元素case 7:{cout<<"\t\t\t请输入要插入的值:";int x; cin>>x;cout<<"\t\t\t请输入要插入的位置:";int k; cin>>k;if(LinkedListInsert(L,k,x)){cout<<"\t\t\t插入成功!"<<endl;}else{cout<<"\t\t\t插入失败!"<<endl;}getch();}break;链表中删除元素case 8:{cout<<"\t\t\t1.按位置删除"<<endl;cout<<"\t\t\t2.按元素删除"<<endl;int d;cout<<"\t\t请选择:";cin>>d;switch(d){case 1:{cout<<"\t\t\t请输入删除位置:";cin>>d;int y;if (LinkedListDel(L,d,y)){cout<<"\t\t\t"<<y<<"被删除!"<<endl;}else{cout<<"\t\t\t删除失败!"<<endl;}}break;case 2:{cout<<"\t\t\t请输入删除元素:";int y;cin>>y;if (LinkedListDel(L,y)){cout<<"\t\t\t"<<y<<"被删除!"<<endl;}else{cout<<"\t\t\t删除失败!"<<endl;}}}getch();}break;}}return 1;}题二约瑟夫环问题算法、思想为了解决这一问题,可以先定义一个长度为30(人数)的数组作为线性存储结构,并把该数组看成是一个首尾相接的环形结构,那么每次报m的人,就要在该数组的相应位置做一个删除标记,该单元以后就不再作为计数单元。
单链表头插法代码
单链表头插法代码单链表是一种常见的数据结构,它由多个节点组成,每个节点包括两部分:一个数据存储区和一个指向下一个节点的指针。
插入操作是单链表的基本操作之一,在插入一个节点时,可以采用两种方法:头插法和尾插法。
在本篇文章中,我们将重点讲解单链表的头插法。
头插法是指在单链表的头节点之前插入一个新节点。
这种方法需要先创建一个新节点,并将其指针指向原头节点所指向的节点。
然后再将头节点的指针指向新节点。
相当于是在链表的头部插入新节点。
下面是头插法的代码实现:```struct node {int data;struct node *next;};void insert_node(struct node **head, int value) {struct node *new_node = (struct node*)malloc(sizeof(struct node));new_node->data = value;new_node->next = *head;*head = new_node;}```在上面的代码中,我们首先定义了一个节点结构体node,其中包含一个int类型的数据成员data和一个指向下一个节点的指针成员next。
然后,我们定义一个函数insert_node,这个函数的作用是向单链表中插入新的节点。
其中,head是指向链表头节点的指针,value 是要插入的节点的值。
在insert_node函数体中,我们首先通过malloc函数动态分配内存,创建一个新节点new_node。
然后,将新节点的data成员赋值为value,将新节点的next指针指向原head指针所指向的节点,最后将head指针指向新节点new_node。
这样,新节点就插入到链表的头部了。
总结一下,头插法是单链表中比较常用的一种插入节点的方式,通过这种方法,可以很方便地在链表头部插入新节点。
在实现的过程中需要注意,在创建新节点时要手动分配内存,否则会发生内存错误。
基于单链表实现集合的交集、并集、差集的运算
基于单链表实现集合的交集、并集、差集的运算解题思路(单链表求交集、并集、差集的思想和顺序表求交集、并集、差集的思想基本相同)1.先通过CreateListR 函数将集合 a 和 b 中的元素添加到顺序表 ha 和 hb 中,添加过程使⽤的是顺序表原有的Initlist 函数(初始化表)和ListInsert 函数(向表中插⼊元素)。
2.因为原集合是⽆序的,所以我通过 sort 函数(选择排序),使得集合变得有序。
3.得到有序集合 ha 和 hb 后,便可以使⽤ Union 函数(类似归并的思想写出来的求并集的函数),求出 ha 和 hb 的并集。
4.⽽求交集的⽅法则是,通过将集合 a 中的元素⼀个⼀个取出,并通过函数LocateElem ,查看集合 hb 中是否存在该元素,如果存在则将元素放⼊ hc ,如果不存在,则舍去。
以此求得两集合的交集。
5.求两集合的差则可以反过来,同样通过将集合 a 中的元素⼀个⼀个取出,并通过函数LocateElem ,查看集合 hb 中是否存在该元素,如果不存在则将元素放⼊ hc ,如果存在,则舍去。
以此求得两集合的差集。
#include <iostream>#include <cstdio>#include <malloc.h>using namespace std;/* 定义单链表数据 */typedef char ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LinkList;/* 单链表的初始化 */void InitList(LinkList *&L){L = (LinkList *)malloc(sizeof(LinkList));L->next=NULL;}/* 向单链表中插⼊数据元素 */bool ListInsert(LinkList *&L,int x,char e){int j = 0;LinkList *p = L, *s;while(p!=NULL && j<x-1){p = p->next;j++;}if(p==NULL){return false;}else{s = (LinkList *)malloc(sizeof(LinkList));s->data = e;s->next = p->next;p->next = s;return true;}}/* 输出单链表 */void DispList(LinkList *L){LinkList *p = L->next;while(p!=NULL){printf("%c ",p->data);p = p->next;}printf("\n");}/* 求单链表的长度 */int ListLength(LinkList *L){LinkList *p = L->next;int i = 0;while(p!=NULL){p = p->next;}return i;}/* 查看单链表是否为空 */bool ListEmpty(LinkList *L){return L->next==NULL;}/* 求单链表中某个数据元素值 */bool GetElem(LinkList *L,int i, ElemType &e) {LinkList *p = L;int j = 0;while(p!=NULL && j < i){p=p->next;j++;}if(p==NULL){return false;}else{e = p->data;return true;}}/* 在单链表中查找元素 */int LocateElem(LinkList *L,ElemType e){LinkList *p = L;int i = 0;while(p!=NULL && p->data!=e){p = p->next;i++;}if(p==NULL){return0;}else{return i;}}/* 删除单链表中第 i 个元素*/bool ListDelete(LinkList *&L,int i,ElemType &e) {int j = 0;LinkList *p = L, *q;while(p!=NULL && j < i - 1){p = p->next;j++;}if(p==NULL)return false;else{q = p->next;if(q==NULL)return false;e = q->data;p->next = q->next;free(q);return true;}}/* 删除单链表 */void DestroyList(LinkList *&L){LinkList *p = L;LinkList *q = p->next;while(q!=NULL){p = q;q = p->next;}free(p);}void CreateListR(LinkList *&L,ElemType e[],int n) {InitList(L);int i;for(i = 0;i < n; ++i){if(!LocateElem(L,e[i]))ListInsert(L,i+1,e[i]);}}void InsterSect(LinkList *a,LinkList *b,LinkList *&c) {DestroyList(c);InitList(c);LinkList *p = a->next;int i = 0;while(p!=NULL){if(LocateElem(b,p->data))ListInsert(c,++i,p->data);p = p->next;}}void Subs(LinkList *a,LinkList *b,LinkList *&c){DestroyList(c);InitList(c);LinkList *p = a->next;int i = 0;while(p!=NULL){if(!LocateElem(b,p->data))ListInsert(c,++i,p->data);p = p->next;}}void Union(LinkList *a,LinkList *b,LinkList *&c){InitList(c);LinkList *p = a->next;LinkList *q = b->next;int k = 0;while(p!=NULL && q!=NULL){if(p->data < q->data){ListInsert(c,k+1,p->data);p = p->next;k++;}else if(p->data == q->data){ListInsert(c,k+1,p->data);p = p->next;q = q->next;k++;}else{ListInsert(c,k+1,q->data);q = q->next;k++;}}while(p!=NULL){ListInsert(c,k+1,p->data);p = p->next;k++;}while(q!=NULL){ListInsert(c,k+1,q->data);q = q->next;}///cout<<"hehe"<<endl;}void sort(LinkList *&L){LinkList *p , *pre, *q, *k;InitList(p);int i = 0;char c;while(!ListEmpty(L)){pre = L ->next;c = pre->data;while(pre!=NULL){if(c>=pre->data)c = pre->data;pre = pre->next;}ListInsert(p,++i,c);int tag = LocateElem(L,c);ListDelete(L,tag,c);}L = p;}int main( ){LinkList *ha, *hb, *hc;ElemType a[]={'c','a','e','h'};ElemType b[]={'f','h','b','g','d','a'};printf("集合的运算如下\n");CreateListR(ha,a,4);CreateListR(hb,b,6);printf("原集合 A: "); DispList(ha); printf("原集合 B: "); DispList(hb); sort(ha);sort(hb);printf("有序集合A:"); DispList(ha); printf("有序集合B:"); DispList(hb); Union(ha,hb,hc);printf("集合的并C:"); DispList(hc); InsterSect(ha,hb,hc);printf("集合的交C:"); DispList(hc); Subs(ha,hb,hc);printf("集合的差C:"); DispList(hc); DestroyList(ha);DestroyList(hb);DestroyList(hc);return0;}。
数据结构实验报告实现单链表各种基本运算的算法
实验截图(1)void InitList(LinkNode *&L)//初始化线性表{L=(LinkNode *)malloc(sizeof(LinkNode)); //创建头结点L->next=NULL;//单链表置为空表}void DestroyList(LinkNode *&L)//销毁线性表{LinkNode *pre=L,*p=pre->next;实验截图(2)bool GetElem(LinkNode *L,int i,ElemType &e) //求线性表中第i个元素值{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L;//p指向头结点,j置为0(即头结点的序号为0) while (j<i && p!=NULL)//找第i个结点p{ j++;p=p->next;}if (p==NULL)//存在值为e的结点,返回其逻辑序号ireturn(i);}实验截图(3)bool ListInsert(LinkNode *&L,int i,ElemType e) //插入第i个元素{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L,*s;//p指向头结点,j置为0(即头结点的序号为0) while (j<i-1 && p!=NULL)//查找第i-1个结点p{ j++;p=p->next;}}实验截图(4)编写exp2-2.cpp程序包含有关代码//文件名:exp2-2.cpp#include "linklist.cpp"int main(){LinkNode *h;ElemType e;printf("单链表的基本运算如下:\n");printf(" (1)初始化单链表h\n");InitList(h);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");return 1;}实验截图(5)运行得到结果实验截图(6)。
面向对象课程设计题目汇总及要求
面向对象程序设计课程设计题目汇总选题说明及要求说明:1、由于各选题的难度不同,将选题分为A、B、C三个等级,每个等级对应的最高分依次为:100分、85分和75分。
达到基本要求且有一定程度和创新和见解的同学可获得较高分数。
学生可根据自己的情况,自行选择。
2、每个题目最多只能有两组,若超过两组,则该题目自动作废!3、规定2-4人的题目,若实际人数比分组人数每少一人,则题目等级自动上调一级。
4、若实际小组人数比规定人数多一人,则题目等级自动下调一级。
实际人数比规定人数多两个的分组无效!题目列表题目一、单链表(1人)(C级) (3)题目二:一元多项式求和(1人)(B级) (3)题目三:快餐店点餐系统(3人)(B级) (3)题目四、简单车辆管理系统(3人)(B级) (4)题目五、滚动发车系统设计(3人)(B级) (4)题目六、简单银行账户系统(3人)(A级) (5)题目七、银行叫号系统设计(3人)(B级) (5)题目八、学生学籍管理系统(3人)(B级) (6)题目九、教师工资信息管理系统(3人)(A级) (6)题目十、书刊租借信息管理系统(3人)(A级) (7)题目十一、仓库管理信息系统(3人)(B级) (7)题目十二、研究生管理信息系统(3人)(B级) (8)题目十三、图书馆管理信息系统(3人)(B级) (8)题目十四、学生宿舍管理信息系统(3人)(B级) (9)题目十五、理财管理信息系统(3人)(B级) (9)题目十六、IT设备资产管理系统(3人)(B级) (10)题目十七、员工管理信息系统(3人)(B级) (10)题目十八某软件公司客户关系(CRM)管理系统(4人)(A级).. 11 题目十九:足球联赛排名(3人)(A级) (11)题目二十:小学生四则运算测验(3人)(B级) (12)题目二十一:学生电子投票平台设计(3人)(B级) (12)题目二十二:物品库存管理系统(3人)(B级) (12)题目二十三:个人财政支出管理系统(2人)(C级) (13)题目二十四:电话簿管理系统(2人)(C级) (13)题目二十五:股票交易系统(4人)(A级) (13)题目二十六:学生信息管理系统(2人)(C级) (13)题目二十七:学生成绩管理系统(2人)(C级) (13)题目二十八:小型字符串类(2人)(B级) (14)题目二十九:分数计算器(2人)(B级) (14)题目二十九:复数计算器(1人)(C级) (14)题目三十:无符号大整数计算器(2人)(B级) (15)题目三十一:超市密码存储箱系统(2人)(A级) (15)题目一、单链表(1人)(C级)建立一个单链表类,该链表类能够实现以下功能:(1)有合理的构造函数,能够由用户输入数据,创建链表,如果用户输入的数据不合理,能够给出提示信息(2)能够实现单链表元素的遍历(3)能够在指定位置插入一个元素(4)能够删除指定位置的元素(5)能够统计单链表中的元素个数并输出题目二:一元多项式求和(1人)(B级)编写一个程序用单链表存储一元多项式,并实现以下功能:(1)能够运行用户合理输入两个的多项式(2)能够实现两个多项式相加(3)能够将相加的结果输出(4)能够对常见的错误进行正确的处理和输出题目三:快餐店点餐系统(3人)(B级)快餐店点餐系统一般具有高效、便捷的特点。
单链表求集合的并、交和差运算
单链表求集合的并、交和差运算单链表是一种常用的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
在计算机科学中,我们经常需要对集合进行操作,包括求并集、交集和差集。
在本文中,我们将介绍如何使用单链表来实现这些集合操作。
我们需要定义一个单链表的数据结构。
每个节点包含一个数据元素和一个指向下一个节点的指针。
我们可以使用类来实现这个数据结构,例如:```class Node:def __init__(self, data):self.data = dataself.next = Noneclass LinkedList:def __init__(self):self.head = None```接下来,我们需要实现集合的并、交和差运算。
首先是并运算,它将两个集合中的所有元素合并为一个新的集合。
我们可以使用两个指针分别遍历两个链表,将两个链表中的元素逐个比较,并将不重复的元素添加到结果链表中。
具体代码如下:```def union(l1, l2):result = LinkedList()p1 = l1.headp2 = l2.headwhile p1 is not None:result.append(p1.data)p1 = p1.nextwhile p2 is not None:if not result.contains(p2.data):result.append(p2.data)p2 = p2.nextreturn result```接下来是交运算,它将两个集合中共有的元素提取出来组成一个新的集合。
同样地,我们可以使用两个指针分别遍历两个链表,将相同的元素添加到结果链表中。
具体代码如下:```def intersection(l1, l2):result = LinkedList()p1 = l1.headwhile p1 is not None:if l2.contains(p1.data):result.append(p1.data)p1 = p1.nextreturn result```最后是差运算,它将第一个集合中不属于第二个集合的元素提取出来组成一个新的集合。
单链表数据结构
插入
if (p != NULL && j == i-1) { // 找到第i个结点
s = (LinkList) malloc ( sizeof (LNode)); // 生成新结点
s->data = e;
// 数据域赋值
s->next = p->next; //新结点指针指向后一结点
p->next = s; return OK;
6、销毁
4.6 销毁操作
while(L) { p = L->next; free(L); L=p;
// p指向第一结点(头节点为“哑结点”) // 释放首结点 // L指向p
}
// 销毁完成后,L为空(NULL)
算法的时间复杂度为:O(ListLength(L))
判空 求表长
4.7 其它操作
if(L->next==NULL) return TRUE; // 空
5、清空
4.5 清空操作
while (L->next) { p = L->next; L->next = p->next; free(p);
// p指向当前结点 // 头结点指向当前结点的后结点 // 释放当前结点内存
}
// 清空完成后,仍保留头结点L
算法的时间复杂度为:O(ListLength(L))
点。
5.1.2 逆序建立单链表
①建立一个带头结点的空单链表;
②输入数据元素ai,建立新结点p, 并把p插入在头结点之后成为第一个 结点。
③重复执行②步,直到完成单链表的 建立。
a1
a2 a1
创建出来的链表 点顺序与插入操作
顺序相反。
数据结构C语言版 线性表的单链表存储结构表示和实现
#include 〈stdio.h>#include <malloc。
h>#include 〈stdlib.h>/*数据结构C语言版线性表的单链表存储结构表示和实现P28—31编译环境:Dev-C++ 4。
9。
9。
2日期:2011年2月10日*/typedef int ElemType;// 线性表的单链表存储结构typedef struct LNode{ElemType data; //数据域struct LNode *next;//指针域}LNode, *LinkList;// typedef struct LNode *LinkList;// 另一种定义LinkList的方法// 构造一个空的线性表Lint InitList(LinkList *L){/*产生头结点L,并使L指向此头结点,头节点的数据域为空,不放数据的。
void *malloc(size_t)这里对返回值进行强制类型转换了,返回值是指向空类型的指针类型.*/(*L)= (LinkList)malloc(sizeof(struct LNode) );if( !(*L))exit(0);// 存储分配失败(*L)-〉next = NULL;// 指针域为空return 1;}// 销毁线性表L,将包括头结点在内的所有元素释放其存储空间。
int DestroyList(LinkList *L){LinkList q;// 由于单链表的每一个元素是单独分配的,所以要一个一个的进行释放while(*L ){q = (*L)—〉next;free(*L );//释放*L = q;}return 1;}/*将L重置为空表,即将链表中除头结点外的所有元素释放其存储空间,但是将头结点指针域置空,这和销毁有区别哦。
不改变L,所以不需要用指针。
*/int ClearList( LinkList L ){LinkList p,q;p = L—〉next;// p指向第一个结点while( p ) // 没到表尾则继续循环{q = p—>next;free( p );//释放空间p = q;}L—>next = NULL; // 头结点指针域为空,链表成了一个空表return 1;}// 若L为空表(根据头结点L—〉next来判断,为空则是空表),则返回1,// 否则返回0.int ListEmpty(LinkList L){if(L—>next ) // 非空return 0;elsereturn 1;}// 返回L中数据元素个数。
数据结构课件单链表
删除链表中的节点需要遍历至指定位置,时间复杂度为 O(n)。
查找节点
在链表中查找一个节点需要遍历整个链表,时间复杂度为 O(n)。
空间复杂度
空间占用
单链表的空间占用主要取决于链表中的 节点数,因此空间复杂度为O(n)。
VS
内存分配
每个节点需要分配内存空间存储数据和指 针,因此内存分配的空间复杂度也为O(n) 。
需要根据数据元素顺 序进行遍历的场景, 如排序算法等。
需要频繁插入、删除 操作的场景,如动态 规划、图算法等。
02
单链表的实现
创建单链表
定义节点结构体
首先需要定义一个节点结构体,包含 数据域和指针域两个部分,数据域用 于存储数据,指针域用于指向下一个 节点。
初始化头节点
创建一个头节点,并将其指针域指向 NULL,表示单链表的起始位置。
05
单链表常见问题与解决方 案
循环链表
总结词
循环链表是一种特殊类型的单链表,其中尾节点的指针指向头节点,形成一个闭环。
详细描述
在循环链表中,由于尾节点的指针指向头节点,因此遍历链表时需要特别注意,以避免无限循环。常见的解决方 法是在遍历时记录已经访问过的节点,避免重复访问。
链表中的重复元素
总结词
链表中可能存在重复元素的问题,这会影响数据处理的正确性。
详细描述
为了解决这个问题,可以在插入节点时检查新元素是否已存在于链表中。如果存在,则不进行插入操 作。另外,也可以使用哈希表等数据结构来快速查找重复元素。
链表的排序
总结词
对链表进行排序是常见的需求,但链表的排 序算法通常比数组的排序算法复杂。
合并单链表
总结词
将两个已排序的单链表合并为一个新的已排序的单链表。
数据结构-链表
链表一种数据结构的链接实现是指按链式存储方式构建其存储结构,并在此链式存储结构上实现其基本运算。
线性表的常见链式存储结构有单链表、循环链表和双链表,其中最简单的单链表。
本节讨论单链表的组织方法以及线性表的基本运算在单链表上的实现。
单链表示法的基本思想是用指针表示结点间的逻辑关系。
因此单链表的一个存储结点包含两个部分,结点形式如下:其中,data部分称为数据域,用于存储线性表的一个数据元素。
next部分称为指针域或链域,用于存放一个指针,该指针指向本结点所含数据元素的直接后继所在的结点。
从上述单链表中可以联想到我们生活中的火车,还有一种火车只有火车头。
假设数据元素的类型为Datatype。
单链表的类型定义如下:typedef struct node{Datatype data;struct node * next;} node,* LinkList;struct node表示链表的结点,一个结点是由两个域数据域data和指针域next组成的记录(每个域实际上相当于一个变量),而next本身又是一个pointer类型的指针型变量。
这个定义与上面给出的单链表的结点形式一致。
单链表的简单操作:1、初始化建立一个空表。
空表由一个头指针和一个头结点(该结点同时也是尾结点)组成。
LinkList Initiate_LinkList()/* 建立一空表 */{ LinkLis head;head= malloc(sizeof(node));head -> next = NULL;return head;}2、定位:按值查找。
按从前往后的顺序,依次比较单链表中各表结点数据域的值与给定值X,第一个值与X相等的表结点的序号就是结果。
若没有这样的结点,运算结果为0。
int Locate_LinkList(LinkList head,Datatype x){ Node *p;p = head; /* 置初值 */p=p->next;j = 0; /* 置初值 */while((p!= NULL)&&(p -> data != x)){ p = p -> next;j ++;} /* 未达尾结点又未找到等于x的结点时继续扫描 */if (p -> data == x)return(j+1);elsereturn(0);}3、插入:把新的结点x插入到i结点之前。
实验二 链表操作实现
实验二链表操作实现实验日期: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 -实验一:实现单链表各种基本运算的算法一、 实验目的1、 掌握单链表存储结构的类型定义;2、 实现单链表各种基本运算的算法。
二、 实验环境1、 Windows 操作系统;2、 Visual C++ 6.0三、 实验内容实现单链表各种基本运算的算法。
四、 概要设计1.存储结构的类型定义:Typedef struct LNode{ElemType data;Struct LNode *next;}LinkList;2.单链表示意图:3.项目组成图:4.algo2_2.cpp 的程序文件包含的函数原型及功能:InitList(LinkList *&L) 初始化单链表LDestroyList(LinkList *&L) 释放单链表LListEmpty(LinkList *L)判断单链表L 是否为空表ListLength(LinkList *L)返回单链表L 的元素个数DispList(LinkList *L)输出单链表LGetElem(LinkList *L,int i,ElemType &e)获取单链表L 的第i 个元素LocateElem(LinkList *L,ElemType e)在单链表L 中查找元素eListInsert(LinkList *&L,int i,ElemType e)在单链表L 中的第i 个位置上插入元素e…… head a 1 a 2 a 3 a n ∧ListDelete(LinkList *&L,int i,ElemType &e)在单链表L中删除第i个元素5.exp2_2.cpp程序文件简介:InitList(LinkList *&L) 初始化单链表LDestroyList(LinkList *&L) 释放单链表LListEmpty(LinkList *L) 判断单链表L是否为空表ListLength(LinkList *L) 返回单链表L的元素个数DispList(LinkList *L) 输出单链表LGetElem(LinkList *L,int i,ElemType &e) 获取单链表L的第i个元素LocateElem(LinkList *L,ElemType e) 在单链表L中查找元素eListInsert(LinkList *&L,int i,ElemType e) 在单链表L中的第i个位置上插入元素e ListDelete(LinkList *&L,int i,ElemType &e) 在单链表L中删除第i个元素6.proj2-2的项目的模块结构:在文件algo2-2中,(1)定义单链表结构类型;(2)初始化单链表(3)定义释放单链表的函数(4)定义判断单链表是否为空的函数(5)定义返回单链表元素个数的函数(6)定义输出单链表的函数(7)定义获取第i个元素的函数(8)定义查找元素的函数(9)定义插入元素的函数(10)定义删除元素的函数在文件exp2-2中分别调用algo2-2中所定义的函数7.函数调用关系图:五、详细设计源代码清单见附录。
数据结构c语言版课后习题答案
数据结构c语言版课后习题答案数据结构是计算机科学中的一个重要概念,它涉及到组织、管理和存储数据的方式,以便可以有效地访问和修改数据。
C语言是一种广泛使用的编程语言,它提供了丰富的数据结构实现方式。
对于学习数据结构的C语言版课程,课后习题是巩固理论知识和提高实践能力的重要手段。
数据结构C语言版课后习题答案1. 单链表的实现在C语言中,单链表是一种常见的线性数据结构。
它由一系列节点组成,每个节点包含数据部分和指向下一个节点的指针。
实现单链表的基本操作通常包括创建链表、插入节点、删除节点、遍历链表等。
答案:- 创建链表:定义一个链表结构体,然后使用动态内存分配为每个节点分配内存。
- 插入节点:根据插入位置,调整前后节点的指针,并将新节点插入到链表中。
- 删除节点:找到要删除的节点,调整其前后节点的指针,然后释放该节点的内存。
- 遍历链表:从头节点开始,使用指针遍历链表,直到达到链表尾部。
2. 二叉树的遍历二叉树是一种特殊的树形数据结构,其中每个节点最多有两个子节点。
二叉树的遍历是数据结构中的一个重要概念,常见的遍历方式有前序遍历、中序遍历、后序遍历和层序遍历。
答案:- 前序遍历:先访问根节点,然后递归遍历左子树,最后递归遍历右子树。
- 中序遍历:先递归遍历左子树,然后访问根节点,最后递归遍历右子树。
- 后序遍历:先递归遍历左子树,然后递归遍历右子树,最后访问根节点。
- 层序遍历:使用队列,按照从上到下,从左到右的顺序访问每个节点。
3. 哈希表的实现哈希表是一种通过哈希函数将键映射到表中一个位置来访问记录的数据结构。
它提供了快速的数据访问能力,但需要处理哈希冲突。
答案:- 哈希函数:设计一个哈希函数,将键映射到哈希表的索引。
- 哈希冲突:使用链地址法、开放地址法或双重哈希法等解决冲突。
- 插入操作:计算键的哈希值,将其插入到对应的哈希桶中。
- 删除操作:找到键对应的哈希桶,删除相应的键值对。
4. 图的表示和遍历图是一种复杂的非线性数据结构,由顶点(节点)和边组成。
数据结构c语言版单链表心得
数据结构c语言版单链表心得介绍在计算机科学中,数据结构是组织和存储数据的方式,目的是使数据可以高效地操作和访问。
而在C语言中,单链表是一种常见的数据结构,它由节点组成,每个节点包含数据和指向下一个节点的指针。
在本篇文章中,我将分享我对C语言版单链表的体会和心得。
什么是单链表单链表是一种线性数据结构,它由一系列节点组成。
每个节点包含两个部分:数据和指针。
数据部分用来存储具体的数据,而指针部分用来指向下一个节点。
通过使用指针,可以将各个节点连接起来,形成一个链表的结构。
单链表的设计与实现在C语言中,我们可以使用结构体来定义链表的节点类型。
每个节点包含一个数据域和一个指向下一个节点的指针域。
以下是单链表节点的定义:typedef struct Node {int data;struct Node* next;} Node;通过定义一个指向链表头节点的指针,我们可以操作链表。
以下是单链表的实现:#include <stdio.h>#include <stdlib.h>typedef struct Node {int data;struct Node* next;} Node;void insert(Node** head, int data) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->next = *head;*head = newNode;}void printList(Node* head) {Node* curr = head;while (curr != NULL) {printf("%d ", curr->data);curr = curr->next;}}int main() {Node* head = NULL;insert(&head, 1);insert(&head, 2);insert(&head, 3);insert(&head, 4);printList(head);return 0;}单链表的插入操作向单链表中插入节点是一种常见的操作。
数据结构实验报告 单链表基本操作
printf("查找不到该元素!\n");
printf("---------------------------------------------\n"); return 0; } 二: 1. 编写头文件及各个函数。这里函数有 CreateList_L() 创建函数,MergeList_L() 是排序函 2. 数。MergeList_L 函数不改变存储,只改变指针。PrintList_L() 用来打印结果。 写主函数。在主函数里输入元素个数,调用函数创建链表输入各个元素值。在调用函数
五、实验结果与讨论
一:
二:
-5-
六、总结
在查找元素的函数中如果按照下面的写法则会产生如下的结果:
于是必须改成 while(p&&(p->data!=e))
-6-
原因:先判断 p 是因为如果先判断 p->data 有可能此时 p 已指向空,p->data 没有值
七、思考与提高
1.如果上面实验内容 2 中合并的表内不允许有重复的数据该如何操作? 2.如何将一个带头结点的单链表 La 分解成两个同样结构的单链表 Lb,Lc, 使得 Lb 中只含 La 表中奇数结点,Lc 中含有 La 表的偶数结点?
-3-
排序,改变指针。输出。 3. 完整代码如下: #include<stdio.h> #include<stdlib.h> #define TRUE 1 #define FALSE 0 #define ERROR 0 #define OK 1 typedef int Status; typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*Linklist; Status CreateList_L(Linklist &L,int n) { Linklist p,q; int i=0; L=(Linklist)malloc(sizeof(LNode)); L->next=NULL; p=L; printf("请输入%d 个元素:\n",n); for(i=0;i<n;i++) { q=(Linklist)malloc(sizeof(LNode)); scanf("%d",&q->data); q->next=p->next; } return OK; } void MergeList_L(Linklist &La, Linklist &Lb, Linklist &Lc) { Linklist pa, pb, pc; pa = La->next; pb = Lb->next; while (pa && pb) { if(pa->data <= pb->data) { pc->next = pa; else { pc->next = pb; Lc = pc = La; p->next=q; p=q;
数据结构带头节点的单向链表.ppt
ListMerge
2、pa和pb分别指向La和Lb的第一个元素
La
a1
a2
a3
pa
Lb
b1
b2
pb
pa=La->next, pb=Lb->next;
ListMerge
3、如果pa和pb都不为空,则: 选择pa和pb所指结点中数据较小的 那个结点,
调整pa或者pb,使之指向下一个结点 if(pa->data<pb->data) { tmp=pa;pa=pa->next;} else {tmp=pb;pb=pb->next;}
node->next==node; }
插入Lc的表尾
ListMerge
if (!pa) tmp=pb; else
tmp=pa; while(tmp){
node=(LNode *)malloc(sizeof(LNode)); if(!node) return(OVERFLOW); node->data=tmp->data; node->next=NULL; pc->next=node; pc=node; tmp=tmp->next; }
L 链式存储的结构
顺序存储的结构
讨论
head length
链式存储的结构
typedef struct { LNode *head //头指针 int length//元素个数
} LinkList
讨论
Status InitList(LinkList &L){ L.length=0; L.head=(LNode *)malloc(sizeof(LNode)); if(!L.head) return(OVERFLOW); L.head->next=NULL; return(OK);
数据结构c语言版单链表心得
数据结构c语言版单链表心得单链表是一种常用的数据结构,它能够以链式的形式存储数据,可以动态的插入、删除等操作,非常适合于需要频繁操作数据的场景。
在C语言中,单链表的实现相对来说比较简单,但是需要掌握一些基本的指针操作技巧。
单链表的结构定义通常包含一个数据域和一个指向下一节点的指针域。
例如:```ctypedef struct Node {int data;struct Node* next;} Node;```这里我们定义了一个名为Node的结构体,其中包括一个int类型的数据域和一个指向下一个Node的指针域。
之所以要使用指针域,是因为链表不像数组那样在内存中连续存储,因此我们必须借助指针来建立节点之间的联系。
创建一个链表可以通过动态分配内存来实现,例如:```cNode* create_list() {Node* head = NULL; //头结点Node* tail = NULL; //尾结点int x;while (scanf("%d", &x) != EOF) { //读取数据直到文件末尾Node* node = (Node*)malloc(sizeof(Node)); //动态分配内存node->data = x;node->next = NULL;if (head == NULL) { //如果链表为空head = node; //头结点指向新节点}else {tail->next = node; //尾节点的指针域指向新节点}tail = node; //重置尾节点}return head;}```该函数通过使用malloc动态分配节点内存空间,然后读取数据并将其添加到链表中。
这里head和tail分别指向链表的头结点和尾结点,并且将尾结点的指针域指向新节点。
如果链表为空,则将头结点指向新节点。
遍历链表可以通过循环链表上的节点来实现,例如:```cvoid traverse_list(Node* head) {Node* node = head;while (node != NULL) { //循环链表printf("%d ", node->data);node = node->next; //指向下一个节点}}```该函数以head为参数,循环链表并输出每个节点的数据域。
使用循环单链表表示队列
使用循环单链表表示队列队列是一种常见的数据结构,它遵循先进先出(FIFO)的原则,即先进入队列的元素将先被取出。
队列通常用于需要按照顺序处理数据的场景,比如任务调度、消息传递等。
在实际应用中,我们可以使用循环单链表来表示队列。
循环单链表是一种链表结构,它与普通的单链表相比,最后一个节点的指针域不为空,而是指向链表的头结点。
这样一来,在遍历链表时可以很方便地回到链表的起始位置。
对于队列来说,使用循环单链表可以更高效地实现入队和出队的操作。
下面我们来具体讨论如何使用循环单链表来表示队列。
我们需要定义一个循环单链表节点的结构。
该结构包含一个数据域和一个指针域,分别指向下一个节点。
代码如下:```cppstruct Node {int data;Node* next;};```接下来,我们定义一个队列类,该类包含队列的基本操作,如入队、出队、判断队列是否为空等。
代码如下:```cppclass Queue {private:Node* front; // 队头指针Node* rear; // 队尾指针public:Queue() {front = rear = nullptr; // 初始化队头和队尾指针为空 }~Queue() {// 释放队列中的所有节点while (!isEmpty()) {dequeue();}}// 入队操作void enqueue(int value) {Node* newNode = new Node;newNode->data = value;newNode->next = nullptr;if (isEmpty()) {front = rear = newNode; // 队列为空,队头和队尾指针指向新节点} else {rear->next = newNode; // 将新节点链接到队尾rear = newNode; // 更新队尾指针}}// 出队操作void dequeue() {if (isEmpty()) {throw "Queue is empty!";}Node* temp = front;front = front->next; // 更新队头指针if (front == nullptr) {rear = nullptr; // 队列只有一个节点,出队后队尾指针为空}delete temp; // 释放出队节点的内存 }// 判断队列是否为空bool isEmpty() {return front == nullptr;}// 获取队头元素int getFront() {if (isEmpty()) {throw "Queue is empty!";}return front->data;}// 获取队列长度int getSize() {int size = 0;Node* current = front;while (current != nullptr) {size++;current = current->next;}return size;}};```使用循环单链表表示队列的好处是,入队和出队的时间复杂度都是O(1),即常数时间。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
线性表的链接存储结构——单链表的实现实验
1、实验的名称:用类来实现单链表
2、实验的功能:
(1)建立单链表;
(2)对已建立的单链表进行查找、插入、删除操作。
3、实验的代码:
#include<iostream.h>
class list //定义单链表的结构
{
public:
int num,score;
char sex[10],name[10];
class list *next;
void create();
void listout();
int seek(int n);
int insert(int n);
void dele(int n);
};
typedef class list node; //将class list重定义为node
typedef node *link; //声明指针
link p,s;
void list::create() //创建链表操作
{
s=new node; // 建立一个新的结点
cout<<"请输入学号、姓名、性别、成绩:";
cout<<endl;
cin>>s->num;
cin>>s->name;
cin>>s->sex;
cin>>s->score;
s->next=NULL;
p->next=s;
p=p->next; //工作指针p后移
}
void list::listout() //进行输出操作
{
while(p)
{
cout<<p->next<<" "<<p->num<<" "<<p->name<<" "<<p->sex<<" "<<p->score<<endl;
p=p->next;
}
}
int list::seek(int i) // 进行查找操作
int j=1;
while(p&&j<i)
{
p=p->next;
j++;
}
if(!p)
{
cout<<"查找无效!";
cout<<endl;
return 0;
}
else
{
cout<<p<<" "<<p->num<<" "<<p->name<<" "<<p->sex<<" "<<p->score;
return 1;
}
}
int list::insert(int i) //进行插入操作
{
int j=0;
while(p&&j<i-1)
{
p=p->next;
j++;
}
if(!p)
{
cout<<"插入无效!";
cout<<endl;
return 0;
}
else
{
link s;
s=new node;
cin>>s->num;
cin>>s->name;
cin>>s->sex;
cin>>s->score;
s->next=p->next;
p->next=s;
return 1;
}
void list::dele(int i) //进行删除操作{
int j=1;
while(p&&j<i-1)
{
p=p->next;
j++;
}
if(!p)
{
cout<<"删除无效!";
cout<<endl;
}
else
{
link q;
q=new node;
q=p->next;
p->next=q->next;
delete q;
}
}
void main()
{
list list1;
link first;
int x;
first=new node;
p=first;
cout<<"请输入学生信息条数:";
cin>>x;
for( int i=1;i<=x;i++)
{
cout<<"请输入第"<<i<<"条学生信息:";
cout<<endl;
list1.create();
}
cout<<"所输入的学生信息是:";
cout<<endl;
p=first->next;
list1.listout();
cout<<endl;
p=first->next;
cout<<"请输入查找的位置:";
cin>>i;
list1.seek(i);
cout<<endl;
p=first->next;
cout<<"请输入要插入的位置:";
cin>>i;
list1.insert(i);
p=first->next;
list1.listout();
p=first->next;
cout<<"请输入要删除的位置:";
cin>>i;
list1.dele(i);
p=first->next;
list1.listout();
}
4、实验的体会:
通过本次的单链表的实现实验,我更进一步地理解了单链表,对单链表的概念有了更准确的认识,此外,还懂得了顺序表和单链表之间的差别,知道应该在什么样的情况下采用哪种更合适。
在做实验过程中,我理解了,在单链表上实现插入和删除操作,不需要移动元素,在将工作指针指向合适的位置后,仅需修改结点之间的链接关系的指针。
做本次实验我还学会了仔细认真,对待编代码这项任务不能有任何马虎,同时,在我们学习软件当中要认真对待每一种课程,平时加强练习,只有通过大量的练习,反复地操作才能学好我们的专业,才能提高我们的专业技能。