02-普通链表、企业链表

最新推荐文章于 2024-01-18 16:13:06 发布
最新推荐文章于 2024-01-18 16:13:06 发布
阅读量336 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43788522/article/details/107307578
版权

链表的两种实现方式

一、普通链表的实现

普通链表也就是我门平常上数据结构所写的一样。

（1）头文件
#ifndef LINKLIST
#define LINKLIST

//链表结点
typedef struct LINKNODE{
	void* data;//指向任何类型数据
	struct LINKNODE* next;
}LinkNode;

//打印函数指针(因为链表结点是void* 形指针，所以我们用一个回调函数，让用户自己去写这个回调函数进行数据的输出)
typedef void(*PRINTLINKNODE)(void*);

//链表结构体
typedef struct LINKLIST{
	LinkNode* head;
	int size;//需要容量吗？链表是没有容量的概念的
}LinkList;

//初始化链表
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 Print_LinkList(LinkList* list, PRINTLINKNODE print);
//返回第一个结点
LinkNode* Front_LinkList(LinkList* list);
//释放链表内存
void FreeSpace_LinkList(LinkList* list);

#endif
（2）函数的实现
#include<stdlib.h>
#include"LinkLIst.h"

//创建链表
LinkList* Init_LinkList(){
	LinkList* list = (LinkList*)malloc(sizeof(LinkList));
	//头结点是不保存数据信息的
	list->head = (LinkNode*)malloc(sizeof(LinkNode));
	list->head->next = NULL;
	list->head->data = NULL;
	list->size = 0;
	return list;
}
//指定位置插入
void Insert_LinkList(LinkList* list, int pos, void* data){
	if (list == NULL){
		return;
	}
	//友好的处理pose越界
	if (pos > list->size|| pos<0){
		pos = list->size;
	}
	//创建赋值指针变量
	LinkNode* pCurrent = list->head;
	for (int i = 0; i < pos; i++){
		pCurrent = pCurrent->next;
	}
	//创建新的结点
	LinkNode* newNode = (LinkNode*)malloc(sizeof(LinkNode));
	newNode->data = data;
	newNode->next = pCurrent->next;
	pCurrent->next = newNode;
	list->size++;
}
//删除指定的位置的值
void RemoveByPos_LinkList(LinkList* list, int pos){
	if (list == NULL){
		return;
	}
	//查找删除结点的前一个结点
	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){
	if (list == NULL){
		return -1;
	}
	return list->size;
}
//查找
int Find_LinkList(LinkList* list,void* data){
	if (list == NULL){
		return -1;
	}
	//记录查找到的位置
	int pos;
	//创建辅助指针变量
	LinkNode* pCurrent = list->head->next;
	for (int i = 0; i < list->size; i++){
		if (pCurrent->data ==data){
			pos = i;
			break;
		}
		pCurrent = pCurrent->next;
	}
	return pos;
}
//打印链表结点
void Print_LinkList(LinkList* list, PRINTLINKNODE print){
	if (list == NULL){
		return;
	}
	//创建赋值指针变量
	LinkNode* pCurrent = list->head->next;
	while (pCurrent != NULL){
		print(pCurrent->data);
		pCurrent = pCurrent->next;
	}
}
//返回第一个结点
LinkNode* Front_LinkList(LinkList* list){
	if (list == NULL){
		return NULL;
	}
	return list->head->next->data;
}
//释放链表内存(这样写是错误的！！！你看如果到了pcurrent等于最后一个节点，则rpcurrent=null进入while循环
//到了rpcurrent=rpCurrent->next这一行时，就报空指针异常了
/*void FreeSpace_LinkList(LinkList* list){
	if (list == NULL){
		return;
	}
	//创建辅助指针变量
	LinkNode* pCureent = list->head;
	//缓存下一个结点
	LinkNode* rpCurrent = list->head->next;
	while (pCureent != NULL){
		free(pCureent);
		pCureent = rpCurrent;
		rpCurrent = rpCurrent->next;
	}
	list->size = 0;
	free(list);
}*/

void FreeSpace_LinkList(LinkList* list){
	if (list == NULL){
		return;
	}
	//创建辅助指针变量
	LinkNode* pCurrent = list->head;
	while (pCurrent != NULL){
		LinkNode* pNext = pCurrent->next;
		free(pCurrent);
		pCurrent = pNext;
	}
}
（3）测试
#include<stdlib.h>
#include<stdio.h>
#include"LinkLIst.h"

//创建打印函数
void myPrint(void * data){
	printf("%s\n", (char*)data);
}
int main(){

	

	//获取链表
	LinkList* list = Init_LinkList();
	//创建一些数据
	char* str1 = "有很多话想对你说 但一直没有机会";
	char* str2 = "我携带这它们穿越季节 掠过高架 铺在山与海之间";
	char* str3 = "花盛开就是一句 夜漫过就是一篇";
	char* str4 = "黄昏开始书写 黎明是无数的扉页";
	char* str5 = "全世界拼成首诗 我爱你当做最后一行";

	//向链表中插入数据
	Insert_LinkList(list, 0,str1);
	Insert_LinkList(list, 1, str2);
	Insert_LinkList(list, 2, str3);
	Insert_LinkList(list, 3, str4);
	Insert_LinkList(list, 4, str5);

	//打印数据
	Print_LinkList(list, myPrint);
	printf("-------------------------------------\n");

	//返回链表的第一个元素
	char* str = (char*)Front_LinkList(list);
	printf("%s\n", str);
	printf("-------------------------------------\n");

	//删除	char* str3 = "花盛开就是一句 夜漫过就是一篇";
	RemoveByPos_LinkList(list, 2);
	Print_LinkList(list, myPrint);
	printf("-------------------------------------\n");

	//获取链表的大小
	printf("%d\n", list->size);
	
	//查找值
	printf("查到str2的位置为%d\n",Find_LinkList(list, str5));
	//释放链表内存
	FreeSpace_LinkList(list);

	system("pause");
}

在这里插入图片描述

二、企业链表的实现

（1）头文件
#ifndef LINKLIST_H
#define LINKLIST_H

//链表小节点
typedef struct LINKNODE
{
	struct LINKNODE* next;
}LinkNode;

//链表结点
typedef struct LINKLIST{
	LinkNode head;
	int size;
}LinkList;

//打印函数
typedef void(*PRINTNODE)(LinkNode*);

//初始化链表
LinkList* Init_LinkList();
//安装顺序插入
void Insert_LinkList(LinkList* list, LinkNode* data);
//按照指定位置进行插入
void InsertByPose_LinkList(LinkList* list, int pose, LinkNode* data);
//删除
void Remove_LinkList(LinkList* list, int pose);
//查找
int Find_LinkList(LinkList* list, LinkNode* data);
//返回链表大小
int Size_LinkList(LinkList* list);
//打印
void Print_LinkList(LinkList* list, PRINTNODE print);
//释放链表内存
void Free_LinkList(LinkList* list);

#endif
（2）函数的实现
#include<stdlib.h>
#include"LinkList.h"
//初始化链表
LinkList* Init_LinkList(){
	LinkList* list = (LinkList*)malloc(sizeof(LinkList));
	list->head.next = NULL;
	list->size = 0;
	return list;
}
//按照顺序插入
void Insert_LinkList(LinkList* list, LinkNode* data){
	if (list == NULL){
		return;
	}
	//创建辅助指针变量
	LinkNode* pCurrent = &(list->head);
	while (pCurrent->next != NULL)
	{
		pCurrent = pCurrent->next;
	}
	pCurrent->next = data;
	data->next = NULL;
	list->size++;
}
//按照指定位置进行插入
void InsertByPose_LinkList(LinkList* list, int pose, LinkNode* data){
	if (list == NULL){
		return;
	}
	//创建辅助指针变量
	LinkNode* pCurrent = &(list->head);
	for (int i = 0; i < pose; i++){
		pCurrent = pCurrent->next;
	}	
	data->next = pCurrent->next;
	pCurrent->next = data;
	list->size++;
}
//删除
void Remove_LinkList(LinkList* list, int pose){
	if (list == NULL){
		return;
	}
	//创建辅助指针变量
	LinkNode* pCurrent = &(list->head);
	for (int i = 0; i < pose; i++){
		pCurrent = pCurrent->next;
	}
	pCurrent->next = pCurrent->next->next;
	list->size--;
}
//查找
int Find_LinkList(LinkList* list, LinkNode* data){
	if (list == NULL){
		return -1;
	}
	//创建辅助指针变量
	int pose=0;
	LinkNode* pCurrent = list->head.next;
	while (pCurrent){
		if (pCurrent == data){
			return pose;
		}
		pose++;
		pCurrent = pCurrent->next;
	}
}
//返回链表大小
int Size_LinkList(LinkList* list){
	if (list == NULL){
		return -1;
	}
	return list->size;
}
//打印
void Print_LinkList(LinkList* list, PRINTNODE print){
	if (list == NULL){
		return;
	}
	//创建辅助指针变量
	LinkNode* pCurrent = list->head.next;
	while (pCurrent){
		print(pCurrent);
		pCurrent = pCurrent->next;
	}
}
//释放链表内存
void Free_LinkList(LinkList* list){
	if (list == NULL){
		return;
	}
	free(list);
}
（3）测试
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"LinkList.h"

typedef struct SCENTENCE {
	LinkNode node;
	char str[64];
}Sctence;

//打印函数
void myPrint(LinkNode* data){
	Sctence* s = (Sctence*)data;
	printf("%s\n", s->str);
}
int main(){

	//获得链表对象
	LinkList* list = Init_LinkList();

	//创建一些数据
	Sctence s1, s2, s3, s4, s5,s6;
	strcpy(s1.str, "有很多话想对你说 但一直没有机会");
	strcpy(s2.str, "我携带这它们穿越季节 掠过高架 铺在山与海之间");
	strcpy(s3.str, "花盛开就是一句 夜漫过就是一篇");
	strcpy(s4.str, "黄昏开始书写 黎明是无数的扉页");
	strcpy(s5.str, "全世界拼成首诗 我爱你当做最后一行");
	strcpy(s6.str, "你归来是诗 离去成词 且笑风尘不敢造次");

	//插入数据到链表
	Insert_LinkList(list,(LinkNode*)&s1);
	Insert_LinkList(list, (LinkNode*)&s2);
	Insert_LinkList(list, (LinkNode*)&s3);
	Insert_LinkList(list, (LinkNode*)&s4);
	Insert_LinkList(list, (LinkNode*)&s5);

	InsertByPose_LinkList(list, 3, (LinkNode*)&s6);

	//InsertByPose_LinkList(list, 0,(LinkNode*)&s1);

	//删除某个元素
	Remove_LinkList(list, 3);

	//打印
	Print_LinkList(list, myPrint);

	//查找某个元素
	int pose = Find_LinkList(list, (LinkNode*)&s3);
	printf("查找到的位置为%d\n", pose);

	//返回链表的大小
	int size = Size_LinkList(list);
	printf("链表的长度为:%d\n", size);
	//释放内存
	Free_LinkList(list);
	system("pause");
	return 0;
}

在这里插入图片描述

安慕希ai
关注
专栏目录
普通链表和循环链表的逆置
01-06
首先是普通链表： template void LinkList::Reverse() { Node* p; Node* q; p = first->next; first->next = NULL; while (p) { q = p; p = p->next; q->next = first->next;//前驱变后继 first->next...
C++之内核链表和企业链表
suren_jun的博客
10-13 563
作为数据结构中的基础结构之一，链表的优点就是可以不要求连续的存储空间，但是没有了随机访问，在按索引增删改查，似乎效率没有数组快，但是链表也有它优势的地方，linux内核和企业上，对于链表的时候，和我们一般学的方法有所不同，这里详细讲解一下。废话说到这里，开始上干货。
【线性表——企业链表】
piano_diano的博客
12-01 188
企业链表 企业链表与普通的链表的区别是，后者的结点包含数据域和指针域，而前者只有指针域。 因为指针的灵活性，只要将指针强转为任意一种数据结构的指针，便能拥有想要的数据元素。 例如: 以下是两种不同的数据结构 typedef struct LINKNODE{ struct LINKNODE* next; }LinkNode; typedef struct PERSON{ char*...
企业链表
Mr_Csyn的博客
12-04 314
企业链表 企业链表其实也就是传统链表的改进版本 链表结点有数据域和指针域 指针域是一个结构体，结构体有一个next指针，可以把结点关联起来 typedef struct LINKNODE { struct LINKNODE* next; }LinkNode; typedef struct MyData { LinkNode node; char name[64]; int age; }Mydata; 传统链表 跟企业链表相比，传统链表同样是一个数据域一个指针域 链表结构体包含的是链表信息,
数据结构 (四) 线性表_企业链表
Fioman_GYM的博客
04-22 570
文章目录一. 企业链表概述① 企业链表简介 一. 企业链表概述 ① 企业链表简介 企业链表出现的原因: 我们在写传统的链表的时候,节点里面存放的有数据,如果数据的类型固定死了,再我们需要另外一种数据类型的时候,就需要重新写一个链表. 我们也可以使用void*万能指针不固定死数据类型,当然我们还有另外一种实现方式,就是使用企业链表,链表的node里面不存放具体的业务数据类型,这样我们的链表就不受业务数据的限制. 企业链表如何实现 业务数据分离出来,也就是说链表中的节点只保存指针域. 你定义的数据一般
C++数据结构X篇_05_企业链表的思路和实现（企业链表是企业中经常使用的一种链表；企业链表p_next仅仅指向下一个p_next的地址，链表中并未涉及任何data数据）
分享学习成长历程，Winter is coming！
06-25 164
/链表指针节点节点 class node_p {public ://链表 class list {public :int size;//初始化链表 list * list_init() {return L;//自定义链表数据节点 class my_data {public :int num;当我们创建my_data的对象指针p1，将其强转成node_p的对象指针a1，a1->next=p1->p_data（具体原理见。
cpp代码-循环链表的算法
07-14
循环链表是一种特殊的链式数据结构，它与普通链表的主要区别在于最后一个节点指向了第一个节点，形成一个环形的连接。在C++编程中，循环链表常用于实现各种算法，例如遍历、搜索、排序等。在这个“cpp代码-循环链表...
数据结构5.9二叉树的链式存储-三叉链表
11-19
2. **特点**：与普通二叉链表相比，三叉链表的优点在于可以更方便地访问节点的父节点，从而提高了某些操作的效率，例如查找某个节点的祖先节点或遍历整棵树等。 #### 三、三叉链表的表示方法 下面通过一个具体的...
第10课-循环链表.rar
04-23
循环链表与普通链表的主要区别在于其最后一个节点的指针并不为空，而是指向链表的第一个节点，形成了一个闭合的环状结构。这种设计使得遍历链表更加方便，因为从任何一个节点开始都可以继续遍历整个链表。 首先，...
企业链表List
宝安小雨
07-10 288
常用的容器包括vector, list, deque, queue, stack, map等，这些容器都是用基本的数据结构实现的。vector是用动态数组实现的；list是用双向循环链表实现的；deque有些特别，他是用一个个缓冲器组成的，把这些缓冲区的头指针放在数组中，使得使用者用迭代器+1就可以不停地遍历下一个元素，给使用者造成queue是顺序存储的假象，而这正是stl想要的，因为使用者不必去关心它复杂的实现过程；deque头尾都可插入弹出， queue, stack的实现是直接调用部分deque的接口
顺序链表在企业开发中的应用
07-14
学习c++的数据结构，总是不清楚学习的链表要如何才能应用到企业开发中，这里上传了完整的代码 并做了详细的注释
各大企业校招笔试中频繁出现的链表题
10-17
本资源收集了 自己亲身经历的 各大企业笔试中遇到的链表题目，也是企业常常考查的链表题，对正在找工作的同学有很大的帮助。
企业级的使用链表
永远积极向上、永远热泪盈眶、永远豪情满怀、永远坦坦荡荡
09-05 1657
一，企业级链表的设计数据结构的设计//链接链表的指针 struct LinedNode { struct LinedNode* next; } LinedNode;//保存链表的信息 struct LList { struct LinedNode toppoter; int m_size; }LList;typedef void* ListNode; 1,链表的初始化List
企业链表原理C语言实现
最新发布
weixin_42250342的博客
01-18 369
这两个结构体均不包含具体的用户数据层面的操作，用户的数据类型需要单独定义，在链表的函数里面是没办法直接访问用户的数据的，需要借助预留的函数指针接口，定义用户自己的打印函数和比较函数（关于数据值操作的函数）。该结构数据将数据层面和数据链层面完全分开，数据层面进入数据链层需要进行强制类型转换，借助指针指向结构体的首地址这一原理。定义两个数据结构：链表结构和节点结构。企业链表是内核链表和传统链表的改进版本。要对指针的原理了解比较清楚，理解稍微复杂。空间开销更小，和用户数据剥离更加彻底。
数据结构 普通链表、企业链表和循环链表
CodeHouse的博客
09-18 213
//普通有头结点链表 #include <stdio.h> #include <stdlib.h> #include <string.h> //有头结点的单向链表 typedef struct MyNode{ int num; struct MyNode *next; }STNode_def; #define NODE_SIZE sizeof(STNode_def) #define SUCCESS 0 #define FAILURE -1 //链表
数据结构：静态链表、企业链表实现及使用
Rain的博客
02-28 333
文章目录一、静态链表二、循环链表三、双向链表四、企业链表 一、静态链表 二、循环链表 三、双向链表 四、企业链表 企业链表：如果我们使用原始的C语言写链表的话，数据类型是被固定死的，如果业务换了，需要另一种数据类型，我们又得重新在写一个链表，十分麻烦！因此为了方便使用，我们引出了企业链表。 作用：将实际的数据类型和链表相分离，实现实际的数据类型和链表的解耦。 那么什么是企业链表呢？我们之前学的单链...
C++企业链表
qq_41973378的博客
07-18 397
C++企业链表 开发工具与关键技术：C++、VisualStudio 作者：何任贤 撰写时间：2019年07月10日 所谓的企业链表其实只是因为企业经常用到，所以叫企业链表，它相当于linux内核链表的升级版， 那么这两种链表和传统链表有什么区别，它们和传统链表的区别就在于它们的指针域， 也就链表节点中的next指针，至于区别在哪里呢？ 就是传统链表的指针域在linux内核链表和企业链表...
企业级链表
jingshen9992的博客
03-22 475
自我总结：企业级链表就是相当于给自定义结构体（数据），加上“挂钩“（指针） #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Linknode{ struct Linknode *next; }Linknode; typedef struct Linklist{ struct Linknode header; int m_size; }Linklist; //链表初
数据结构-循环链表详解与应用
1. **判断空链表**：在普通单链表中，通常通过头指针是否为空来判断链表是否为空。而在循环链表中，判断空链表的方法是head->next==head。如果头节点的next指针指向自身，则链表为空。 2. **判断表尾结点**：在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值