【线性表——链表】

最新推荐文章于 2023-01-14 12:19:40 发布
最新推荐文章于 2023-01-14 12:19:40 发布
阅读量260 收藏 1
点赞数
分类专栏： # 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/piano_diano/article/details/101713909
版权

一、写链表，主要需要两个结构体：

       一个是表头LinkList（只要知道了表头的地址，就能往下找到每一个结点；表头还记录结点长度）

       一个是结点LinkNode（包括数据域和指针域，每个结点都是通过指针域串联起来）

//表头
typedef struct LINKLIST{

    LinkNode* head;
    int size;

}LinkList;

//结点
typedef struct LINKNODE{

    void* data; //无类型指针，可以指向任何类型数据
    struct  LINKNODE* next;

}LinkNode;

 

注：图中的蓝色竖条代表结点LinkNode的地址

 

二、初始化链表

       初始化链表主要有两部分操作，一是为表头LinkList申请内存，二是为头结点LinkNode(Head) 申请内存。将头结点的地址赋    给表头的head，也就是说head相当于头结点LinkNode(Head) 。一切的操作都从head开始遍历。

//初始化链表

LinkList* Init_LinkList(){

    //创建表头 LinkList
    LinkList* list = (LinkList*)malloc(sizeof(LinkList));
    list->size = 0;

    //创建头结点 LinkNode(Head)
    list->head = (LinkNode*)malloc(sizeof(LinkNode));
    list->head->data = NULL;   //不保存数据信息
    list->head->next = NULL;

return list;
}

 

三、添加第1个结点

       申请内存创建新结点NewNode，填充数据data，next指向空地址NULL，然后将头结点LinkNode(Head)的next指新结点         NewNode的地址

//创建新的节点 LinkNode

LinkNode* NewNode = (LinkNode*)malloc(sizeof(LinkNode));

NewNode->data = data;

NewNode->next = NULL;



LinkNode* pCurrent = list->head;    //从头结点head开始操作

//新结点入链表

NewNode->next = pCurrent->next;   //这里的pCurrent->next（即头结点LinkNode(Head)的next）并没有指向任何一个结点，是指向NULL的

pCurrent->next = NewNode;



list->size++;    //表头记录长度

 

（声明：next代表的是下一个结点的地址。

例如：第n个结点的next就是第n+1个结点的地址

              第n个结点的next的next（相当于第n+1个结点的next）就是第n+2个结点的地址

）

 

 

四、插入新节点

       和第三步的添加第一个结点差不多，只不过原来头结点是指向空的，现在的情况是头结点指向了第1个结点，我们可以在头      结点和第1个结点之间插入一个新结点，也就是第0个位置上插入新结点（pos = 0）

//指定位置插入

void Insert_LinkList(LinkList* list,int pos,void* data){

    //创建新的节点 LinkNode
    LinkNode* NewNode = (LinkNode*)malloc(sizeof(LinkNode));
    NewNode->data = data;
    NewNode->next = NULL;

    LinkNode* pCurrent = list->head;
    for(int i= 0;i<pos;i++){       //这里的pos传入的值是0，因为是要在第0个位置上插入新结点
    pCurrent = pCurrent->next;    
    }

    //新结点入链表
    NewNode->next = pCurrent->next;
    pCurrent->next = NewNode;
    list->size++;
}

 

如果要想在第n个位置插入新结点，则

//指定位置插入

void Insert_LinkList(LinkList* list,int pos,void* data){



//创建新的节点 LinkNode

LinkNode* NewNode = (LinkNode*)malloc(sizeof(LinkNode));

NewNode->data = data;

NewNode->next = NULL;



LinkNode* pCurrent = list->head;

for(int i= 0;i<pos;i++){       //这里的pos传入的值是n，因为是要在第n个位置上插入新结点

pCurrent = pCurrent->next;     //遍历到第n-1个结点

}

//新结点入链表（新结点要取代第n个结点的位置，旧的第n个结点将变成第n+1个结点）

NewNode->next = pCurrent->next;   //将新结点的next指向第n个结点的地址（第n-1个结点的next就是第n个结点的地址）

pCurrent->next = NewNode;    //将第n-1个结点的next指向新结点的地址（或者说是：新节点的地址赋给第n-1个结点的next）



list->size++;

}

 

五、删除结点

假如要删除第n个结点，则只需将第n-1个结点的Next指向第n+1个结点的地址即可

void RemoveByPos_LinkList(LinkList* list,int pos){

//查找删除节点的前一个节点

LinkNode* pCurrent = list->head;

for(int i= 0;i<pos;i++){

pCurrent = pCurrent->next;   //遍历到第n-1个结点

}

LinkNode* pDel =  pCurrent->next;  //找到第n个结点的地址

pCurrent->next =  pDel->next;    //将第n-1个结点的Next指向第n+1个结点的地址



free(pDel);  //释放被删除的第n个节点的内存

list->size--;

}

 

六、销毁链表

            既然在插入结点的时候，每一个结点都是申请了内存，那么最后销毁链表的时候也应该一一释放掉每个结点的内存。

            结点释放顺序规则：

               ·从当前头结点head开始

               ·用指针pNext保存下一个结点的地址

               ·释放当前结点，保存pNext的下一个结点的地址

               ·释放当前结点，保存pNext的下一个结点的地址

            ..........

 

            当结点的内存都释放之后，就要处理表头list了：

               ·将list的size置零

               ·释放list的内存

               ·将list置NULL

//释放链表内存
void FreeSpace_LinkList(LinkList* list){
	if(list==NULL){
		return ; 
	} 
	LinkNode* pCurrent = list->head;
	while(pCurrent!=NULL){
		LinkNode* pNext =  pCurrent->next;
		free(pCurrent); 
		pCurrent = pNext; 
	} 

	//释放表头内存
	list->size = 0;
	free(list); 
	list = NULL;
}

 

 

下面是完整的代码

#include<stdio.h>
#include<stdlib.h> 
#include<string.h>

//链表节点
typedef struct LINKNODE{
	void* data; //无类型指针，可以指向任何类型数据 
	struct  LINKNODE* next; 
}LinkNode; 

//链表结构体
typedef struct LINKLIST{
	LinkNode* head;
	int size; 
}LinkList; 

typedef struct PERSON{
	char name[64];
	int age; 
	int score; 
}Person; 

//打印函数指针 
typedef void(*PRINTLINKNODE)(void*); 

//初始化链表
LinkList* Init_LinkList();
//指定位置插入
void Insert_LinkList(LinkList* list,int pos,void* data);
//删除指定位置的值
void RemoveByPos_LinkList(LinkList* list,int pos); 
//获得链表长度
int Size_LinkList(LinkList* list); 
//查找
int Find_LinkList(LinkList* list,void* data); 
//返回第一个节点
void* Front_LinkList(LinkList* list); 
//打印链表节点 
void Print_LinkList(LinkList* list,PRINTLINKNODE print); 
//释放链表内存
void FreeSpace_LinkList(LinkList* list); 

/********************************************************************/ 

//初始化链表
LinkList* Init_LinkList(){
	//创建表头 LinkList
	LinkList* list = (LinkList*)malloc(sizeof(LinkList));
	list->size = 0;
	
	//创建头结点 LinkNode(Head) 不保存数据信息
	list->head = (LinkNode*)malloc(sizeof(LinkNode)); 
	list->head->data = NULL;
	list->head->next = NULL; 
	
	return list; 
	 
} 
//指定位置插入
void Insert_LinkList(LinkList* list,int pos,void* data){
	if(list==NULL){
		return ; 
	} 
	if(data==NULL){
		return ; 
	}  
	if(pos<0 || pos>list->size){
		pos = list->size; 
	} 
	
	//创建新的节点 LinkNode
	LinkNode* NewNode = (LinkNode*)malloc(sizeof(LinkNode));
	NewNode->data = data;
	NewNode->next = NULL;
	
	//找节点  辅助指针变量
	LinkNode* pCurrent = list->head;
	for(int i= 0;i<pos;i++){
		pCurrent = pCurrent->next; 
	} 
	//新节点入链表
	NewNode->next = pCurrent->next;
	pCurrent->next = NewNode; 
	 
	list->size++; 
}
//删除指定位置的值
void RemoveByPos_LinkList(LinkList* list,int pos){
	if(list==NULL){
		return ; 
	}  
	if(pos<0 || pos>=list->size){
		pos = list->size; 
	}
	
	//查找删除节点的前一个节点
	LinkNode* pCurrent = list->head;
	for(int i= 0;i<pos;i++){
		pCurrent = pCurrent->next; 
	} 
	LinkNode* pDel =  pCurrent->next;
	pCurrent->next =  pDel->next; 
	//释放删除节点的内存
	free(pDel);
	list->size--; 
} 
//获得链表长度
int Size_LinkList(LinkList* list){
	
	return list->size; 
} 
//查找
int Find_LinkList(LinkList* list,void* data){
	if(list==NULL){
		return -1; 
	} 
	if(data==NULL){
		return -1; 
	}  
	LinkNode* pCurrent = list->head->next;
	int i; 
	for(i= 0;i<=list->size;i++){
		if(pCurrent->data==data){
			break; 
		} 
		pCurrent = pCurrent->next; 
	}  
	
	return i; 
} 
//返回第一个节点
void* Front_LinkList(LinkList* list){
	return list->head->next->data; 
} 
//打印链表节点 
void Print_LinkList(LinkList* list,PRINTLINKNODE print){
	if(list==NULL){
		return ; 
	} 
	LinkNode* pCurrent = list->head->next;
	for(int i= 0;i<list->size;i++){
		print(pCurrent->data); 
		pCurrent = pCurrent->next; 
	}  
} 
//释放链表内存
void FreeSpace_LinkList(LinkList* list){
	if(list==NULL){
		return ; 
	} 
	LinkNode* pCurrent = list->head;
	while(pCurrent!=NULL){
		LinkNode* pNext =  pCurrent->next;
		free(pCurrent); 
		pCurrent = pNext; 
	} 

	//释放表头内存
	list->size = 0;
	free(list); 
	list = NULL;
} 
void MyPrint(void* data){
	Person* p =(Person*)data; 
	printf("Name:%s Age:%d Score%d \n",p->name,p->age,p->score); 
} 

/********************************************************************/ 
/********************************************************************/ 

void test01(){
	//创建链表
	LinkList* list =  Init_LinkList();
	
	//创建数据 
	Person p1 = {"a",16,100};
	Person p2 = {"b",17,101};
	Person p3 = {"c",18,102};
	Person p4 = {"d",19,103};
	Person p5 = {"e",20,104};
	
	//数据插入链表
	 Insert_LinkList(list,0,&p1); 
	 Insert_LinkList(list,1,&p2); 
	 Insert_LinkList(list,2,&p3); 
	 Insert_LinkList(list,3,&p4); 
	 Insert_LinkList(list,4,&p5); 
	 
	 //打印
	 Print_LinkList(list,MyPrint); 
	 printf("------------------------\n"); 
	 //删除
	RemoveByPos_LinkList(list,3); 
	//打印
	 Print_LinkList(list,MyPrint);
	 printf("------------------------\n"); 
	 //返回第一个节点
	 Person* ret = (Person*) Front_LinkList(list); 
	 printf("Name:%s Age:%d Score%d \n",ret->name,ret->age,ret->score); 
	 //销毁链表 
	 FreeSpace_LinkList(list);  

} 


/********************************************************************/ 
/********************************************************************/ 

int main(){
	test01(); 
	return 0; 
}

 

 

_Peko_
关注
专栏目录
线性表——链表PPT学习教案.pptx
10-01
链表的操作，如插入和删除，通常比顺序存储的线性表更灵活，因为它们主要涉及到节点之间的指针修改，而不需要像顺序表那样移动大量元素。然而，这也意味着链表的访问速度可能较慢，因为必须从头节点开始遍历，寻找...
博智数据结构——单项链表
weixin_40317531的博客
01-06 827
链表由一系列节点组成，每个节点包含两个域（ 指针域和数据域） 包含有个没有任何数据的头节点是方便，其他数据的插入删除，起到标志位的作用。 #ifndef LINKLIST_H #define LINKLIST_H #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; //链表节点 typedef struct LINKNODE { voi...
数据结构第二章线性表的2.3：链式存储实现单向链表
weixin_46432435的博客
05-21 319
2.3 线性表的链式存储 2.3.1 基本概念 链式存储定义 为了表示每个数据元素与其直接后继元素之间的逻辑关系，每个元素除了存储本身的信息外，还需要存储指示其直接后继的信息。 单链表 线性表的链式存储结构中，每个结点中包含一个指针域，这样的链表叫单链表。 通过每个结点的指针域将线性表的数据元素按其逻辑次序连接起来（如图） 概念解释： 表头结点： 链表中的第一个结点，包含指向第一个数据元素的指针以及链表自身的一下信息 .
c语言实现单链表（带头结点）-可针对任意数据类型
hou19975418的博客
01-14 546
带头结点单链表的c语言实现，这里给出的接口比较少，功能比较简单，主要的知识点是typedef定义结构体类型后的指针定义（刚开始没想明白）、void*类型可以存储任意数据类型的指针、设置统一的接口（参数包含函数指针）并且给不同数据类型编写各自的打印函数来打印数据。我对于查找元素返回位置的逻辑进行了一点补充。所以这一点局限性比较大。
Day 62 数据结构（单向链表，单向循环链表，双向链表）
AppreciateIt的博客
11-08 514
数据结构（单向链表，单向循环链表，双向链表）
【数据结构】双向链表
像雾像雨又像风_的博客
08-19 289
1.LinkedList.h #ifndef LINKED_LIST_H #define LINKED_LIST_H #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; #include &lt;string.h&gt; //首先定义一个链表节点结构体 typedef struct LINKNODE{ void* data;//表示节点中存储...
线性表——链表的一般功能展示
10-28
### 线性表——链表的一般功能展示 #### 概述 本文档通过具体的C语言代码示例，向初学者介绍了链表这一数据结构的基础操作方法，包括字符的插入与删除、节点的添加与移除等核心功能。这些基本操作是理解和使用链表...
线性表——顺序表PPT学习教案.pptx
10-04
线性表——顺序表PPT学习教案 线性表是一种典型的线性结构，其基本特点是线性表中的数据元素是有序且是有限的。线性表可以分为顺序表和链表两种存储结构，今天我们主要讨论顺序表。 1. 线性表的定义 线性表是具有...
线性表的链式存储——链表（带源码）
05-27
线性表是计算机科学中一种基础的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。在实际应用中，线性表的元素可以是整型、字符型或其他复杂的数据类型。线性表有两种常见的存储方式：顺序存储和链式存储。...
算法和数据结构——链表.pdf
08-07
在标题《算法和数据结构——链表.pdf》中提到的“算法”指的是对数据的处理过程和步骤，而“数据结构”是指数据在计算机中的组织方式，二者在计算机科学中是基础且核心的概念。在数据结构的学习中，链表是实现算法的...
链表----单链表
abaidaye的博客
10-22 269
3.1.单链表 链表属于线性结构的链式储存结构，是一种有序的列表。它的储存如图所示： 链表的数据的内存地址不一定是连续的。 链表是以节点的形式存储的 链表可能有头节点和无头节点的 3.1.1.思路分析 3.1.2.代码实现 3.1.2.1.按照插入顺序添加（只写了遍历） 这种哪个先添加哪个就排在前面 package LinkDlist; public class sigelLinkNode { private int no; public String name; publi
【数据结构】单链表
debug...
08-13 381
数据结构单链表实现原理
线性表（5）——单链表框架搭建
程序员的时光
07-26 524
目录 1. LinkList.h头文件（函数声明）； 2.LinkList.c源文件（函数实现）； 3.源文件main.c（包括主函数）； 先看看项目文件： 总共3个文件， LinkList.h 是头文件，包含各种函数的定义； LinkList.c 是源文件，包含各种函数的具体功能实现，以及调用； main.c 是主函数文件，包含主函数； 1. LinkList...
16-链表的基本运算的改进
网络安全
05-31 361
在定义链表的存储结构类型时，我们要为链表和链表的节点单独定义数据类型 定义链表节点存储结构：  2.1 定义数据域，要求是存储任意类型的数据，因此可以把数据域定义为void 指针类型(void 是一个万能指针类型，可以指向任何数据类型)  2.2 定义指针域，指针域一般用于指向节点，所以指针域一般定义为 定义链表存储结构：  3.1 定义头结点，头结点一般是不存储数据  3.2 定义链表...
C++学习笔记-数据结构-单链表的实现
qq_19813681的博客
04-20 242
这是学习C++的数据结构的第一个笔记，留着自己今后忘了的时候再看看吧 #include <iostream> using namespace std; // 定义一个打印回调指针，由使用者实现 typedef void(*PRINTLINKLIST)(void*); // 链表节点 typedef struct LINKNODE { void* data; //指向...
数据结构之_单链表加强版企业链表的实现
weixin_30477797的博客
07-18 234
数据结构之_单链表加强版企业链表的实现 1.传统链表参见博文 https://www.cnblogs.com/wanghui1234/p/11196467.html 2.原理图 3.企业链表/通用链表(单向链表)案例代码 LinkList.h #ifndef LINKLIST_H #define LINKLIST_H #include<stdlib.h&...
线性表的链式存储
I_O_fly的博客
03-14 291
# ifndef LINKLIST_H# define LINKLIST_H# include &lt;stdio.h&gt;# include &lt;stdlib.h&gt;//链表结点typedef struct LINKNODE{ //可以放任何数据就是无类型数组,指向任何类型数据 void* data; struct LINKNODE* next;}LinkNode;//链表结构体typ...
如何理解typedef void (*pfun)(void)
liu19891226的博客
06-06 9476
问题：      在刚接触typedef void (*pfun)(void) 这个结构的时候，存在疑惑，为什么typedef后只有一“块”东西，而不是两“块”东西呢？那是谁“替代”了谁啊？我总结了一下，一方面是对typedef的概念不清晰，另一方面受了#define的影响，犯了定向思维的错误。 概念理解：typedef 只对已有的类型进行别名定义，不产生新的类型；#define 只是在预处理过程...
对typedef的真正理解
疙瘩的专栏
03-16 7837
本人学C++也有三年了，还是对typedef不太熟，今天终于弄清楚了，所以发表此帖，希望对不太清楚的朋友能有所帮助。首先请看看下面这两句：typedef int a[10];typedef void (*p)(void);如果你能一眼就看出它们的意思，那请不要再往下看了。如果你不太理解，或概念还有些模糊，请继续往下看吧。下面的东西我就直接把人家的东西粘上去吧。自己敲太慢了。呵呵。原文（摘录）：ty
高级线性表——静态链表
最新发布
05-19
静态链表是一种使用数组来实现链表的数据结构。它的本质是利用数组来描述链表中结点之间的关系，数组中的每个元素存储着链表中一个结点的数据和指向下一个结点的指针，而指针则用数组下标来表示。 静态链表的实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值