单向链表

最新推荐文章于 2024-07-29 17:54:45 发布
最新推荐文章于 2024-07-29 17:54:45 发布
阅读量586 收藏
点赞数 1
分类专栏： 数据结构 文章标签： C语言 链表 数据结构 单向链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AlbertoNo1/article/details/51154552
版权

单链表介绍

        单链表（通常简称链表）由各个元素之间通过一个指针彼此链接起来而组成。每个元素包含两部分：数据成员和一个称为next指针。通过采用这种二成员结构，将每个元素的next指针设置为指向其后面的元素。最后一个元素的next指针设置为NULL，简单地表示链表的尾端。链表开始处的元素是“头”，链表末尾的元素称为“尾”。

        待补图

        要访问链表中的某个元素，从链表头开始，通过next指针从一个元素到另一个元素连续的遍历直到找到所需要的那个元素为止。


单链表实现（1）

/*链表元素结构体定义*/
typedef struct ListElmt_
{
	void *pdata;
	struct ListElmt_ *pNext;
}ListElmt;

/*链表结构体定义*/
typedef struct List_
{
	int iSize;
	void (*destory)(void *data);
	ListElmt *ListElmtHead;
	ListElmt *ListElmtTail;
}List;

/*链表操作宏定义*/
#define LIST_SIZE(list) ((list)->iSize)
#define LIST_HEAD(list) ((list)->ListElmtHead)
#define LIST_TAIL(list) ((list)->ListElmtTail)
#define LIST_IS_HEAD(list, element) ((element == (list)->ListElmtHead) ? 1:0)
#define LIST_IS_TAIL(list, element) ((element == (list)->ListElmtTail) ? 1:0)
#define LIST_DATA(element) ((element)->pdata)
#define LIST_NEXT(element) ((element)->pNext)

/*
*函数名：List_Init
*参数：list  链表
*      destory  释放链表节点内存的函数
*功能：单链表初始化
*返回值：无
*作者：AlbertoNo1
*日期：2016-04-14
*/
void List_Init(List *list, void (*destory)(void *data))
{
	/*入参合法性由调用者保证*/

	list->iSize = 0;
	list->destory = destory;
	list->ListElmtHead = NULL;
	list->ListElmtTail = NULL;

	return ;
}

/*
*函数名：List_Ins_Next
*参数：list  链表
*      Element  待插入元素的前一个节点元素
*      data     待插入元素数据
*功能：单链表添加节点函数
*返回值：0 成功  -1 失败
*作者：AlbertoNo1
*日期：2016-04-14
*/
int List_Ins_Next(List *list, ListElmt *Element, void *data)
{
	ListElmt *Lelmt = NULL;

	if ((NULL == list) || (NULL == data))
	{
		return -1;
	}

	/*申请链表节点内存*/
	Lelmt = (ListElmt*)malloc(sizeof(ListElmt));
	if (NULL == Lelmt)
	{
		return -1;
	}

	Lelmt->pdata = data;

	if (NULL == Element)
	{
		/*在链表头插入元素*/
		Lelmt->pNext = list->ListElmtHead;
		list->ListElmtHead = Lelmt;

		if (0 == LIST_SIZE(list))
		{
			list->ListElmtTail = Lelmt;
		}
	}
	else
	{
		/*在非链表头插入元素*/
		Lelmt->pNext = Element->pNext;
		Element->pNext = Lelmt;

		if (NULL == Lelmt->pNext)
		{
			list->ListElmtTail = Lelmt;
		}
	}

	/*链表大小加1*/
	list->iSize++;

	return 0;
}

/*
*函数名：List_Rem_Next
*参数：list  链表
*      Element  待删除元素的前一个节点元素
*      data     返回删除元素的数据域
*功能：单链表删除节点函数
*返回值：0 成功  -1 失败
*作者：AlbertoNo1
*日期：2016-04-14
*/
int List_Rem_Next(List *list, ListElmt *Element, void **data)
{
	ListElmt *Old_Lelmt = NULL;

	if ((NULL == list) || (NULL == data))
	{
		return -1;
	}

	if (0 == LIST_SIZE(list))
	{
		return -1;
	}

	if (LIST_IS_TAIL(list, Element))
	{/*尾结点下一个元素无效，不能删除*/
		return -1;
	}

	if (NULL == Element)
	{
		/*删除链表头元素*/
		*data = list->ListElmtHead->pdata;
		Old_Lelmt = list->ListElmtHead;
		list->ListElmtHead = list->ListElmtHead->pNext;

		if (1 == LIST_SIZE(list))
		{
			list->ListElmtTail = NULL;
		}

	}
	else
	{
		/*删除非链表头元素*/
		if (1 == LIST_SIZE(list))
		{
			return -1;
		}
		else
		{
			*data = Element->pNext->pdata;
			Old_Lelmt = Element->pNext;
			Element->pNext = Element->pNext->pNext;

			if (NULL == Element->pNext)
			{
				list->ListElmtTail = Element;
			}
		}
	}

	/*释放删除节点的内存*/
	free(Old_Lelmt);

	/*链表大小减一*/
	list->iSize--;

	return 0;
}

/*
*函数名：List_Destory
*参数：list  链表
*功能：单链表销毁
*返回值：无
*作者：AlbertoNo1
*日期：2016-04-14
*/
void List_Destory(List *list)
{
	void *data = NULL;

	/*入参合法性由调用者保证*/

	while (LIST_SIZE(list) > 0)
	{
		if ((0 == List_Rem_Next(list, NULL, &data))&&(NULL != list->destory))
		{
			list->destory(data);
		}
	}

	memset(list, 0, sizeof(List));

	return ;
}

/*
*函数名：destory
*参数：data  动态申请内存的地址
*功能：释放动态申请内存函数
*返回值：无
*作者：AlbertoNo1
*日期：2016-04-14
*/
void destory(void *data)
{
	free(data);
}

单链表实现（2） 

/*单链表元素结构体定义*/
typedef struct  ListElmt_
{
	unsigned int uiValueA;   /*数据域 数据成员*/
	unsigned int *puiValueB; /*数据域 数据成员，需要动态申请内存*/

	struct ListElmt_ *pNext;  /*指针域 指向后一个元素结点的指针*/

}ListElmt;

/*单链表结构体定义*/
typedef struct List_
{
	int  iSize;   /*链表大小*/

	void (*destory)(void *data);  /*用于释放元素结点内动态申请的内存*/
	int (*compare)(void *key1, void *key2); /*比较函数 返回值 0 相等 1 大于 -1 小于*/

	ListElmt  *pListElmtHead;  /*指向链表头结点的指针*/
	ListElmt  *pListElmtTail;  /*指向链表尾结点的指针*/

}List;

/*单链表操作宏定义*/
#define LIST_SIZE(list)   ((list)->iSize)
#define LIST_HEAD(list)   ((list)->pListElmtHead)
#define LIST_TAIL(list)   ((list)->pListElmtTail)
#define LIST_IS_HEAD(list, element) (((element) == (list)->pListElmtHead) ? 1:0)
#define LIST_IS_TAIL(list, element) (((element) == (list)->pListElmtTail) ? 1:0)

/*函数声明*/

void MemoryFree(void *data);
int DataCompare(void *key1, void *key2);
void List_Init(List *list, void (*destory)(void *data), int (*compare)(void *key1, void *key2));
int List_Insert_Next(List *list, ListElmt *Lelement, unsigned int uiDataA, unsigned int *puiDataB);
int List_Remove_Next(List *list, ListElmt *Lelement, unsigned int *puiDataA, unsigned int **puiDataB);
void List_Sort(List *list);
void List_Destory(List *list);
void List_Swap(ListElmt *LelementKey1, ListElmt *LelementKey2);

/*
*函数名：MemoryFree
*参数：data  待释放的内存
*功能：释放动态申请的内存
*返回值：无
*作者：AlbertoNo1
*日期：2016-04-20
*/
void MemoryFree(void *data)
{
	free(data);
}

/*
*函数名：DataCompare
*参数：key1  待比较的元素1
*      key2  待比较的元素2
*功能：比较两个元素的大小（无符号整型）
*返回值：0 key1 等于 key2  1 key1 大于 key2  -1 key1 小于 key2 
*作者：AlbertoNo1
*日期：2016-04-20
*/
int DataCompare(void *key1, void *key2)
{
	unsigned int uiKey1 = 0;
	unsigned int uiKey2 = 0;

	uiKey1 = *((unsigned int*)key1);
	uiKey2 = *((unsigned int*)key2);

	if (uiKey1 < uiKey2)
	{
		return -1;
	}
	else if (uiKey1 > uiKey2)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

/*
*函数名：List_Init
*参数：list  待初始化的链表
*      destory  数据域动态内存释放函数
*      compare  比较函数
*功能：单链表初始化函数
*返回值：无 
*作者：AlbertoNo1
*日期：2016-04-20
*/
void List_Init(List *list, void (*destory)(void *data), int (*compare)(void *key1, void *key2))
{
	list->iSize = 0;

	list->destory = destory;
	list->compare = compare;

	list->pListElmtHead = NULL;
	list->pListElmtTail = NULL;
}

/*
*函数名：List_Insert_Next
*参数：list  链表
*      Lelment  待插入元素的前一个元素指针
*      uiDataA  数据成员值
*      puiDataB 数据成员值（动态申请内存）
*功能：单链表插入元素函数
*返回值：0 成功 -1 失败 
*作者：AlbertoNo1
*日期：2016-04-20
*/
int List_Insert_Next(List *list, ListElmt *Lelement, unsigned int uiDataA, unsigned int *puiDataB)
{
	ListElmt  *pElment = NULL;

	/*入参合法值由调用者保证*/

	/*申请内存*/
	pElment = (ListElmt*)malloc(sizeof(ListElmt));
	if (NULL == pElment)
	{
		return -1;
	}

	/*数据域赋值*/
	pElment->uiValueA = uiDataA;
	pElment->puiValueB = puiDataB;

	if (0 == LIST_SIZE(list))
	{/*空链表插入元素*/
		pElment->pNext = NULL;

		/*更新链表头尾结点指针*/
		list->pListElmtHead = pElment;
		list->pListElmtTail = pElment;
	}
	else
	{
		if (NULL == Lelement)
		{/*插入链表头*/
			pElment->pNext = list->pListElmtHead;

			list->pListElmtHead = pElment;
		}
		else if (LIST_IS_TAIL(list, Lelement))
		{/*插入链表尾*/
            pElment->pNext = NULL;

			list->pListElmtTail->pNext = pElment;
			list->pListElmtTail = pElment;
		}
		else
		{
			pElment->pNext = Lelement->pNext;

			Lelement->pNext = pElment;
		}
	}

	list->iSize++;

	return 0;
}

/*
*函数名：List_Remove_Next
*参数：list  链表
*      Lelment  待删除元素的前一个元素指针
*      puiDataA  返回数据成员值
*      puiDataB  返回数据成员值（动态申请内存）
*功能：单链表删除元素函数
*返回值：0 成功 -1 失败 
*作者：AlbertoNo1
*日期：2016-04-20
*/
int List_Remove_Next(List *list, ListElmt *Lelement, unsigned int *puiDataA, unsigned int **puiDataB)
{
	ListElmt  *pElment = NULL;

	/*入参合法值由调用者保证*/

	if (0 == LIST_SIZE(list))
	{/*空链表删除元素*/
		return -1;
	}

	if (LIST_IS_TAIL(list, Lelement))
	{/*尾结点下一个元素无效，不能删除*/
		return -1;
	}

	if (NULL == Lelement)
	{/*删除链表头*/

		pElment = list->pListElmtHead;
		/*数据域返回*/
		*puiDataA = pElment->uiValueA;
		*puiDataB = pElment->puiValueB;

		list->pListElmtHead = list->pListElmtHead->pNext;

		if (1 == LIST_SIZE(list))
		{
			list->pListElmtTail = NULL;
		}
	}
	else
	{/*删除非链表头元素*/
		if (1 == LIST_SIZE(list))
		{
			return - 1;
		}
		else
		{
			pElment = Lelement->pNext;

			/*数据域返回*/
			*puiDataA = pElment->uiValueA;
			*puiDataB = pElment->puiValueB;

			Lelement->pNext = Lelement->pNext->pNext;

			if (NULL == Lelement->pNext)
			{
				list->pListElmtTail = Lelement;
			}
		}
	}

	/*释放链表结点内存*/
	free(pElment);

	list->iSize--;

	return 0;
}

/*
*函数名：List_Sort
*参数：list  链表
*功能：单链表排序(交换结点的数据域)
*返回值：无 
*作者：AlbertoNo1
*日期：2016-04-20
*/
void List_Sort(List *list)
{
	ListElmt  *pElmentPos = NULL;
	ListElmt  *pElmentA = NULL;
	ListElmt  *pElmentB = NULL;

	if (0 == LIST_SIZE(list))
	{
		return ;
	}

	for (pElmentA = list->pListElmtHead; NULL != pElmentA; pElmentA = pElmentA->pNext)
	{
		pElmentPos = pElmentA;

		for (pElmentB = pElmentA->pNext; NULL != pElmentB; pElmentB = pElmentB->pNext)
		{
			if (list->compare(&(pElmentB->uiValueA), &(pElmentPos->uiValueA)) < 0)
			{
				pElmentPos = pElmentB;
			}
		}

		if (pElmentPos != pElmentA)
		{
			List_Swap(pElmentPos, pElmentA);
		}
	}
}

/*
*函数名：List_Swap
*参数：list  链表
*功能：单链表交换两个结点的数据域
*返回值：无 
*作者：AlbertoNo1
*日期：2016-04-20
*/
void List_Swap(ListElmt *LelementKey1, ListElmt *LelementKey2)
{
	unsigned int uiValueA = 0;   
	unsigned int *puiValueB = NULL; 

	uiValueA = LelementKey1->uiValueA;
	puiValueB = LelementKey1->puiValueB;

	LelementKey1->uiValueA = LelementKey2->uiValueA;
	LelementKey1->puiValueB = LelementKey2->puiValueB;

	LelementKey2->uiValueA = uiValueA;
	LelementKey2->puiValueB = puiValueB;
}

/*
*函数名：List_Destory
*参数：list  链表
*功能：单链表销毁函数
*返回值：无 
*作者：AlbertoNo1
*日期：2016-04-20
*/
void List_Destory(List *list)
{
	unsigned int uiDataA = 0;
	unsigned int *puiDataB = NULL;

	while (LIST_SIZE(list) > 0)
	{
		if ((0 == List_Remove_Next(list, NULL, &uiDataA, &puiDataB)) && (NULL != list->destory))
		{
			list->destory(puiDataB);
		}
	}
}


AlbertoNo1
关注
专栏目录
单向链表及其应用（C语言）
sweetdark的专栏
12-16 1212
一、单向链表 //list.h#ifndef LIST_H_ #define LIST_H_ #include typedef struct ListElement_ { void *data; struct ListElement_ *next; } ListElement; typedef struct List_ { int size; int (*match) (con
C语言之单向链表详解及实例代码
12-31
1，单向链简洁。...根据示例代码中的例子，完成单向链表(single linked list)中的以字符串为数据的链表的插入、删除以及查找，并支持单向链表的反转； 3，代码实现。 #include #include <math.h>
数据结构二叉树的实现，前序、中序、后序遍历
ORANCLE
07-17 410
typedef struct BitTreeNode_ { void *data; struct BitTreeNode_ *left; struct BitTreeNode_ *right; }BitTreeNode; typedef struct BitTree_ { int size; BitTreeNode *root; int (*compare)(const voi
C语言 实现一个二叉树
pecuyu
06-24 805
1、概述 二叉树是一种特殊的树，每个父节点最多只有2个直接子孩子，每个节点也只有一个直接父节点（根节点默认无父节点）。我们实现类似下图所示的二叉树（图片来源网络）： 可以看出，该树满足一般二叉树的特性： 包含一个树根节点 每个节点都最多只有2个直接子孩子 每个子孩子也最多只有一个父节点 随着树深度的增加，所能容纳的元素也是成倍增长。宽度呈指数级增长，高度增长相对较缓慢 等等 对二叉...
c++实现单向链表
henjdx的博客
03-26 1071
单向链表属于链表中的一类，链表是用于数据元素的线性集合，其中每个元素都指向下一个元素，元素存储上并不连续。单向链表的特性是每个元素只知道其下一个元素是谁。
单向链表Python
泰敢人辣的博客
07-26 3691
链表是一种常见的数据结构，用于存储和组织数据。它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。 链表相对于数组的优势在于灵活性。由于链表的节点并不一定连续存储在内存中，因此可以动态地插入和删除节点，而不需要移动其他节点。然而，链表的缺点是访问特定位置的节点较慢，需要从头节点开始遍历到指定位置。
单向链表SingleLinkedList
weixin_66598341的博客
09-09 1415
本文案例仅仅使用Java语言实现单向链表的一些简单的增删改查，完成反转单向链表，以及借助栈逆序遍历单向链表等功能。
单向链表的C语言实现
Broken_x的博客
05-28 1194
首先，我们需要定义单向链表的结点和链表本身的结构// 单向链表的结点定义// 数据域// 指针域，指向后继结点} Listnode;// 单向链表的定义// 头结点// 整个链表的元素个数和：包含标准输入输出和标准库函数。：定义链表中数据的类型为int，可以根据需要更改。：定义链表结点结构体，包含数据域data和指向后继结点的指针next。：定义链表结构体，包含指向头结点的指针head和链表的元素个数size。
C语言——单向链表
2301_79695216的博客
07-21 722
线性表的链式存储结构，我们叫做链表。将线性表L=(a0,a1,……,an-1)中各元素分布在存储器中的不同存储区域，线性表中的各元素称为结点，通过地址或指针建立结点之间的联系，所得到的存储结构为链表 结构。
单向链表与双向链表
最新发布
qq_57106106的博客
07-29 892
可以解决顺序表存储空间上限，插入和删除效率低的问题链表：链式存储的线性表链表的组成：由一个个节点组成节点：由数据域和指针域组成数据域：存放数据的区域指针域：存放下一个节点地址的指针单向链表，双向链表，循环链表只能通过头节点或者头指针单向的访问后继节点的链表，称为单向链表。每个节点的指针域只记录其后继节点的地址。（火车结构）头节点结构体格式：int len；//头节点的数据域普通节点结构体格式：int data；//普通节点的数据域unionint len；//头节点的数据域。
单向链表结构
qq_59750520的博客
07-02 806
本文简要介绍了单向链表的结构以及实现了一个单向链表类
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
单向链表类模板_单向链表类模板_fastchq_
10-03
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在C++编程中，为了实现通用性，我们通常会使用模板类来创建单向链表，以便它可以处理不同类型的元素。标题"单向链表类...
单向链表 代码架构
12-29
单向链表是一种基本的数据结构，它在计算机科学和编程中有着广泛的应用。与数组不同，链表中的元素不是在内存中连续存储的，而是通过指针或引用连接在一起，形成一个逻辑上的线性序列。单向链表的每个节点包含两部分...
Python单向链表和双向链表原理与用法实例详解
09-20
在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只包含一个指向下一个节点的引用。在单向链表中，遍历只能从头节点开始，按顺序访问每个节点，无法...
双向链表
AlbertoNo1的博客
04-24 2907
双向链表介绍        双向链表，如同其名所暗示的那样，链表元素之间由两个指针链接。双向链表中的每一个元素都由3部分组成：除了数据域成员和next指针外，每个元素还包含一个指向其前驱元素的指针，称为prev指针。双向链表的组成是这样的：将一些元素链接在一起使得每个元素的next指针都指向其后继的元素，而每个元素的prev指针都指向其前驱元素。为了标识链表的头和尾，将第一个元素的prev指针和
链式哈希表
AlbertoNo1的博客
04-15 1026
链式哈希表介绍         待补充 链式哈希表实现 // Chtbl.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include #include #include #include /*链表元素结构体定义*/ typedef struct Li
循环链表
AlbertoNo1的博客
04-27 693
循环链表介绍         循环链表是另一种形式的链表，它提供了更为灵活的遍历表元素的能力。循环链表可以是单向的或双向的，但区分一个链表是不是循环链表只要看它有没有尾部元素即可。在循环链表中，最后一个元素的next指针又指回头元素而不是设置为NULL。在双向循环链表中，头元素的prev指针则指向最后一个元素，这使得循环链表中的每个元素既可以看做头元素也可以看做尾元素。遍历循环链表可以从任何一个
C语言实现单向链表的基本操作
"这篇资源是关于单向链表的基础知识，包括如何在C语言中实现单向链表的初始化、创建、销毁等操作。" 在数据结构中，链表是一种非常重要的非线性数据结构。单向链表是其中一种形式，每个节点包含一个数据元素和一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值