链表基础操作(含菜单选择)

合集下载

实验一 线性表的基本操作实现及其应用

实验一 线性表的基本操作实现及其应用

实验一线性表的基本操作实现及其应用一、实验目的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的人,就要在该数组的相应位置做一个删除标记,该单元以后就不再作为计数单元。

单链表的基本操作

单链表的基本操作

10)调用头插法的函数,分别输入10,20,分别回车:
11)调用尾插法的函数,分别输入30,40
12)查找单链表的第四个元素:
13)主函数中传入参数,删除单链表的第一个结点:
14)主函数传入参数,删除第0个未位置的元素,程序报错:
15)最后,输出单链表中的元素:
return 0;
}
6)编译,连接,运行源代码:
7)输入8,回车,并输入8个数,用空格分隔开,根据输出信息,可以看出,链表已经拆分为两个
五、实验总结
1.单链表采用的是数据+指针的表示形式,指针域总是指向下一个结
点(结构体)的地址,因此,在内存中的地址空间可以是不连续的,操作比顺序存储更加的方便
2.单链表使用时,需要用malloc函数申请地址空间,最后,删除元
素时,使用free函数释放空间。

链表的各种插入法

链表的各种插入法

linklist createlistr1( ){ char ch; linklist head=(linklist)malloc(sizeof(listnode)); listnode *p,*r; , ; r=head; while((ch=getchar( ))!=‵\n′{ ‵ p=(listnode*)malloc(sizeof(listnode)); p–>data=ch; p–>next=p; r=p; } r–>next=NULL; return(head); }
如果我们在链表的开始结点之前附加一个结点, 如果我们在链表的开始结点之前附加一个结点,并称它 头结点,那么会带来以下两个优点: 为头结点,那么会带来以下两个优点: a、由于开始结点的位置被存放在头结点的指针域 中,所以在链表的第一个位置上的操作就和在表的其它 位置上的操作一致,无需进行特殊处理; 位置上的操作一致,无需进行特殊处理; b、无论链表是否为空,其头指针是指向头结点在 无论链表是否为空, 的非空指针(空表中头结点的指针域为空), ),因此空表 的非空指针(空表中头结点的指针域为空),因此空表 和非空表的处理也就统一了。 和非空表的处理也就统一了。
linklist creater( ) { char ch; linklist head; //(, *head;) , r=NULL; listnode *p,*r; , head=r( )!=‵\n′){ ‵ p=(listnode *)malloc(sizeof(listnode)); p–>data=ch; if(head=NULL) else r=p; } if (r!=NULL) return(head); } r–>next=NULL; r–>next=p; head=p;

数据结构-单链表基本操作实现(含全部代码)

数据结构-单链表基本操作实现(含全部代码)

数据结构-单链表基本操作实现(含全部代码)今天是单链表的实现,主要实现函数如下:InitList(LinkList &L) 参数:单链表L 功能:初始化时间复杂度 O(1)ListLength(LinkList L) 参数:单链表L 功能:获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数:单链表L,位置i,元素e 功能:位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数:单链表L,位置i 功能:删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域,然后删除后继结点。

最坏是O(n),即从头查找p之前的结点,然后删除p所指结点LocateElem(LinkList L,ElemType e) 参数:单链表L,元素e 功能:查找第⼀个等于e的元素,返回指针时间复杂度O(n)代码:/*Project: single linkeed list (数据结构单链表)Date: 2018/09/14Author: Frank YuInitList(LinkList &L) 参数:单链表L 功能:初始化时间复杂度 O(1)ListLength(LinkList L) 参数:单链表L 功能:获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数:单链表L,位置i,元素e 功能:位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数:单链表L,位置i 功能:删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域,然后删除后继结点。

c语言链表操作题

c语言链表操作题

c语言链表操作题C语言链表操作题一、问题描述假设有一个链表,每一个节点都包含一个整数,节点的结构体定义如下:```struct ListNode {int val;struct ListNode *next;};```请你完成以下链表操作函数:1. `struct ListNode* createList(int *arr, int size)`:传入一个整数数组和数组的长度,返回一个链表的头节点,链表的节点顺序和数组顺序一致。

2. `void displayList(struct ListNode *head)`:传入链表的头节点,打印链表中所有的节点值,用空格隔开,最后换行。

3. `int lengthOfList(struct ListNode *head)`:传入链表头节点,返回链表的长度。

4. `void insertNode(struct ListNode *head, int index, int val)`:传入链表的头节点、插入的位置和插入的值,在指定位置插入一个新节点。

5. `void deleteNode(struct ListNode *head, int index)`:传入链表的头节点和删除的位置,删除指定位置的节点。

6. `void reverseList(struct ListNode *head)`:传入链表的头节点,翻转整个链表。

7. `int findValInList(struct ListNode *head, int val)`:传入链表的头节点和要查找的值,返回第一个匹配的节点的下标,如果没有匹配的,则返回-1。

二、解题思路1. 创建链表:根据数组中元素的数量,循环遍历数组,每结构体当做链表节点,并记录对应下一个节点,最后返回链表头节点。

2. 打印链表:循环遍历链表的每一个节点,打印节点的val,并在每个节点之间添加空格,最后在尾部添加换行符。

3. 计算链表长度:从链表头节点开始循环遍历每一个节点,直到当前节点的next指针指向NULL,每遍历到一个节点就计数器加1。

二叉链表基本概念

二叉链表基本概念

二叉链表基本概念二叉链表是一种数据结构,它由节点组成,每个节点包含两个部分:数据和指向其子节点的指针。

二叉链表通常用于表示二叉树,其中每个节点最多有两个子节点,通常称为左子节点和右子节点。

以下是关于二叉链表的详细介绍:一、基本概念1. 节点:节点是二叉链表中的基本单位,每个节点包含两部分:数据和指针。

数据用于存储实际信息,而指针则指向该节点的子节点。

每个节点都有两个指针,一个指向左子节点,另一个指向右子节点。

2. 左子节点和右子节点:在二叉链表中,每个节点最多有两个子节点:左子节点和右子节点。

左子节点的指针指向节点的左子树,右子节点的指针指向节点的右子树。

3. 父节点和孩子节点:在一个二叉链表中,如果一个节点B是另一个节点A的子节点,则A被称为B的父节点,B被称为A的孩子节点。

4. 空节点:在二叉链表中,如果一个节点的父节点为空,则该节点被称为根节点。

如果一个节点的孩子节点为空,则该节点被称为叶节点。

二、基本操作1. 插入操作:插入操作是向二叉链表中添加一个新的节点。

新节点的父节点可以根据需要选择,可以是根节点或某个已存在的节点。

如果新节点的父节点是根节点,则该操作称为根插入;如果新节点的父节点是已存在的节点,则该操作称为插入到指定位置。

插入操作可以通过递归或迭代方式实现。

2. 删除操作:删除操作是从二叉链表中移除一个已存在的节点。

如果被删除的节点是叶节点,则可以直接将其从链表中移除;如果被删除的节点有孩子节点,则需要先找到其孩子节点的替换节点,并将其连接到被删除节点的位置。

删除操作同样可以通过递归或迭代方式实现。

3. 查找操作:查找操作是在二叉链表中查找一个特定的值或节点。

查找操作可以通过递归或迭代方式实现,时间复杂度为O(n),其中n为二叉链表的长度。

4. 遍历操作:遍历操作是对二叉链表中的所有节点进行访问。

常见的遍历方式有前序遍历、中序遍历和后序遍历。

遍历操作可以通过递归或迭代方式实现。

5. 旋转操作:旋转操作是将二叉链表中的某个节点向左或向右移动一定的位置,以保持链表的平衡。

链表的反转与合并掌握链表反转和合并操作的实现

链表的反转与合并掌握链表反转和合并操作的实现

链表的反转与合并掌握链表反转和合并操作的实现链表是一种常见的数据结构,它由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。

链表的反转和合并是链表操作中常见且重要的操作,在很多编程问题中都有应用。

本文将介绍链表的反转和合并操作的实现方法。

一、链表的反转链表的反转是指将链表中节点的顺序反向排列。

例如,对于链表1→2→3→4→5,反转后的链表为5→4→3→2→1。

实现链表的反转有两种常见的方法:迭代法和递归法。

1. 迭代法迭代法的实现思路是,从链表头节点开始,依次遍历每个节点,将该节点的指针指向前一个节点。

具体步骤如下:1)定义三个指针:当前节点指针cur、前一个节点指针prev、下一个节点指针next。

2)遍历链表,将当前节点的指针指向前一个节点,然后更新prev、cur和next指针的位置。

3)重复上述步骤,直到遍历到链表末尾。

以下是迭代法的实现代码示例(使用Python语言):```pythondef reverse_list(head):prev = Nonecur = headwhile cur:next = cur.nextcur.next = prevprev = curcur = nextreturn prev```2. 递归法递归法的实现思路是,从链表的尾节点开始,依次反转每个节点。

具体步骤如下:1)递归地反转除最后一个节点外的链表。

2)将当前节点的指针指向前一个节点。

3)返回反转后的链表的头节点。

以下是递归法的实现代码示例(使用Python语言):```pythondef reverse_list(head):if not head or not head.next:return headnew_head = reverse_list(head.next)head.next.next = headhead.next = Nonereturn new_head```二、链表的合并链表的合并是指将两个有序链表按照一定的规则合并成一个有序链表。

c语言链表的基本操作

c语言链表的基本操作

c语言链表的基本操作(1)单链表的创建// 定义单链表结构体struct Node{int data; // 节点元素值struct Node *next; // 指向下一节点的指针};// 创建单链表struct Node * list_create(){struct Node *head; // 保存头节点struct Node *p1, *p2; // 临时指针int data;// 分配新节点p1 = (struct Node *)malloc(sizeof(struct Node));p2 = p1; // 维持p1指向新节点printf("Please input data:\n");scanf("%d", &data);// 保存数据和指针p1->data = data;p1->next = NULL;if(data != 0) {// 循环录入while(data != 0) {// 分配新节点p1 = (struct Node *)malloc(sizeof(struct Node));p1->next = NULL;// 保存数据scanf("%d", &data);p1->data = data;p2->next = p1;p2 = p1;}}head = p1;printf("Single list create success!!\n");return head;}(2)单链表的插入// 向单链表插入元素void list_insert(struct Node *list){struct Node *p1, *p2;int data;printf("Please input insert data:\n");scanf("%d", &data);// 分配新节点p1 = (struct Node *)malloc(sizeof(struct Node));p1->data = data; // 保存数据p2 = list; // p2指向头指针// 查找插入位置while ((p2 != NULL) && (p2->data < data)){p1 = p2;p2 = p2->next; // 遍历单链表}if (list == p2) // 在最前面插入{p1 = p2; // p1头指针指向头结点list = p1;}// 保存插入位置p1->next = p2;// 插入新节点p1->next->next = p2->next;printf("List insert success!!\n");}(3)单链表的删除// 删除单链表中的节点void list_delete (struct Node *list){struct Node *p1, *p2;int data;printf("Please input delete data:\n");scanf("%d", &data);p1 = list;// 查找删除位置while ((p1->next != NULL) && (p1->next->data < data)) {p1 = p1->next; // 遍历单链表}// 找到要删除的节点if (p1->next->data == data){p2 = p1->next; // 保存要删除的节点p1->next = p2->next; // 指针指向要删除的下一节点// 释放要删除的节点free(p2);printf("List delete success!!\n");}else{printf("No data in list!!\n");}}(4)单链表的查找// 查找单链表中的元素void list_fetch (struct Node *list){struct Node *p;int data;p = list;printf("Please input fetch data:\n");scanf("%d", &data);// 查找插入位置while (p != NULL){if (p->data == data){printf("Fetch success!!\n");break;}p = p->next; // 指针指向下一节点}if (p == NULL){printf("No data in list!!\n");}}(5)单链表的遍历// 遍历单链表void list_traverse (struct Node *list){struct Node *p;printf("Single list traverse: \n");p = list;while (p != NULL) // 遍历单链表{printf("%d ", p->data);p = p->next;}}(6)单链表的销毁// 销毁单链表void list_destory (struct Node *list){struct Node *p;while (list != NULL){p = list; // 保存头指针list = list->next; // 移除头节点// 释放free (p);}printf("Destory list!!\n");}。

单片机多级菜单编程实现(ZT)建立一个树状的菜单结构,用链表实现

单片机多级菜单编程实现(ZT)建立一个树状的菜单结构,用链表实现

单片机多级菜单编程实现(ZT) 建立一个树状的菜单结构,用链表实现链表中包含:1、指向同级左右菜单和指向父菜单、子菜单的四个菜单结构体指针;2、进入该菜单时需要执行的初始化函数指针3、退出该菜单时需要执行的结束函数指针4、该菜单内的按键处理函数指针数组的指针操作菜单模块需要的按键操作有:左、右、确认、退出。

采用这种办法,可以方便的添加或删减菜单。

并且只需要在其头文件中修改初始变量就可以实现,完全无须修改C文件中的任何函数。

具体结构定义我的定义,做个参考:#define MENU_HLP_EN 菜单帮助信息使能typedef struct{void (pMenuTaskInit)(void); 指向菜单任务初始化函数的指针void (pMenuTaskEnd)(void); 指向菜单任务结束函数的指针}MENU_TASK_TYP;typedef struct MenuTyp{INT8U MenuName; 菜单名称字符串WORK_MOD WorkMod; 工作状态编号MENU_TASK_TYP pMenuTask; 指向菜单任务的指针void (pTaskKeyDeal)(void); 指向菜单任务按键处理函数数组的指针#ifdef MENU_HLP_ENINT8U MenuHlp; 菜单帮助字符串#endifstruct MenuTyp pParent; 指向上层菜单的指针struct MenuTyp pChild; 指向子菜单的指针struct MenuTyp pRight; 指向右菜单的指针struct MenuTyp pLeft; 指向左菜单的指针}MENU_TYP;我根据网上的资料做的一个菜单:菜单数据结构struct KeyTabStruct{uint8 MenuIndex; 当前状态索引号uint8 MaxItems; 本级菜单最大条目数uint8 ShowLevel; 菜单显示内容uint8 PressOk; 按下回车键时转向的状态索引号uint8 PressEsc; 按下返回键时转向的状态索引号uint8 PressDown; 按下向下键时转向的状态索引号uint8 PressUp; 按下向上键时转向的状态索引号void (CurrentOperate)(); 当前状态应该执行的功能操作};uint8 MenuID; 菜单ID号uint8 MenuNextID; 下级菜单ID号CurMenuID=本菜单IDMaxMenuItem=同级菜单最大项数OkMenuID=子菜单层所对应的菜单ID,ID=999为菜单已经到底了EscMenuID=父菜单层所对应的菜单ID,ID=999为菜单已经到顶了DownMenuID=弟菜单层所对应的菜单ID,ID=999为菜单是独生子UpMenuID=兄菜单层所对应的菜单ID,ID=999为菜单是独生子CurFunction=本菜单所对应的菜单函数指针const struct KeyTabStruct KeyTab[MAX_KEYTABSTRUCT_NUM]={CurMenuID, axMenuItem, MenuShowLevel, OkMenuID, EscMenuID, DownMenuID, UpMenuID, CurFunction{MENU_EDIT, 0, 0, MENU_DA TA_VIEW, MENU_NO, MENU_NO, MENU_NO, MenuEdit}, {MENU_DA TA_VIEW, 3, 1, MENU_DA TA_VIEW_FIRE, MENU_EDIT, MENU_SYS_EDIT, MENU_PRINT_DA TA,MenuEdit},{MENU_DA TA_VIEW_FIRE, 5, MENU_NO, MENU_NO, MENU_DA TA_VIEW, MENU_DA TA_VIEW_TROUBLE, MENU_STEP_FOLLOW, MenuDataViewIn},{MENU_DA TA_VIEW_TROUBLE, 5, MENU_NO, MENU_NO, MENU_DA TA_VIEW, MENU_DA TA_VIEW_REPEA T, MENU_DA TA_VIEW_FIRE, MenuDataViewIn},{MENU_DA TA_VIEW_REPEA T, 5, MENU_NO,MENU_NO, MENU_DA TA_VIEW, MENU_FACE_CHECK, MENU_DA TA_VIEW_TROUBLE, MenuDataV iewIn},{MENU_FACE_CHECK, 5, MENU_NO,MENU_NO, MENU_DA TA_VIEW, MENU_STEP_FOLLOW,MENU_DA TA_VIEW_REPEA T, MenuFaceCheck},{MENU_STEP_FOLLOW, 5, MENU_NO,MENU_NO, MENU_DA TA_VIEW, MENU_DA TA_VIEW_FIRE, MENU_FACE_CHECK,MenuStepFollow},{MENU_SYS_EDIT, 3,2, MENU_SUM_SET, MENU_EDIT,MENU_PRINT_DA TA, MENU_DA TA_VIEW, MenuEdit}, {MENU_SUM_SET, 6, MENU_NO,MENU_NO, MENU_SYS_EDIT, MENU_EDIT_INSULA TE,MENU_TIME_SET, MenuSumSet},{MENU_EDIT_INSULA TE, 6, MENU_NO,MENU_NO, MENU_SYS_EDIT, MENU_EDIT_HZ, MENU_SUM_SET,MenuEditInsulate},{MENU_EDIT_HZ, 6, MENU_NO,MENU_NO, MENU_SYS_EDIT, MENU_LD_CONTROL,MENU_EDIT_INSULA TE, MenuEditHZ},{MENU_LD_CONTROL, 6,MENU_NO, MENU_NO, MENU_SYS_EDIT, MENU_LD_DELAY,MENU_EDIT_HZ, MenuLDControl},{MENU_LD_DELAY, 6,MENU_NO, MENU_NO, MENU_SYS_EDIT, MENU_TIME_SET,MENU_LD_CONTROL, MenuLDDelay},{MENU_TIME_SET, 6, MENU_NO,MENU_NO, MENU_SYS_EDIT, MENU_SUM_SET, MENU_LD_DELAY,MenuTimeSet},{MENU_PRINT_DA TA, 3, 3,MENU_PRINT_DA TA_FIRE, MENU_EDIT, MENU_DA TA_VIEW, MENU_SYS_EDIT, MenuEdit},{MENU_PRINT_DA TA_FIRE, 4,MENU_NO, MENU_NO, MENU_PRINT_DA TA,MENU_PRINT_DA TA_TROUBLE, MENU_PRINT_SET, MenuPrintDataIn}, {MENU_PRINT_DA TA_TROUBLE, 4, MENU_NO,MENU_NO, MENU_PRINT_DA TA, MENU_PRINTER_CHECK,MENU_PRINT_DA TA_FIRE, MenuPrintDataIn},{MENU_PRINTER_CHECK, 4, MENU_NO,MENU_NO, MENU_PRINT_DA TA, MENU_PRINT_SET,MENU_PRINT_DA TA_TROUBLE, MenuPrintDataIn},{MENU_PRINT_SET, 4, MENU_NO,MENU_NO, MENU_PRINT_DA TA, MENU_PRINT_DA TA_FIRE, MENU_PRINTER_CHECK, MenuPrintSet},};编程菜单显示数据const struct MenuDispData MenuEditShow[][MENU_MAX] = {{{MENU_NO , 0, 0, 选择消音→退出}, 主菜单{MENU_DA TA_VIEW , 1, 6, ⒈数据查看},{MENU_SYS_EDIT , 2, 6, ⒉系统编程},{MENU_PRINT_DA TA, 3, 6, ⒊数据打印}},{{MENU_NO , 0, 0, 数据查看消音→退出}, 数据查看{MENU_DA TA_VIEW_FIRE , 1, 4, ⒈火警},{MENU_DA TA_VIEW_TROUBLE, 2, 4, ⒉故障},{MENU_DA TA_VIEW_REPEA T , 3, 4, ⒊重码},{MENU_FACE_CHECK , 1,12, ⒋面板检测},{MENU_STEP_FOLLOW , 2,12, ⒌单步跟踪}},{{MENU_NO , 0, 0, 系统编程消音→退出}, 系统编程{MENU_SUM_SET , 1, 0, ⒈容量设置},{MENU_EDIT_INSULA TE , 2, 0, ⒉隔离点},{MENU_EDIT_HZ , 3, 0, ⒊汉字描述},{MENU_LD_CONTROL , 1,12, ⒋联动控制},{MENU_LD_DELAY, 2,12, ⒌模块延时},{MENU_TIME_SET , 3,12, ⒍时钟调整}},{{MENU_NO , 0, 0, 数据打印消音→退出}, 数据打印{MENU_PRINT_DA TA_FIRE , 1, 0, ⒈火警数据},{MENU_PRINT_DA TA_TROUBLE,2, 0, ⒉故障数据},{MENU_PRINTER_CHECK , 3, 0, ⒊打印机自检},{MENU_PRINT_SET , 1,12, ⒋打印设置}},};等待按键void WaitKey(void){uint32 time;time = RTCFlag;WhichKey = KEY_NONE;while(!EscFlag){if(RTCFlag - time = EDIT_TIME)EscFlag = TRUE;if(WhichKey != KEY_NONE){KeySound(300); 按键音return;}}}显示多级菜单void MenuEdit(){uint32 i,j=0;uint32 oldid;j = KeyTab[MenuID].ShowLevel;if(WhichKey == KEY_ESC WhichKey == KEY_OK){ClearScreen();for(i=0;iKeyTab[MenuNextID].MaxItems+1;i++)ShowString(MenuEditShow[j][i].Lin,MenuEditShow[j] [i].Column,MenuEditShow[j][i].Pdata,0); 初始化显示oldid =0;没有原先选择的项}else{if(WhichKey == KEY_UP)oldid = KeyTab[MenuNextID].PressDown;elseoldid = KeyTab[MenuNextID].PressUp;指示原先的项}for(i=1;iKeyTab[MenuNextID].MaxItems+1;i++){if(MenuEditShow[j][i].Id == oldid)ShowString(MenuEditShow[j][i].Lin,MenuEditShow[j] [i].Column,MenuEditShow[j][i].Pdata,0); 正常显示原先的项else{if(MenuEditShow[j][i].Id == MenuNextID)ShowString(MenuEditShow[j][i].Lin,MenuEditShow [j][i].Column,MenuEditShow[j][i].Pdata,1); 反显当前选择的项}}WhichKey = KEY_NONE;}系统编程uint32 Edit(void){struct KeyTabStruct NowKeyTab; 指示当前的菜单值uint32 escflag = FALSE;ResetFlag = FALSE;ChangeFlag = FALSE;EscFlag = FALSE;MenuID = MENU_EDIT;NowKeyTab = KeyTab[MenuID];MenuNextID = NowKeyTab.PressOk;(NowKeyTab.CurrentOperate)(); 显示主菜单do{if(WhichKey == KEY_NONE)WaitKey(); 等待按键switch(WhichKey){case KEY_ESC if(NowKeyTab.PressEsc != MENU_NO) {MenuID =NowKeyTab.PressEsc;MenuNextID =NowKeyTab.MenuIndex;NowKeyTab = KeyTab[MenuID];NowKeyTab.PressOk =MenuNextID;(NowKeyTab.CurrentOperate) (); 显示当前菜单}elseescflag =TRUE; 退出编程状态break;case KEY_OK if(NowKeyTab.PressOk != MENU_NO){MenuID =NowKeyTab.PressOk;NowKeyTab = KeyTab[MenuID];MenuNextID =NowKeyTab.PressOk;}(NowKeyTab.CurrentOperate)(); 执行当前按键的操作break;case KEY_UP if((MenuNextID != MENU_NO) && (KeyTab[MenuNextID].PressUp != MENU_NO)){NowKeyTab.PressOk =KeyTab[MenuNextID].PressUp;MenuNextID = KeyTab[MenuNextID].PressUp;(NowKeyTab.CurrentOperate)(); 执行当前按键的操作}break;case KEY_DOWN if((MenuNextID != MENU_NO) && (KeyTab[MenuNextID].PressDown != MENU_NO)){NowKeyTab.PressOk =KeyTab[MenuNextID].PressDown;MenuNextID = KeyTab[MenuNextID].PressDown;(NowKeyTab.CurrentOperate)(); 执行当前按键的操作}break;case KEY_RESET ResetFlag = TRUE;break;default break;}}while(!ResetFlag && !EscFlag && !escflag);if(ChangeFlag && !EscFlag && !ResetFlag)EditDataChange();if(ResetFlag)return SYS_RESET;else{return 0;}}关于这个菜单的说明:1.我用的是ARM处理器,所以51的时候把const改成code,uint32改成unsigned char。

单链表的基本运算

单链表的基本运算
{ Node *s; char c; int flag=1; while(flag) /* flag 初值为 1,当输入“$”时,置 flag 为 0,
建表结束*/ { c=getchar(); if(c!=’$’) { s=(Node*)malloc(sizeof(Node)); /*建立新结点 s*/ s->data=c; s->next=L->next; /*将 s 结点插入表头*/ L->next=s; } else flag=0;
3. 结果判断 如找到第 i 个结点,则返回结点 p;
如表查完未找到,则返回空。
【算法描述】
Node * Get (LinkList L, int i) / * 在带头结点的单链表 L 中查找第 i 个结点,若找到(1≤i≤n),则返回 该结点的存储位置; 否则返回 NULL * / { int j;
【算法描述】
int ListLength(LinkList L)
/*求带头结点的单链表 L 的长度*/
{ Node *p;
p=L->next;
j=0; /*用来存放单链表的长度*/
while(p!=NULL)
{
p=p->next;
j ++;
}
return j; /*j 为求得的单链表长度*/
} /* ListLength */
H

s r
(a)初始化的空表
C1 ∧
(b)申请新结点并赋值
s 指向新申请的结点空间;
s->data:=C1
H
c1 ∧
r
(c)插入第一个结点
s
① r->next=s;
c1 H

Python数据结构之链表详解

Python数据结构之链表详解

Python数据结构之链表详解⽬录0.学习⽬标1.线性表的链式存储结构1.1指针相关概念1.2指针结构1.3结点1.4结点类2.单链表的实现2.1单链表的初始化2.2获取单链表长度2.3读取指定位置元素2.4查找指定元素2.5在指定位置插⼊新元素2.6删除指定位置元素2.7其它⼀些有⽤的操作3.单链表应⽤3.1单链表应⽤⽰例3.2利⽤单链表基本操作实现复杂操作0. 学习⽬标在顺序存储⽅式中,根据数据元素的序号就可随机存取表中任何⼀个元素,但同时在插⼊和删除运算需要移动⼤量的元素,造成算法效率较低。

解决此缺陷的⼀个办法是:对线性表采⽤链式存储⽅式。

在链表存储⽅式中,在逻辑上相邻的数据元素在存储空间中不⼀定相邻,数据元素的逻辑次序是通过链表中指针链接实现的。

本节将介绍链式存储结构的特点以及各种基本操作的实现。

通过本节学习,应掌握以下内容:线性表的链式存储及实现⽅法链表基本操作的实现利⽤链表的基本操作实现复杂算法1. 线性表的链式存储结构链式存储结构⽤于存放线性表中的元素的存储单元在内存中可以是连续的,也可以是零散分布的。

由于线性表中各元素间存在着线性关系,为了表⽰元素间的这种线性关系,链式存储结构中不仅要存储线性表中的元素,还要存储表⽰元素之间逻辑关系的信息。

所以⽤链式存储结构表⽰线性表中的⼀个元素时⾄少需要两部分信息,除了存储每⼀个数据元素值以外,还需存储其后继或前驱元素所在内存的地址。

采⽤链式存储结构表⽰的线性表简称链表 (Linked List)。

1.1 指针相关概念在继续进⾏讲解前,我们⾸先来了解指针的相关概念,以便更好的理解链表。

假设我们需要处理⼀个⼤型数据⽂件,这⼀⽂件已经被读取保持在内存中,当我们在函数间传递⽂件时,并不会直接传递整个⽂件,我们需要创建变量来保存⽂件在内存中的位置,这些变量很⼩,很容易在不同的函数之间传递。

使⽤指针的好处之⼀就是可以⽤⼀个简单的内存地址就可以指向⼀个更⼤的内存地址段。

数据结构链表的基本操作

数据结构链表的基本操作

数据结构链表的基本操作一、引言链表是计算机科学中的一种数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

链表可以用于实现栈、队列和其他数据结构。

本文将详细介绍链表的基本操作。

二、链表的基本概念1. 节点:链表中的每个元素称为节点,它包含两部分:数据和指向下一个节点的指针。

2. 头结点:链表中第一个节点称为头结点,它不包含实际数据,只有指向第一个真正节点的指针。

3. 尾节点:链表中最后一个节点称为尾节点,它的指针为空。

4. 空链表:不包含任何元素的链表称为空链表。

三、链表的基本操作1. 创建链表创建一个空链表很简单,只需要让头结点指针为空即可。

如果需要创建带有多个元素的非空链表,则需要依次创建每个节点,并将前一个节点的指针指向当前节点。

2. 插入元素在插入元素时,需要先找到要插入位置前面的那个节点。

然后新建一个要插入的节点,并将其指针指向原来位置上后面那个节点。

最后将前面那个节点的指针改为新建立的节点。

3. 删除元素在删除元素时,需要先找到要删除的那个节点。

然后将前一个节点的指针指向后一个节点,从而跳过要删除的那个节点。

最后释放要删除的节点。

4. 遍历链表遍历链表是指依次访问链表中每个元素。

可以使用循环结构来实现遍历操作。

从头结点开始,依次访问每个节点,并将其数据输出即可。

5. 查找元素查找元素时,需要从头结点开始依次遍历每个节点,直到找到目标元素或者遍历完整个链表为止。

6. 反转链表反转链表是指将原来的链表顺序倒置。

可以使用三个指针分别表示当前节点、前一个节点和后一个节点,依次修改它们之间的指针即可实现反转操作。

四、链表的应用举例1. 栈和队列:栈和队列都可以用链表来实现。

栈是一种先进后出(FILO)的数据结构,而队列是一种先进先出(FIFO)的数据结构。

2. 链式存储文件系统:文件系统中通常采用基于树或者基于哈希表的存储方式。

但是在某些情况下,也可以采用基于链式存储方式来实现文件系统。

链表(单链表 双向循环)实验报告讲解

链表(单链表 双向循环)实验报告讲解

数据结构实验报告T1223-3-21余帅实验一实验题目:仅仅做链表部分难度从上到下1.双向链表,带表头,线性表常规操作。

2.循环表,带表头,线性表常规操作。

3.单链表,带表头,线性表常规操作。

实验目的:了解和掌握线性表的逻辑结构和链式存储结构,掌握单链表的基本算法及相关的时间性能分析。

实验要求:常规操作至少有:1.数据输入或建立2.遍历3.插入4.删除必须能多次反复运行实验主要步骤:1、分析、理解给出的示例程序。

2、调试程序,并设计输入数据,测试程序的如下功能:1.数据输入或建立2.遍历3.插入4.删除单链表示意图:headhead head 创建删除双向循环链表示意图:创建程序代码://单链表#include<iostream.h>#include<windows.h>const MAX=5;enum returninfo{success,fail,overflow,underflow,range_error}; int defaultdata[MAX]={11,22,33,44,55};class node{public:int data;node *next;};class linklist{private:node *headp;protected:int count;public:linklist();~linklist();bool empty();void clearlist();returninfo create(void);returninfo insert(int position,const int &item);returninfo remove(int position) ;returninfo traverse(void);};linklist::linklist(){headp = new node;headp->next = NULL;count=0;}linklist::~linklist(){clearlist();delete headp;}bool linklist::empty(){if(headp->next==NULL)return true;elsereturn false;}void linklist::clearlist(){node *searchp=headp->next,*followp=headp;while(searchp->next!=NULL){followp=searchp;searchp=searchp->next;delete followp;}headp->next = NULL;count = 0;}returninfo linklist::create(){node *searchp=headp,*newnodep;for(int i=0;i<MAX;i++){newnodep = new node;newnodep->data = defaultdata[i];newnodep->next = NULL;searchp->next = newnodep;searchp = searchp->next;count++;}searchp->next = NULL;traverse();return success;}returninfo linklist::insert(int position,const int &item) //插入一个结点{if(position<=0 || position>=count)return range_error;node *newnodep=new node,*searchp=headp->next,*followp=headp;for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}newnodep->data=item; //给数据赋值newnodep->next=followp->next; //注意此处的次序相关性followp->next=newnodep;count++; //计数器加一return success;}returninfo linklist::remove(int position) //删除一个结点{if(empty())return underflow;if(position<=0||position>=count+1)return range_error;node *searchp=headp->next,*followp=headp; //这里两个指针的初始值设计一前一后for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}followp->next=searchp->next; //删除结点的实际语句delete searchp; //释放该结点count--; //计数器减一return success;}returninfo linklist::traverse(void){node *searchp;if(empty())return underflow;searchp = headp->next;cout<<"连表中的数据为:"<<endl;while(searchp!=NULL){cout<<searchp->data<<" ";searchp = searchp->next;}cout<<endl;return success;}class interfacebase{public:linklist listface; //定义一个对象Cskillstudyonfacevoid clearscreen(void);void showmenu(void);void processmenu(void);};void interfacebase::clearscreen(void){system("cls");}void interfacebase::showmenu(void){cout<<"================================"<<endl;cout<<" 功能菜单 "<<endl;cout<<" 1.创建链表 "<<endl;cout<<" 2.增加结点 "<<endl;cout<<" 3.删除结点 "<<endl;cout<<" 4.遍历链表 "<<endl;cout<<" 0.结束程序 "<<endl;cout<<"======================================"<<endl;cout<<"请输入您的选择:";}void interfacebase::processmenu(void){int returnvalue,item,position;char menuchoice;cin >>menuchoice;switch(menuchoice) //根据用户的选择进行相应的操作{case '1':returnvalue=listface.create();if(returnvalue==success)cout<<"链表创建已完成"<<endl;break;case '2':cout<<"请输入插入位置:"<<endl;cin>>position;cout<<"请输入插入数据:"<<endl;cin>>item;returnvalue = listface.insert(position,item);if(returnvalue==range_error)cout<<"数据个数超出范围"<<endl;elsecout<<"操作成功!!!"<<endl;break;case '3':cout<<"输入你要删除的位置:"<<endl;cin>>position;returnvalue = listface.remove(position);if(returnvalue==underflow)cout<<"链表已空"<<endl;else if(returnvalue==range_error)cout<<"删除的数据位置超区范围"<<endl;elsecout<<"操作成功!!!"<<endl;break;case '4':listface.traverse();break;case '0':cout<<endl<<endl<<"您已经成功退出本系统,欢迎再次使用!!!"<<endl;system("pause");exit(1);default:cout<<"对不起,您输入的功能编号有错!请重新输入!!!"<<endl;break;}}void main(){interfacebase interfacenow;linklist listnow;system("color f0");interfacenow.clearscreen();while(1){interfacenow.showmenu();interfacenow.processmenu();system("pause");interfacenow.clearscreen();}}/* 功能:用双向循环链表存储数据1.创建链表2.增加结点3.删除结点4.遍历链表制作人:余帅内容:239行*/#include<iostream.h>#include<windows.h>const MAX=5;enum returninfo{success,fail,overflow,underflow,range_error}; int defaultdata[MAX]={11,22,33,44,55};class node{public:int data;node * next; //指向后续节点node * pre; //指向前面的节点};class linklist{private:node *headp;protected:int count;public:linklist();~linklist();bool empty();void clearlist();returninfo create(void);returninfo insert(int position,const int &item);returninfo remove(int position) ;returninfo traverse(void);};linklist::linklist(){headp = new node;headp->next = NULL;headp->pre = NULL;count=0;}linklist::~linklist(){clearlist();delete headp;}bool linklist::empty(){if(headp->next==NULL)return true;elsereturn false;}void linklist::clearlist(){node *searchp=headp->next,*followp=headp;while(searchp->next!=NULL){followp=searchp;searchp=searchp->next;delete followp;}headp->next = NULL;headp->pre = NULL;count = 0;}returninfo linklist::create(){node *searchp=headp,*newnodep;for(int i=0;i<MAX;i++){newnodep = new node;newnodep->data = defaultdata[i];newnodep->next = NULL;searchp->next = newnodep;newnodep->pre = searchp;searchp = searchp->next;count++;}searchp->next = headp;headp->pre = searchp;traverse();return success;}returninfo linklist::insert(int position,const int &item) //插入一个结点{if(position<=0 || position>count+1)return range_error;node *newnodep=new node;node *searchp=headp->next,*followp=headp;for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}newnodep->data=item; //给数据赋值newnodep->next = searchp;searchp->pre = newnodep;followp->next = newnodep;newnodep->pre = followp;count++; //计数器加一return success;}returninfo linklist::remove(int position) //删除一个结点{if(empty())return underflow;if(position<=0||position>=count+1)return range_error;node *searchp=headp->next,*followp=headp; //这里两个指针的初始值设计一前一后for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}followp->next=searchp->next; //删除结点的实际语句searchp->next->pre = followp;delete searchp; //释放该结点count--; //计数器减一return success;}returninfo linklist::traverse(void){node *searchp1,*searchp2;if(empty())return underflow;searchp1 = headp;searchp2 = headp;cout<<"连表中的数据为:"<<endl;cout<<"从左至右读取:";while (searchp1->next!=headp ) {searchp1 = searchp1 ->next;cout << searchp1->data<<" ";}cout<<endl;cout<<"从右至左读取:";while (searchp2->pre!=headp ) {searchp2 = searchp2 ->pre;cout << searchp2->data<<" ";}cout<<endl;return success;}class interfacebase{public:linklist listface; //定义一个对象Cskillstudyonface void clearscreen(void);void showmenu(void);void processmenu(void);};void interfacebase::clearscreen(void){system("cls");}void interfacebase::showmenu(void){cout<<"================================"<<endl;cout<<" 功能菜单 "<<endl;cout<<" 1.创建链表 "<<endl;cout<<" 2.增加结点 "<<endl;cout<<" 3.删除结点 "<<endl;cout<<" 4.遍历链表 "<<endl;cout<<" 0.结束程序 "<<endl;cout<<"======================================"<<endl;cout<<"请输入您的选择:";}void interfacebase::processmenu(void){int returnvalue,item,position;char menuchoice;cin >>menuchoice;switch(menuchoice) //根据用户的选择进行相应的操作{case '1':returnvalue=listface.create();if(returnvalue==success)cout<<"链表创建已完成"<<endl;break;case '2':cout<<"请输入插入位置:"<<endl;cin>>position;cout<<"请输入插入数据:"<<endl;cin>>item;returnvalue = listface.insert(position,item);if(returnvalue==range_error)cout<<"数据个数超出范围"<<endl;elsecout<<"操作成功!!!"<<endl;break;case '3':cout<<"输入你要删除的位置:"<<endl;cin>>position;returnvalue = listface.remove(position);if(returnvalue==underflow)cout<<"链表已空"<<endl;else if(returnvalue==range_error)cout<<"删除的数据位置超区范围"<<endl;elsecout<<"操作成功!!!"<<endl;break;case '4':listface.traverse();break;case '0':cout<<endl<<endl<<"您已经成功退出本系统,欢迎再次使用!!!"<<endl;system("pause");exit(1);default:cout<<"对不起,您输入的功能编号有错!请重新输入!!!"<<endl;break;}}void main(){interfacebase interfacenow;linklist listnow;system("color f0");interfacenow.clearscreen();while(1){interfacenow.showmenu();interfacenow.processmenu();system("pause");interfacenow.clearscreen();}}运行结果:1.创建链表:2.增加结点3.删除结点心得体会:本次实验使我们对链表的实质了解更加明确了,对链表的一些基本操作也更加熟练了。

实验二 链表的基本操作

实验二 链表的基本操作

实验二链表的基本操作链表是一种常用的数据结构,它由一系列节点组成,每个节点包含两部分:数据和指向下一个节点的指针。

链表的基本操作包括插入、删除和查找等。

本文将围绕链表的基本操作展开讲解,并以此为标题展开内容。

一、链表的插入操作链表的插入操作是指在链表中插入一个新的节点。

插入操作可以分为头插法和尾插法。

1. 头插法:将新节点插入链表的头部,即将新节点的指针指向原链表的头节点,再将链表的头指针指向新节点。

这样可以在常数时间内完成插入操作。

2. 尾插法:将新节点插入链表的尾部,即将原链表的尾节点指针指向新节点,再将新节点的指针指向空。

这样也可以在常数时间内完成插入操作。

二、链表的删除操作链表的删除操作是指删除链表中的一个节点。

删除操作可以分为删除指定节点和删除指定数值的节点两种情况。

1. 删除指定节点:找到待删除节点的前一个节点,将其指针指向待删除节点的下一个节点,再释放待删除节点的内存空间。

2. 删除指定数值的节点:遍历链表,找到数值匹配的节点并删除,具体操作与删除指定节点类似。

三、链表的查找操作链表的查找操作是指在链表中寻找某个节点或数值。

链表的查找操作与数组的查找操作不同,需要从头节点开始遍历整个链表。

1. 查找指定节点:遍历链表,逐个比较节点的值,直到找到目标节点或遍历到链表末尾。

2. 查找指定数值的节点:同样遍历链表,逐个比较节点的值,直到找到目标数值或遍历到链表末尾。

四、链表的其他操作除了插入、删除和查找操作外,链表还可以进行其他操作,如获取链表长度、反转链表和合并链表等。

1. 获取链表长度:遍历链表,计数节点的个数,即为链表的长度。

2. 反转链表:遍历链表,将每个节点的指针指向前一个节点,最后将链表的头指针指向原链表的尾节点。

3. 合并链表:将两个有序链表合并成一个新的有序链表。

遍历两个链表,逐个比较节点的值,将较小值的节点插入新链表中,直到其中一个链表遍历完毕,然后将另一个链表的剩余部分直接插入新链表的尾部。

C++链表的创建与操作

C++链表的创建与操作

c++链表的创建与操作我们知道,数组式计算机根据事先定义好的数组类型与长度自动为其分配一连续的存储单元,相同数组的位置和距离都是固定的,也就是说,任何一个数组元素的地址都可一个简单的公式计算出来,因此这种结构可以有效的对数组元素进行随机访问。

但若对数组元素进行插入和删除操作,则会引起大量数据的移动,从而使简单的数据处理变得非常复杂,低效。

为了能有效地解决这些问题,一种称为“链表”的数据结构得到了广泛应用。

1.链表概述链表是一种动态数据结构,他的特点是用一组任意的存储单元(可以是连续的,也可以是不连续的)存放数据元素。

链表中每一个元素成为“结点”,每一个结点都是由数据域和指针域组成的,每个结点中的指针域指向下一个结点。

Head是“头指针”,表示链表的开始,用来指向第一个结点,而最后一个指针的指针域为NULL(空地址),表示链表的结束。

可以看出链表结构必须利用指针才能实现,即一个结点中必须包含一个指针变量,用来存放下一个结点的地址。

实际上,链表中的每个结点可以用若干个数据和若干个指针。

结点中只有一个指针的链表称为单链表,这是最简单的链表结构。

再c++中实现一个单链表结构比较简单。

例如,可定义单链表结构的最简单形式如下 struct Node{int Data; Node *next; };这里用到了结构体类型。

其中,*next是指针域,用来指向该结点的下一个结点;Data是一个整形变量,用来存放结点中的数据。

当然,Data可以是任何数据类型,包括结构体类型或类类型。

在此基础上,我们在定义一个链表类list,其中包含链表结点的插入,删除,输出等功能的成员函数。

class list{Node *head; public:list(){head=NULL;}void insertlist(int aDate,int bDate); //链表结点的插入 void Deletelist(int aDate); //链表结点的删除 void Outputlist(); //链表结点的输出 Node*Gethead(){return head;} };2.链表结点的访问由于链表中的各个结点是由指针链接在一起的,其存储单元文笔是连续的,因此,对其中任意结点的地址无法向数组一样,用一个简单的公式计算出来,进行随机访问。

VC++程序设计链表与链表的基本操作

VC++程序设计链表与链表的基本操作
产生下一个结点链表尾要输出链表首先要知道链表头的地址然后用一个指针指向第一个结点输出该结点的数据成员pnum和pscore再使p指向下一结点再输出直到链表的尾结点pnextnull
VC++程序设计 链表与链表的 基本操作
简单链表
链表是一种动态地进行存储分配的结构。最简单的链表称 为单向链表,如图所示: Head
初始 p1=head;
$7.7.4 对链表的插入操作
设已有的链表中各结点的成员是按学号由小到大顺序排列的。
p1
head p2
11041 89
11043 90
11047 85 NULL
p0
89102
初始 p1=p2=head; p0=&stud;
p1
head
p2 p0
11041 89 89102
11043 90
1249
1249
A 1356
1356
B 1475
1475
C 1021
1021
D NULL
特点: 1。头指针变量head, 它存放一个地址,用于指向一个元素。 链表中的一个元素称为结点。 2。每个结点至少应包含两个部分:一为用户需要的实际数据 二为下一个结点的地址。 3。“表尾” 的地址部分放一个“Null”(表示“空地址”) 表示链表的最后一个元素,该元素不再指向其它元素。
//插入结点的函数insert如下:
student *insert(student *head, student *stud) { student *p0,*p1,*p2; p1=head; p0=stud; if(head==Null) //原为空链表 { head=p0; p0->next=Null; } else while((p0->num > p1->num)&&(p1->next != Null)) { //查找插入位置 p2=p1; p1=p1->next; };

链表的基本操作

链表的基本操作

链表的基本操作
链表是一种通用的数据结构,它利用指针对数据元素的每一个节点进行存储,当需要访问任何指定的节点时,受益于指针技术,可以较快的访问指定节点。

在一般的链表中,可以进行如下几种基本操作:
1.插入:链表可以在既有链表中的任何一个位置插入数据元素,通过改变相应指针指向,实现插入操作。

2.删除:链表也可以通过调整相应指针指向,实现删除操作。

3.搜索:在链表中搜索某个元素可以采用顺序搜索的方式,从链表的首元节点开始,逐个比较,直到找到所要查找节点。

4.遍历:链表可以从链表的首元节点开始,按照指针指向,依次访问每一个节点,从而实现对链表的元素的遍历。

5.修改:修改链表可以通过先将要修改的节点找出来,然后调整相应的数据值来实现。

链表的基本操作是一个非常常用的数据结构,可以有效的提高编程效率,更加方便的实现某些算法,广泛应用于很多的计算机程序。

所以在学习更多的数据结构的时候,了解链表的基本操作,也是一个不可忽视的组成部分。

单链表的实现及其基本操作

单链表的实现及其基本操作

单链表的实现及其基本操作结点的引⼊链表是⼀种链式存储结构,链式存储结构的特点是⽤⼀组任意的存储单元存储数据元素。

为了能正确表⽰数据元素之间的线性关系,需引⼊结点概念。

⼀个结点表⽰链表中的⼀个数据元素,节点中除了储存数据元素的信息,还必须存放指向下⼀个节点的的指针(单、双链表的最后⼀个节点除外,它们存储的是⼀个空指针NULL)结点的结构如下图所⽰:代码如下:1 typedef struct node{2int data;3struct node* pNext;4 }Node, *PNode;View Code注:这⾥假设结点中储存的是整型 (int) 的数据单链表由多个结点依次连接⽽成,我们不难想象出它结构:我们注意到:在第⼀个结点的前⾯多了⼀个头结点,这是为了处理空表的⽅便⽽引⼊的,它的指针指向链表的第⼀个结点,⽽它的data域不存放任何信息。

单链表的基本操作1.创建链表1 PNode createList()2 {3int len, value;45 PNode pHead = (PNode)(malloc(sizeof(Node)));6 PNode pTail = pHead;7 pTail->pNext = NULL;89 printf("请输⼊你要的节点个数:");10 scanf("%d", &len);11for(int i=1;i<=len;i++){12 printf("请输⼊第%d个节点的值:", i);13 scanf("%d", &value);1415 PNode pNew = (PNode)malloc(sizeof(Node));16 pNew->data = value;17 pTail->pNext = pNew;18 pTail = pNew;19 pTail->pNext = NULL;20 }2122return pHead;23 }View Code2.遍历链表void traverse(PNode pHead){printf("遍历结果为:\n");PNode pTra = pHead;while(pTra->pNext != NULL){printf("%d ", pTra->pNext->data);pTra = pTra->pNext;}printf("\n");}View Code3.判断链表是否为空1bool isEmpty(PNode pHead)2 {3if(pHead->pNext==NULL)4return true;5else6return false;7 }View Code4.链表长度1int length(PNode pHead)2 {3int len = 0;4while(pHead->pNext!=NULL){5 pHead = pHead->pNext;6 len++;7 }8return len;910 }View Code5.插⼊结点1bool insert(PNode pHead, int pos, int val)2 {3if(pos<1 || pos>length(pHead)){4return false;5 }else{6 PNode pInsert = pHead;7for(int i=1;i<pos;i++){8 pInsert = pInsert->pNext;9 }1011 PNode pNew = (PNode)malloc(sizeof(Node));12 pNew->data = val;13 pNew->pNext = pInsert->pNext;14 pInsert->pNext = pNew;1516return true;17 }1819 }View Code6.删除结点1bool del(PNode pHead, int pos)2 {3if(pos<1 || pos>length(pHead)){4return false;5 }else{6 PNode pDel = pHead;7for(int i=1;i<pos;i++){8 pDel = pDel->pNext;9 }1011if(pos==length(pHead)){12free(pDel->pNext);13 pDel->pNext = NULL;14 }else{15 PNode pNext = pDel->pNext->pNext;16free(pDel->pNext);17 pDel->pNext = pNext;18 }1920return true;2122 }232425 }View Code7.查找节点(1)按元素值查找1 PNode locate(PNode pHead, int value)2 {3 PNode p = pHead->pNext;4while(p&&p->data!=value){ //NULL 是 05 p = p->pNext;6 }7return p;8 }View Code(2)按序号查找1 PNode get(PNode pHead, int k)2 {3 PNode p = pHead;4for(int i=1;i<=k;i++){5 p = p->pNext;6 }7return p;89 }View Code完整代码1 #include<stdio.h>2 #include<stdlib.h>3 typedef struct node{4int data;5struct node* pNext;6 }Node, *PNode;78 PNode createList();9void traverse(PNode pHead);10bool isEmpty(PNode pHead);11int length(PNode pHead);12bool insert(PNode pHead, int pos, int val);13bool del(PNode pHead, int pos);14 PNode get(PNode pHead, int k); //按序号查找15 PNode locate(PNode pHead, int value);//按值查找 1617int main(void)18 {19//test2021return0;22 }2324 PNode createList()25 {26int len, value;2728 PNode pHead = (PNode)(malloc(sizeof(Node)));29 PNode pTail = pHead;30 pTail->pNext = NULL;3132 printf("请输⼊你要的节点个数:");33 scanf("%d", &len);34for(int i=1;i<=len;i++){35 printf("请输⼊第%d个节点的值:", i);36 scanf("%d", &value);3738 PNode pNew = (PNode)malloc(sizeof(Node));39 pNew->data = value;40 pTail->pNext = pNew;41 pTail = pNew;42 pTail->pNext = NULL;43 }4445return pHead;46 }474849void traverse(PNode pHead)50 {51 printf("遍历结果为:\n");52 PNode pTra = pHead;53while(pTra->pNext != NULL)54 {55 printf("%d ", pTra->pNext->data);56 pTra = pTra->pNext;57 }58 printf("\n");59 }6061bool isEmpty(PNode pHead)62 {63if(pHead->pNext==NULL)64return true;65else66return false;67 }6869int length(PNode pHead)70 {71int len = 0;72while(pHead->pNext!=NULL){73 pHead = pHead->pNext;74 len++;75 }76return len;7778 }7980bool insert(PNode pHead, int pos, int val)81 {82if(pos<1 || pos>length(pHead)){83return false;84 }else{85 PNode pInsert = pHead;86for(int i=1;i<pos;i++){87 pInsert = pInsert->pNext;88 }8990 PNode pNew = (PNode)malloc(sizeof(Node));91 pNew->data = val;92 pNew->pNext = pInsert->pNext;93 pInsert->pNext = pNew;9495return true;96 }9798 }99100bool del(PNode pHead, int pos)101 {102if(pos<1 || pos>length(pHead)){103return false;104 }else{105 PNode pDel = pHead;106for(int i=1;i<pos;i++){107 pDel = pDel->pNext;108 }109110if(pos==length(pHead)){111free(pDel->pNext);112 pDel->pNext = NULL;113 }else{114 PNode pNext = pDel->pNext->pNext;115free(pDel->pNext);116 pDel->pNext = pNext;117 }118119return true;120121 }122123124 }125126 PNode get(PNode pHead, int k)127 {128 PNode p = pHead;129for(int i=1;i<=k;i++){130 p = p->pNext;131 }132return p;133134 }135 PNode locate(PNode pHead, int value)136 {137 PNode p = pHead->pNext;138while(p&&p->data!=value){ //NULL 是 0 139 p = p->pNext;140 }141return p;142 }View Code。

数据结构中链表及常见操作

数据结构中链表及常见操作

链表1 定义链表(Linked list)是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的指针(Pointer)。

由于不必须按顺序存储,链表在插入的时候可以达到O(1)的复杂度,比另一种线性表顺序表快得多,但是查找一个节点或者访问特定编号的节点则需要O(n)的时间,而顺序表相应的时间复杂度分别是O(logn)和O(1)。

使用链表结构可以克服数组链表需要预先知道数据大小的缺点,链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。

但是链表失去了数组随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大。

在计算机科学中,链表作为一种基础的数据结构可以用来生成其它类型的数据结构。

链表通常由一连串节点组成,每个节点包含任意的实例数据(data fields)和一或两个用来指向明上一个或下一个节点的位置的链接("links")。

链表最明显的好处就是,常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序,数据的访问往往要在不同的排列顺序中转换。

而链表是一种自我指示数据类型,因为它包含指向另一个相同类型的数据的指针(链接)。

链表允许插入和移除表上任意位置上的节点,但是不允许随机存取。

链表有很多种不同的类型:单向链表,双向链表以及循环链表。

2 结构2.1 单向链表链表中最简单的一种是单向链表,它包含两个域,一个信息域和一个指针域。

这个链接指向列表中的下一个节点,而最后一个节点则指向一个空值。

一个单向链表的节点被分成两个部分。

第一个部分保存或者显示关于节点的信息,第二个部分存储下一个节点的地址。

单向链表只可向一个方向遍历。

链表最基本的结构是在每个节点保存数据和到下一个节点的地址,在最后一个节点保存一个特殊的结束标记,另外在一个固定的位置保存指向第一个节点的指针,有的时候也会同时储存指向最后一个节点的指针。

一般查找一个节点的时候需要从第一个节点开始每次访问下一个节点,一直访问到需要的位置。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

} q->next=NULL;
return(head); }
NODE *CreateDefaultList() {
NODE *head,*q,*p; int num=10; int n=4;
//创建链表
head=(NODE*)malloc(sizeof(NODE)); q=head;
if(n>0){ while(n>0) { p=(NODE*)malloc(sizeof(NODE)); p->data = num; q->next = p; q = p; num = num + 10; n--; }
while(n!=0 && n!=1) {
printf("非法输入!\n"); scanf("%d", &n); }
if(n == 0) {
a=CreateDefaultList(); printf("\n"); menu(a); }else{
a=CreateList(); printf("\n"); menu(a); }
while(p!=NULL)
{
printf("%5d —>",p->data);
p=p->next;
}
printf("NULL");
}
void NizhiList(NODE *head) {
NODE *p,*q; p = head->next; q = NULL;
//链表逆置
if(p==NULL) {
}else if(p==NULL){ q->next = r; r->next = p;
}else {
r->next = p; q->next = r; }
}
void PrintList(NODE *head)
//打印链表
{
NODE *p;
p=head->next;
printf("打印链表如下:\n");
#include <stdio.h> #include <stdlib.h> #include <malloc.h>
typedef struct node {
int data; struct node *next; }NODE;
//定义数据结构
NODE *CreateList() {
NODE *head,*q,*p; int a,n;
int n = 0;
scanf("%d", &n); while(n<0 || n>5) {
printf("非法输入!\n"); scanf("%d", &n); } switch(n) {
case 1: PrintList(head); printf("\n"); menu(head); break;
case 2:
} }
InsertList(head); printf("\n"); menu(head); break; case 3: NizhiList(head); printf("\n"); menu(head); break; case 4: DelList(head); printf("\n"); menu(head); break;
p->next = q->next; q = p->next; }else{ p = q; q = p->next; } } }
void menu(NODE *head) {
printf("键入 1:打印单链表\n"); printf("键入 2:在有序单链表中插入元素 x\n"); printf("键入 3:单链表就地逆置\n"); printf("键入 4:在有序单链表中删除所有值大于 mink 且小于 maxk 的元素\n"); printf("请选择你要进行的操作—>\n");
return 0; }
r=(NODE*)malloc(sizeof(NODE)); r->data = numInsert;
while(p!=NULL && p->data <= r->data) {
q = p; p = q->next; }
if(q==NULL){ r->next = p; head->next = r;
printf("链表为空!"); }else{
q=p->next; }
p->next = NULL;
while(q!=NULL) {
head->next = p; p = q; q = p->next; p->next = head->next; } head->next = p;
}
void DelList(NODE *head) //在有序单链表中删除所有值大于 mink 且小于 maxk 的元素 {
printf("链表为空!"); }else{
q=p->next; }
if(p!=ห้องสมุดไป่ตู้ULL && q==NULL)
{ if(p->data>mink && p->data<mink) { head->next = NULL; }
}
while(q!=NULL) {
if(q->data>mink && q->data<maxk) {
int main()
{
printf("********************************\n");
printf("*
链表操作演示
*\n");
printf("********************************\n\n\n");
int n = 0; NODE *a; printf("请选择使用默认创建的链表(0)或是自行创建链表(1)\n"); printf("默认链表为:10->20->30->40\n"); scanf("%d", &n);
} q->next=NULL;
return(head); }
void InsertList(NODE *head) {
NODE *p,*q,*r; int numInsert; p = head->next; q=NULL;
//插入数据
printf("请输入想插入的数字:\n"); scanf("%d", &numInsert);
NODE *p,*q; int mink,maxk; printf("请输入 mink:"); scanf("%d", &mink); printf("请输入 maxk:"); scanf("%d", &maxk);
if(maxk<mink) {
printf("非法输入!"); }
p = head->next; q = NULL; if(p==NULL) {
待评审代码:链表的基本操作
从键盘读入 n 个整数(升序),请编写算法实现: (1) CreateList():建立带表头结点的单链表; (2) PrintList():显示单链表,(形如:H->10->20->30->40); (3)InsertList():在有序单链表中插入元素 x; (4) NizhiList():单链表就地逆置; (5)DelList():在有序单链表中删除所有值大于 mink 且小于 maxk 的元素。
//创建链表
head=(NODE*)malloc(sizeof(NODE)); q=head;
printf("您想输入几个数字:\n"); scanf("%d",&n);
if(n>0){ printf("请输入数字:\n"); while(n>0) { scanf("%d",&a); p=(NODE*)malloc(sizeof(NODE)); p->data=a; q->next=p; q=p; n--; }
相关文档
最新文档