单向链表（C语言实现）

最新推荐文章于 2023-05-03 10:44:33 发布
最新推荐文章于 2023-05-03 10:44:33 发布
阅读量149 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46544158/article/details/120815592
版权 
/*
* 单向链表传统版本
*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>


//节点结构体
struct LinkNode
{
	//数据域
	void * data;
	//指针域
	struct LinkNode* next;
};

//链表结构体
struct LList 
{ 
	//头结点
	struct LinkNode pHeader;

	//链表长度
	int m_Size;
};

//通过void* 隐藏结构体中属性，防止用户更改
typedef void* LinkList;

//初始化链表
LinkList init_LinkList()
{
	//分配内存
	struct LList * mylist = (LList*)malloc(sizeof(struct LList));

	if (mylist == NULL) {
		return NULL;
	}

	//给头结点初始化
	//mylist->pHeader.data =(void*) -1;
	mylist->pHeader.next = NULL;
	mylist->m_Size = 0;

	return mylist;
}


//插入节点
void insert_LinkList(LinkList list, int pos, void* data)
{
	if (list == NULL) 
	{
		return;
	}
	if (data == NULL) 
	{
		return;
	}

	struct LList* mylist = (LList*)list;
	if (pos<0 || pos>mylist->m_Size) 
	{
		//无效位置
		pos = mylist->m_Size;
	}

	//创建临时节点 通过循环找到待插入位置的前驱节点位置
	struct LinkNode* pCurrent = &mylist->pHeader;

	for (int i = 0; i < pos; i++) 
	{
		pCurrent = pCurrent->next;
	}

	//此时 pCurrent就是插入位置的前驱节点

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

	//建立节点之间的关系
	newNode->next = pCurrent->next;
	pCurrent->next = newNode;

	//更新链表长度
	mylist->m_Size++;

}

//遍历链表
void foreach_LinkList(LinkList list,void(*myPrint)(void*))
{
	if (list == NULL) 
	{
		return;
	}

	//还原链表真实结构体
	struct LList* mylist = (LList*)list;
	struct LinkNode* pCurrent = mylist->pHeader.next;
	for (int i = 0; i < mylist->m_Size; i++)
	{
		myPrint(pCurrent->data);
		pCurrent = pCurrent->next;
	}
}

//删除链表节点，按位置删除
void removeByPos_LinkList(LinkList list, int pos)
{
	if (list == NULL)
	{
		return;
	}
	struct LList* mylist = (LList*)list;
	if (pos<0 || pos>mylist->m_Size - 1)
	{
		//无效位置
		return;
	}

	//找到待删除位置的前驱节点位置
	struct LinkNode* pCurrent = &mylist->pHeader;

	for (int i = 0; i < pos; i++)
	{
		pCurrent = pCurrent->next;
	}

	//pCurrent就是待删除节点的前驱节点位置

	//利用指针记录待删除节点
	struct LinkNode* pDel = pCurrent->next;

	//更改指针的指向
	pCurrent->next = pDel->next;
	//释放待删除节点
	free(pDel);
	pDel = NULL;

	//更新链表长度
	mylist->m_Size--;
}

//删除链表节点，按值删除
void removeByValue_LinkList(LinkList list,void* data,int(myCompare(void*,void*))) 
{
	if (list == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}

	//将list还原真实链表结构体
	struct LList* mylist = (LList*)list;

	//创建两个辅助指针变量
	struct LinkNode* pPrev = &mylist->pHeader;
	struct LinkNode* pCurrent = mylist->pHeader.next;

	//遍历链表 找用户要删的数据
	for (int i = 0; i < mylist->m_Size; i++)
	{
		//if (data == pCurrent->data)
		if(myCompare(data,pCurrent->data))
		{
			//找到要删除的数据，开始删除
			//更改指针指向 
			pPrev->next=pCurrent->next;

			free(pCurrent);
			pCurrent = NULL;

			mylist->m_Size--;

			break;
		}

		//辅助指针向后移动
		pPrev = pCurrent;
		pCurrent = pCurrent->next;
	}

}

//返回链表长度
int size_LinkList(LinkList list)
{
	if (list == NULL)
	{
		return -1;
	 }

	//将list还原真实链表结构体
	struct LList* mylist = (LList*)list;

	return mylist->m_Size;

}

//清空链表
void clear_LinkList(LinkList list)
{
	if (list == NULL)
	{
		return;
	}

	//将list还原真实链表结构体
	struct LList* mylist = (LList*)list;

	struct LinkNode* pCurrent = mylist->pHeader.next;

	for (int i = 0; i < mylist->m_Size; i++) 
	{
		//记录下一个节点的位置
		struct LinkNode* pNext = pCurrent->next;
		free(pCurrent);
		pCurrent = pNext;
	}

	mylist->pHeader.next = NULL;
	mylist->m_Size = 0;
}

//销毁链表
void destory_LinkList(LinkList list)
{
	if (list == NULL) 
	{
		return;
	}

	//先清空链表，再销毁头结点
	clear_LinkList(list);

	free(list);


}

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

//回调函数打印
void printPerson(void* data)
{
	struct Person* person = (Person*)data;
	printf("姓名： %s 年龄：%d\n", person->name, person->age);
}

//回调函数删除
int ComparePerson(void* data1, void* data2)
{
	struct Person* p1 = (Person*)data1;
	struct Person* p2 = (Person*)data2;

	return strcmp(p1->name,p2->name)==0&&p1->age==p2->age;
}

//测试链表
void test01() 
{
	//初始化链表
	LinkList mylist = init_LinkList();

	struct Person p1 = { "赵云",18 };
	struct Person p2 = { "张飞",19 };
	struct Person p3 = { "关羽",20 };
	struct Person p4 = { "刘备",19 };
	struct Person p5 = { "诸葛亮",22 };
	struct Person p6 = { "黄忠",17 };

	insert_LinkList(mylist, 0, &p1);
	insert_LinkList(mylist, 0, &p2);
	insert_LinkList(mylist, 1, &p3);
	insert_LinkList(mylist, -1, &p4);
	insert_LinkList(mylist, 1, &p5);
	insert_LinkList(mylist, 100, &p6);

	//遍历链表
	foreach_LinkList(mylist, printPerson);
	printf("链表长度为：%d\n", size_LinkList(mylist));

	printf("------------------------------");
	printf("删除刘备之后的遍历结果：\n");
	removeByPos_LinkList(mylist, 4);
	foreach_LinkList(mylist,printPerson);
	printf("链表长度为：%d\n", size_LinkList(mylist));

	printf("------------------------------");
	printf("删除关羽之后的遍历结果：\n");
	struct Person p = { "关羽",20 };
	removeByValue_LinkList(mylist, &p, ComparePerson);
	foreach_LinkList(mylist, printPerson);
	printf("链表长度为：%d\n", size_LinkList(mylist));
	 
	//清空链表
	printf("------------------------------");
	printf("清空链表之后遍历结果：\n");
	clear_LinkList(mylist);
	foreach_LinkList(mylist, printPerson);
	printf("链表长度为：%d\n", size_LinkList(mylist));

	//销毁链表
	destory_LinkList(mylist);
	mylist = NULL;

}


int main() {

	test01();


	system("pause");
	return 0;
}

企业版本：

/*单向链表企业版本：自定义数据类型*/

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


//节点结构体设计
struct LinkNode
{
	//只维护指针域
	struct LinkNode* next;
};

struct LList 
{
	struct LinkNode pHeader;	//头结点
	int m_Size;		//链表长度
};

typedef void* LinkList;

//初始化链表
LinkList init_LinkList()
{
	struct LList * mylist = (LList*)malloc(sizeof(struct LList));

	if (mylist == NULL)
	{
		return NULL;
	}

	mylist->m_Size = 0;
	mylist->pHeader.next = NULL;

	return mylist;
}

//插入链表
void insert_LinkList(LinkList list, int pos, void* data)
{
	if (list == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}

	struct LList* mylist = (LList*)list;

	if (pos<0 || pos>mylist->m_Size - 1)
	{
		pos = mylist->m_Size;
	}

	//取出用户数据的前4个空间
	struct LinkNode* myNode = (LinkNode*)data;

	//找到待插入位置的前驱节点
	struct LinkNode* pCurrent = &mylist->pHeader;

	for (int i = 0; i < pos; i++)
	{
		pCurrent = pCurrent->next;
	}

	//更改指针指向
	myNode->next = pCurrent->next;
	pCurrent->next = myNode;

	//更新链表的长度
	mylist->m_Size++;
}

//遍历
void foreach_LinkList(LinkList list,void (myPrint(void *)))
{
	if (list == NULL) 
	{
		return;
	}

	struct LList* mylist = (LList*)list;

	struct LinkNode* pCurrent = mylist->pHeader.next;

	for (int i = 0; i < mylist->m_Size; i++)
	{
		//pCurrent就是用户数据的首地址
		myPrint(pCurrent);
		pCurrent = pCurrent->next;
	}
}

//删除  按位置
void removeByPos_LinkList(LinkList list, int pos)
{
	if (list == NULL)
	{
		return;
	}

	struct LList* mylist = (LList*)list;

	if (pos<0 || pos>mylist->m_Size - 1)
	{
		return;
	}

	//找到待删除前驱节点位置
	struct LinkNode* pCurrent = &mylist->pHeader;

	for (int i = 0; i < pos; i++)
	{
		pCurrent = pCurrent->next;
	}

	//记录待删除节点位置
	struct LinkNode* pDel = pCurrent->next;

	//重新建立节点之间的关系
	pCurrent->next = pDel->next;

	//链表长度更新
	mylist->m_Size--;

}

//销毁链表
void destory_LinkList(LinkList list)
{
	if (list == NULL)
	{
		return;
	}

	free(list);
	list = NULL;
}

struct Person
{
	struct LinkNode node;
	char name[64];
	int age;
};

void printPerson(void* data)
{
	struct Person* person = (Person*)data;
	printf("姓名：%s 年龄：%d\n", person->name, person->age);
}

//测试链表
void test01()
{
	//初始化链表
	LinkList mylist = init_LinkList();

	//创建数据
	struct Person p1 = { NULL,"aaa",11 };
	struct Person p2 = { NULL,"bbb",22 };
	struct Person p3 = { NULL,"ccc",33 };
	struct Person p4 = { NULL,"ddd",44 };
	struct Person p5 = { NULL,"eee",55 };

	//插入数据
	insert_LinkList(mylist, 0, &p1);
	insert_LinkList(mylist, 0, &p2);
	insert_LinkList(mylist, 1, &p3);
	insert_LinkList(mylist, -1, &p4);
	insert_LinkList(mylist, 0, &p5);

	//遍历链表
	foreach_LinkList(mylist, printPerson);

	//删除bbb的数据
	removeByPos_LinkList(mylist, 1);
	printf("----------\n");
	foreach_LinkList(mylist, printPerson);

	//销毁链表
	destory_LinkList(mylist);
	printf("----------\n");
	foreach_LinkList(mylist, printPerson);



}




int main()
{
	test01();

	system("pause");
	return EXIT_SUCCESS;
}
迎风微笑的代码仔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言单向链表实现
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-26 257
// // main.c // C语言单项链表 // // Created by Pakho on 2017/5/16. // Copyright © 2017年 Pakho. All rights reserved. // #include <stdio.h> #include <stdlib.h> // malloc 可以开辟指定大小的内存空间 #include...
单向链表-C语言实现
To Be A Linux Graphics Coder
06-20 822
只实现了几个简单的操作。在Linux内核中链表的使用非常多，不过使用方法与本例完全不一样。后续有时间再详述。 ChainNode.c#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #define MAX_DATA_LEN 128 #define CN_TRUE 0 #define CN_...
C语言单向链表的实现
热门推荐
无界编程
10-30 5万+
一个简单结点的结构体表示为：    struct note    {       int  data；              /*数据成员可以是多个不同类型的数据*/       struct  note  *next；      /*指针变量成员只能是-个*/    }；  一个简单的单向链表的图示 1．链表是结构、指针相结合的-种应用,它是由头、中间、尾多个链环组成的单方向可伸缩的链表,链
单向链表实现（C语言）
li
06-11 1407
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 ...
C语言实现单向链表
Jeson_的博客
01-14 268
单向链表 注意： 1.头结点的指针域指向链表第一个节点，数据域不使用 单链表最后一个节点的指针域必须设置为NULL C语言实现 创建空链表 linklist_t create_emptylist() { //分配头节点空间 linklist_t head = (linklist_t)malloc(sizeof(linknode_t)); if(head) ...
C语言实现单向链表及操作
03-24
数据结构，c语言实现的单向链表。代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode;
单向链表的C语言实现
11-07
C语言指针实现单向链表 初学者看，非常简单。 时间非常多的功能不同位置的插入、删除、查找；
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
单向链表c语言实现数据结构
09-18
用c语言实现单向链表的数据结构，可以在编译器里直接使用的
单向链表在C语言上的实现
go_sann
05-30 2500
作为几乎是初学C语言的人，在指针的问题还没有完全搞明白的时候，就看到了数据结构里面链表这样一个庞然大物，完全不懂的怎么操作。在阅读了多方资料后，终于根据自己的理解，写出了第一个单向链表程序，放在此处与大家分享，也让自己在复习的时候可以再回顾一下。程序实现了链表的创建、添加单个元素、删除单个元素的功能；对象为单个int型，即程序中的data。因为都是用的函数，所以如果要添加其他的操作，只需要写另外的...
链表C语言实现--单向链表
qq_48639334的博客
08-01 3385
链表C语言实现--单向链表
单向链表的实现（带头结点）-c语言
better_xiong的博客
06-15 1481
1.带头结点的单向链表的结构 head指针始终指向头结点，head->data不放元素。当head->next==NULL时，链表为空表，不为空表时，head->next指向首结点，即head->next=a1。 2.单向链表带头结点和不带头结点的区别 区别主要有两个方面： （1）使用头结点后在链表中第一个结点位置插入和删除操作更加方便。 （2）使用头结点后，对于空链表和非空链表的操作是一样的。如果不使用头结点，当链表非空时，头指针指向第一个结点的地址，如果是空链表，头指针为NUL
c语言简单单向链表,【C语言】单向链表的简单实现
weixin_30349485的博客
05-21 223
1、实现的主要函数：/*初始化链表：参数：int _value(第一个节点的值)返回值：list(链表的头节点)*/list listInit(int _value);/*遍历链表参数：list _list(链表名字)返回值：无*/void listPrintAll(list _list);/*添加节点到结尾参数：list *_listPtr(需要添加节点的链表的指针)int _value(需要添...
C语言——单向链表
DDsoup 24小时不打烊芜湖！
11-02 695
链表的概念：链表是一种动态存储分布的数据结构，由若干个同一结构类型的结点依次串连而成。 链表分为单向链表和双向链表。 链表变量一般用指针head表示，用来存放链表首结点的地址。 每个结点由数据部分和下一个结点的地址部分组成，即每个结点都指向下一个结点。最后一个结点称为表尾，其下一个结点的地址部分的值为NULL（表示为空地址）。 特别注意：链表中的各个结点在内存中是可以不连续存放的，具体存放位置由系统分配。 例如：int...
单链表的c语言,单链表（C语言）(示例代码)
weixin_39974557的博客
05-19 111
单链表：单向无循环，最后置于空//SeqList.h#pragmaonce#include#include#include#defineMAX_SIZE100typedefintDataType;typedefstructSeqlist{DataType*_array;size_t_size;size_t_capacity;}Seqlist;voidInitSeqlist(S...
【数据结构】超详细之单向链表（C语言实现）
m0_74088266的博客
05-03 997
今天我要介绍单向链表，单向链表与之前我们学的顺序表作用相同，但与顺序表相比，单向链表使用起来更加灵活，效率更高，是一种非常常见且实用的数据结构.
单向链表c语言写法,C语言单向链表的实现
weixin_35633340的博客
05-24 216
C语言单向链表的实现采用VS2013编辑器编写的C语言单向链表代码：#include #include typedef int TypeData;#define NODE_LENGTH sizeof(NODE)/**定义链表的结构体*/typedef struct tagNode{TypeData tdData;struct tagNode *plNext;}NODE;/*******函数声明...
单链表C语言版
iwkxi的博客
03-19 1590
文章目录0.前言1.链表的概念及结构2.链表的分类3单链表的实现3.1 Slist.h3.2 Slist.c3.2.1 打印链表3.2.2 动态开辟一个节点3.2.3 尾插3.2.4 头插3.2.5 尾删3.2.7 头删3.2.8 单链表查找3.2.8 单链表插入数据(在pos之前还是之后？）3.2.9 单链表删除pos的数据（pos之前还是之后）3.2.10 删除单链表3.2.11 SList.c完整代码3.3 Test.c4运行结果 0.前言 1.链表的概念及结构 概念：链表是一种物理存储结构上非连
C语言实现单向链表加注释
最新发布
06-11
以下是C语言实现单向链表并加上注释的代码示例： ```c #include <stdio.h> #include <stdlib.h> // 定义单向链表结构体 struct Node { int data; // 数据域 struct Node* next; // 指针域 }; int main() { // 初始化链表头节点 struct Node* head = NULL; // 创建链表节点并赋值 struct Node* node1 = (struct Node*)malloc(sizeof(struct Node)); node1->data = 1; node1->next = NULL; // 将节点1插入链表头 head = node1; // 创建链表节点并赋值 struct Node* node2 = (struct Node*)malloc(sizeof(struct Node)); node2->data = 2; node2->next = NULL; // 将节点2插入链表尾 node1->next = node2; // 遍历链表并输出每个节点的值 struct Node* current = head; while (current != NULL) { printf("%d ", current->data); current = current->next; } // 释放链表节点的内存 current = head; while (current != NULL) { struct Node* temp = current; current = current->next; free(temp); } return 0; } ``` 注释中解释了每个关键步骤的功能，可以帮助理解代码的实现过程。需要注意的是，链表的节点插入和遍历是常见操作，而释放内存也是必要的，避免内存泄漏。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值