数据结构模版----单链表SimpleLinkList[不带头结点](C语言实现)

最新推荐文章于 2023-02-13 23:46:44 发布
最新推荐文章于 2023-02-13 23:46:44 发布
阅读量1.6w 收藏 1
点赞数
分类专栏： ┈┈【C / C++发现】 ┈┈【数据结构与算法】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gatieme/article/details/42611645
版权

下面给出的是单链表不带头结点的另一种实现方式，也是最复杂的一种方式

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>

//#define DEBUG				// 调试插桩信息宏

///*
///
///	带头结点的单链表结构体
///
///*

typedef int ElemType;		// 自定义数据类型

//typedef struct LinkListNode*	PLinkListNode;			// 链表结点指针域

// 链表结点数据域
typedef struct LinkListNode
{
	ElemType			m_data;			// 数据域
	struct LinkListNode	*m_next;			// 指针域
}LinkListNode;

// 带头结点的单项链表
typedef struct LinkListNode*  LinkList;


///*
///
///	初始化单链表
///
///	初始化单链表
///	void InitLinkList(LinkList *list)
///*///

/**
void InitLinkList(LinkList *list)
参数
	list	:	指向一个链表指针，此处传入表头地址
返回值
	无
功能
	初始化单链表， 执行以下操作
	①开辟头结点的空间 ②进行必要的初始化[头结点的初始化和单链表结点数目的初始化]
注意
	使用InitLinkList初始化的单链表(初始化时malloc了头结点m_head的空间)
	而使用用FinitLinkList来进行后处理(后处理时free了头结点的m_head空间)
	以免发生内存泄漏
*/
void InitLinkList(LinkList *list)
{
	(*list) = NULL;			// 初始化只头指针
}


///*
///
///	销毁以及后处理单链表
///
///	后处理单链表，
///	void FinitLinkList(LinkList *list)
///
/// 清空单链表中的所有元素
///	void ClearLinkList(LinkList *list)
///*

/**
void FinitLinkList(LinkList *list)
参数
	list	:	指向一个链表指针，此处传入表头地址
返回值
	无
功能
	后处理单链表， 执行以下操作
	①开辟头结点的空间 ②进行必要的初始化[头结点的初始化和单链表结点数目的初始化]
注意
	使用InitLinkList初始化的单链表(初始化时malloc了头结点m_head的空间)
	而使用用FinitLinkList来进行后处理(后处理时free了头结点的m_head空间)
	以免发生内存泄漏
*/
void FinitLinkList(LinkList *list)
{
	(*list) = NULL;
}



/**
void ClearLinkList(LinkList *list)
参数
	list	:	指向一个链表指针，此处传入表头地址
返回值
	无
功能
	清空单链表中的所有元素
*/
void ClearLinkList(LinkList *list)
{
    while((*list) != NULL)
	{
        DeleteNode(list, 0);
	}
}


///*
///
///	查找函数
///
///	查找到链表list中第position个结点
///	LinkListNode* FindPosNode(LinkList *list, int position)
///
///	在链表list中找到currNode的前一个结点
///	LinkListNode *FindPrevNode(LinkList *list, LinkListNode *currNode)
///
/// 判断结点node指向的区域是不是链表中的结点
///	int IsNodeInList(LinkList *list, LinkListNode *node)
///
///	找到数据域为data的结点首次出现的位置并返回结点信息
///	LinkListNode* FindDataNode(LinkList *list, ElemType data, int *position)
///*

/**
LinkListNode* FindPosNode(LinkList *list, int position)

参数
	list	:	指向一个链表指针，此处传入表头地址
	positon	:	带查找的链表指针的位置
返回值
	若成功返回指向待查找结点的指针
	若失败返回NULL
功能
	该函数的功能是:	查找到链表list中第position个结点
*/
LinkListNode* FindPosNode(LinkList *list, int position)
{
	assert(list != NULL);
	assert((*list) != NULL);									// 链表不能为空
	assert(position >= 0 && position < LengthLinkList(list));		// 查找的位置只能在[0, length)

	LinkListNode 	*pNode	= (LinkListNode *)(*list);
    int 			pos 	= 0;

    while(pNode != NULL && pos < position)		// 遍历单链表，找到第position个结点的位置
	{
		pNode = pNode->m_next;
		pos++;
	}

	if(pNode == NULL || pos < position)
	{
		return NULL;
	}
	else
	{
#ifdef DEBUG
		printf("Find the %d point SUCCESS...[%p]\n", position, pNode);
#endif // DEBUG
		return pNode;
	}
}

/**
LinkListNode *FindPrevNode(LinkList *list, LinkListNode *currNode);

参数
	list		:	指向一个链表指针，此处传入表头地址
	currNode	:	待查找的链表指针的位置
返回值
	若成功返回指向待查找结点的指针
	若失败返回NULL
功能
	在链表list中找到currNode的前一个结点
*/

LinkListNode *FindPrevNode(LinkList *list, LinkListNode *currNode)
{
	assert(list != 	NULL);
	assert(currNode != NULL);

	LinkListNode *pNode = (LinkListNode *)(*list);

	while(pNode->m_next != NULL && pNode->m_next != currNode)
	{
		pNode = pNode->m_next;
	}

	if(pNode->m_next == currNode)				// 查找成功
	{
		return pNode;
	}
	else										// 查找失败
	{
		return NULL;
	}
}

/**
int IsNodeInList(LinkList *list, LinkListNode *node)

参数
	list	:	指向一个链表指针，此处传入表头地址
	node	:	指向待查找的结点的指针
返回值
	若成功 返回结点node在链表中的位置
	若失败 返回-1
功能
	判断结点node指向的区域是不是链表中的结点
*/
int IsNodeInList(LinkList *list, LinkListNode *node)
{
	assert(list != NULL);									// 链表不能为空	assert(Node != NULL);									// 待查找的指针不能为空

	LinkListNode 	*pNode	= (LinkListNode *)(*list);
    int 			pos 	= -1;

    while(pNode != NULL && pNode != node)		// 遍历单链表，找到第position个结点的位置
	{
		pNode = pNode->m_next;
		pos++;
	}

	if(pNode == NULL)
	{	// 查找成功
		return -1;
	}
	else
	{	// 查找失败
#ifdef DEBUG
		printf("Find the [%p] point in the first %d pointer of the list...\n", node, pos);
#endif // DEBUG
		return pos;
	}
}


/**
LinkListNode* FindDataNode(LinkList *list, ElemType data, int *position

参数
	list	:	指向一个链表指针，此处传入表头地址
	data	:	待查找的结点的数据信息
返回值
	若成功 返回结点node在链表中的位置
	若失败 返回-1
功能
	找到数据域为data的结点首次出现的位置并返回结点信息
*/
LinkListNode* FindDataNode(LinkList *list, ElemType data, int *position)
{
	LinkListNode *node = (LinkListNode *)(*list);
	int pos = 0;
	while(node != NULL && node->m_data != data)
	{
		node = node->m_next;
		pos++;
	}
	*position = pos;				// 将出现的位置传递回去

	return node;					// 返回结点的信息
}
///*
///
///	插入函数
///
///	将数据data插入链表的prevNode结点的下一个位置个位置
///	LinkListNode *AddNode(LinkList *list, LinkListNode *prevNode, ElemType data)
///
///	将数据data插入链表的第position个位置
///	LinkListNode *InsertNode(LinkList *list, int position, ElemType data)
///*

/**
void InsertNode(LinkList *list, int position, ElemType data)
参数
	list	:	指向一个链表指针，此处传入表头地址
	positon	:	待插入结点的位置
	data	:	待插入结点的数据
返回值
	无
功能
	该函数的功能是:	将数据data插入链表的第position个位置
*/
LinkListNode* InsertNode(LinkList *list, int position, ElemType data)
{
	assert(position >=0 && position < LengthLinkList(list) + 1);	// 插入的位置应该在[0-length]

	LinkListNode *pNode = NULL;
	LinkListNode *newNode = NULL;

	// 为新结点开辟空间并且
	if((newNode = (LinkListNode *)malloc(sizeof(LinkListNode))) == NULL)	// 为新结点开辟空间
	{	// 开辟新结点失败
		fprintf(stderr, "not enough memeory\n");
        exit(EXIT_FAILURE);
	}
	else
	{	// 开辟新结点成功并且赋值
		newNode->m_data = data;
		newNode->m_next = NULL;
	}

	// 将新结点添加在链表中
	if(position == 0)			// 如果要插入第一个元素
	{
		// 如果当前链表是空链表
		if(list != NULL && (*list) == NULL)	// LinkList list = NULL创建的空链表
		{	// 此时(*list)->m_next会出现ERROR
			(*list) = newNode;
		}
		else								// 否则链表不是空链表
		{
			newNode->m_next = (*list);
			(*list) = newNode;
		}
	}
	else								// 否则当前链表不是空链表
	{
		pNode = FindPosNode(list, position - 1);		// 找到待插入点的前一个指针
		// 将指针newNode连接在pNode的后面
		newNode->m_next = pNode->m_next;
		pNode->m_next = newNode;
	}
#ifdef DEBUG
	printf("Insert the value %d into list at position %d...\n", data, position);
#endif // DEBUG

	return newNode;					// 返回指向插入的新结点的指针
}

/**
LinkListNode* AddNode(LinkList *list, LinkListNode *prevNode, ElemType data);
参数
	list		:	指向一个链表指针，此处传入表头地址
	prevNode	:	待插入位置的前一个结点
	data		:	待插入结点的数据
返回值
	无
功能
	该函数的功能是:	将数据data插入链表的prevNode结点的下一个位置个位置
[注意]	由于单链表不存在链表头，那么第一个元素不存在前驱，因此插入第一个元素时，默认其prevNode是list
*/
LinkListNode *AddNode(LinkList *list, LinkListNode *prevNode, ElemType data)
{
	assert(prevNode != NULL);						// 插入点不能是空指针

	LinkListNode *newNode = NULL;
	if((newNode = (LinkListNode *)malloc(sizeof(LinkListNode))) == NULL)	// 为新结点开辟空间
	{	// 开辟新结点失败
		fprintf(stderr, "not enough memeory\n");
        exit(EXIT_FAILURE);
	}
	//else
	//{
	// 开辟新结点成功
	newNode->m_data = data;
	newNode->m_next = NULL;
	if(prevNode == (LinkListNode *)(*list))		// 如果要插入的元素是第一个元素
	{
		if(list != NULL && (*list) == NULL)	// 如果当前链表是空链表(LinkList list = NULL创建的空链表)
		{	// 此时(*list)->m_next会出现ERROR
			(*list) = newNode;
		}
		else								// 否则链表不是空链表
		{
			newNode->m_next = (*list)->m_next;
			(*list) = newNode;
		}
	}
	else
	{
		// 将指针newNode连接在pNode的后面
		newNode->m_next = prevNode->m_next;
		prevNode->m_next = newNode;
	}

#ifdef DEBUG
	printf("The new node is inserted after point pointer[%p]\n", prevNode);
#endif // DEBUG
	return newNode;
}

///*
///
///	删除函数
///
///	删除链表list中prevNode结点之后的指针个指针
///	void DeleteNode(LinkList *list, int position)
///
///	删除链表list中prevNode结点之后的指针个指针
///	ElemType SubNode(LinkList *list, LinkListNode *prevNode)
///
///	删除链表list中prevNode结点之后的指针个指针
///	ElemType DeleteCurrNode(LinkList *list, LinkListNode *currNode)
///*

/**
ElemType DeleteNode(LinkList *list, int position);
参数
	list	:	指向一个链表指针，此处传入表头地址
	positon	:	待删除结点的位置
返回值
	返回待删除结点的数据域
功能
	将单链表的第position个结点删除
*/
ElemType DeleteNode(LinkList *list, int position)
{
	assert(list != NULL);									// 链表指针不能为空不能为空
	assert(position >=0 && position < LengthLinkList(list));		// 待删除的指针位置仅限于链表中存在的位置

	LinkListNode	*delNode = NULL;
	ElemType		delElem = -1;

	if(position == 0)				// 如果链表中仅剩最后一个元素
	{
		delNode = (*list);				// 待删除的结点就是头指针指向的结点
		if((*list)->m_next == NULL)	// 当前链表中仅剩最后一个元素
		{
			(*list) = NULL;			// 修改头指针为空[参数必须使用LinkListNode **形式， 因为修改了头指针的指向]
		}
		else						// 如果链表中有多个元素
		{
			(*list) = delNode->m_next;
		}
	}
	else								// 否则待删除的是其他结点
	{
		LinkListNode *pNode = FindPosNode(list, position - 1);			// 找到第position - 1个结点

		// 删除pNode的后一个结点
		delNode = pNode->m_next;
		pNode->m_next = delNode->m_next;
	}
	delElem = delNode->m_data;		// 保存待删除结点的数据域
	free(delNode);
#ifdef DEBUG
	printf("Delete the list in the first [%d, %d] node...\n", position, delElem);
#endif // DEBUG
	return delElem;
}

/**
ElemType SubNode(LinkList *list, LinkListNode *prevNode);)
参数
	list	:	指向一个链表指针，此处传入表头地址
	positon	:	待删除结点的位置
返回值
	返回待删除结点的数据域
功能
	删除链表list中prevNode结点之后的指针个指针
*/
ElemType SubNode(LinkList *list, LinkListNode *prevNode)
{
	assert(list != NULL);						// 链表不能为空
	assert(prevNode != NULL);						// 待删除结点的前一个位置不能为空
	assert(IsNodeInList(list, prevNode) != -1);	// 待删除位置的前一个结点必须在链表中

	LinkListNode	*delNode = NULL;
	ElemType		delElem = -1;

	if(prevNode == (*list))				// 如果待删除的元素是链表中第一个元素
	{
		delNode = (*list);				// 待删除的结点就是头指针指向的结点
		if((*list)->m_next == NULL)	// 当前链表中仅剩最后一个元素
		{
			(*list) = NULL;			// 修改头指针为空[参数必须使用LinkListNode **形式， 因为修改了头指针的指向]
		}
		else						// 如果链表中有多个元素
		{
			(*list) = delNode->m_next;
		}
	}
	else								// 否则待删除的是其他结点
	{
		// 删除prevode的后一个结点
		LinkListNode *delNode = prevNode->m_next;
		prevNode->m_next = delNode->m_next;
	}
	delElem = delNode->m_data;
	free(delNode);


	return delElem;
}


/**
ElemType DeleteCurrNode(LinkList *list, LinkListNode *currNode);
参数
	list	:	指向一个链表指针，此处传入表头地址
	positon	:	待删除结点的位置
返回值
	返回待删除结点的数据域
功能
	删除链表list中prevNode结点之后的指针个指针
*/
ElemType DeleteCurrNode(LinkList *list, LinkListNode *currNode)
{
	assert(list != NULL);							// 链表不能为空
	assert(currNode != NULL);							// 待删除结点的前一个位置不能为空
	assert(IsNodeInList(list, currNode) != -1);	// 待删除的结点必须在链表中

	ElemType delElem = -1;							// 待删除结点的数据域
	LinkListNode *delNode = NULL;					// 指向将要删除的结点的指针

	if(currNode->m_next != NULL)					// 如果待删除结点不是最后一个结点
	{
		// 将currNode的后一个结点delNode作为删除结点,
		delNode = currNode->m_next;
		currNode->m_next = delNode->m_next;			//从链表中删除delNode

		// 并将delNode的数据域保存到delNode中
		delElem = currNode->m_data;					// delElem保存currNode的数据域
		currNode->m_data = delNode->m_data;			// 真正删除的结点其实是currNode下一个结点, 因此用currNode保存下一个结点的数据域
	}
	else											// 否则待删除结点是最后一个结点
	{
		// 直接将最后一个结点删除即可， 应该把其前一个结点的指针域赋值为空
		delNode = currNode;
		// 下面应该将currnNode的前一个结点的指针域赋值为空[时间复杂度O(n)]
		LinkListNode *prevNode = FindPrevNode(list, currNode);
		prevNode->m_next = NULL;

	}
	free(delNode);

	return delElem;
}

///*
///
///	其他函数
///
///	显示单链表的信息
///	void ShowList(LinkList *list
///
///	删除链表list中prevNode结点之后的指针个指针
///	void SetNode(LinkList *list, int position, ElemType data)
///
///	获取单链表list第position个结点的数据域
/// ElemType GetNode(LinkList *list, int position)
///
///	获取单链表list的长度[即元素个数]
///	int LengthLinkList(LinkList *list)
///
///	判断当前链表是否是空链表
///	bool IsEmptyLinkList(LinkList *list)
///*


/**
void ShowLinkList(LinkList *list)
参数
	list	:	指向一个链表指针，此处传入表头地址
返回值
	无
功能
	显示单链表的信息
*/
void ShowList(LinkList *list)
{
	printf("there are %d data in list\n", LengthLinkList(list));

	LinkListNode *pNode = (LinkListNode *)(*list);			// 从头指针开始遍历

	while(pNode != NULL)								//开始遍历单链表
	{
		printf("%d  ", pNode->m_data);
        pNode = pNode->m_next;
	}
	printf("\n");

//	ElemType data;
//	for(int pos = 0; pos < list->m_length; pos++)
//	{
//		data = GetNode(list, pos);
//		printf("%d  ", data);
//	}
//	printf("\n");
}


/**
void SetNode(LinkList *list, int position, ElemType data)
参数
	list	:	指向一个链表指针，此处传入表头地址
	positon :	待修改的结点的数据
	data	:	待更正的新数据域
返回值
	无
功能
	修改单链表list第position个结点的数据域为data
*/
void SetNode(LinkList *list, int position, ElemType data)
{
	LinkListNode *pNode = FindPosNode(list, position);		// 找到单链表的第position个结点

	pNode->m_data = data;
}

/**
ElemType GetNode(LinkList *list, int position
参数
	list	:	指向一个链表指针，此处传入表头地址
	positon :	待查询的结点的位置
返回值
	获取到的结点数据
功能
	获取单链表list第position个结点的数据域
*/
ElemType GetNode(LinkList *list, int position)
{
	LinkListNode *pNode = FindPosNode(list, position);		// 找到单链表的第position个结点

	return pNode->m_data;
}

/**
int LengthLinkList(LinkList *list)
参数
	list	:	指向一个链表指针，此处传入表头地址
返回值
	单链表的长度
功能
	获取单链表的长度
*/
int LengthLinkList(LinkList *list)
{
	assert(list != NULL);

	int length = 0;
	LinkListNode *pNode = (LinkListNode *)(*list);

	while(pNode != NULL)
	{
		pNode = pNode->m_next;
		length++;
	}
	return length;
}



/**
bool IsEmptyLinkList(LinkList *list)
参数
	list	:	指向一个链表指针，此处传入表头地址
返回值
	如果单链表是空表，返回true
	否则返回false
功能
	获取单链表的长度
*/
bool IsEmptyLinkList(LinkList *list)
{
	return (list == NULL);
	// return (list->m_head == NULL);
}


#define LIST_SIZE 7
// MAIN
int main(void)
{
	int pos;

	printf("TEST 1...\n");
//	LinkList *plist = NULL;				// ERROR创建单链表


	printf("\n\nTEST 2...\n");
	LinkList list = NULL;
	InitLinkList(&list);								// 初始化单链表
	for(int pos = 0; pos < LIST_SIZE; pos++)			// 训话向单链表中插入数据
	{
		InsertNode(&list, 0, pos + 1);
	}
	ShowList(&list);									// 显示单链表
	ClearLinkList(&list);								// 清空单链表
	FinitLinkList(&list);		// ERROR== list->m_head->m_next == NULL
	ShowList(&list);

	return 	EXIT_SUCCESS;
}


CHENG Jian
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
金工实习、C语言课设、数据结构课设-报告
03-30
金工实习、C语言课设、数据结构课设——报告 源代码丢失了 只剩下报告，配图流程图齐全，可直接用 C语言：香水管理系统 数据结构：西邮导航
数据结构实验报告(C++) 实验一 线性结构实验指导（含源码）
Last_time233的博客
01-06 1089
一、线性结构实验（1）——线性表 题目1. 顺序表的差集 题目2. 单链表的递增差集 题目3.(选做题)：不带头结点的单链表 题目4.：单链表逆置 二、线性结构实验（2）——栈和队列 题目1. 队列元素倒置 题目2. 双端顺序栈
C++ 单链表（无头结点）
qq_43650934的博客
11-17 4729
文章目录总结归纳代码实现 总结归纳 头结点可以没有，头指针必须有。访问整个链表，是用过遍历头指针来进行的。 这里没有特别的设置一个头指针，因为当指针指向整个链表 L 时，该指针的实现效果就是头指针。 不带头结点的单链表，即单链表的第一个结点就存储数据，头指针也指向第一个结点；带头结点的单链表，第一个结点是头结点，不存储数据，从头结点的 next 开始存储，头指针可以从头结点的 next 开始遍历。 对于结点的前插操作，找到对应位置的结点，设新结点为该节点的后继结点，将该结点的 data 后移至新结点的 d
C语言数据结构——单链表(不带头)
qq_65980796的博客
02-13 1949
一、单链表：1.1 概念、1.2 链表结构分析、1.3 单链表的基本操作、1.4 单链表的基本操作源码。
不带头结点的单链表逆置c语言,设计不带头结点的单链表类模板,其功能是对链表中元素结点进行逆置.docx...
weixin_39922683的博客
05-21 492
设计不带头结点的单链表类模板,其功能是对链表中元素结点进行逆置设计不带头结点的单链表类模板,其功能是对链表中元素结点进行逆置篇一：实验一 不带头结点形式的单链表 　　实验一 不带头结点形式的单链表 　　专业：软件工程班级：09软工 学号：1XX11041XX 姓名：XXX 实验日期：XX-09-30 实验地点：B102 指导老师：吴景岚 一、 问题描述 　　实现不带头结点形式的单链表。...
Excel模板数据结构-行政区划信息.zip
06-16
Excel模板数据结构-行政区划信息.zip
Excel模板数据结构-卫星影像信息.zip
06-16
Excel模板数据结构-卫星影像信息.zip
Excel模板数据结构-社会经济信息.zip
06-16
Excel模板数据结构-社会经济信息.zip
Excel模板数据结构-火灾预警信息.zip
06-16
Excel模板数据结构-火灾预警信息.zip
数据结构 不带头结点的单链表代码
12-16
数据结构 用不带头结点的单链表实现遍历、插入、查询和删除等功能
C++分别创建和显示带头结点与不带头结点的单链表
03-19
最近在学数据结构，自己写的很简单的小程序，积跬步、至千里。
【C语言】数据结构C语言版 实验2 不带头结点的单链表
点滴记忆
11-24 2041
运行环境：Dev-C++ vs2013可能不能运行 首先新建一个头文件slnklist.h #include <stdio.h> #include <stdlib.h> /**************************************/ /* 链表实现的头文件，文件名slnklist.h */ /*************************...
不带头结点的单链表
m0_63852285的博客
11-18 3585
建立结构体 和带头结点但单链表一样，按需建立即可。我以建立一个储存学生信息的链表举例。 typedef struct node { char name[20]; int number; struct node *next; }Node,*LinkList; 单链表的建立 因为不带头结点，无需初始化，最后返回head 尾插法 如果是第一个结点，则需让head指向这个结点，再利用另一指针r保存head，并用r进行之后的节点插入。除第一个结点外其他结点的插入与带头结点的单链表一致。 Li
【不带头节点的单链表】
98同学吖的博客
04-23 2478
不带头节点的单链表
实验2 不带头节点的单链表
热门推荐
wlxsq的专栏
12-24 1万+
实验1 编写函数slnklist delx(linklist head, datatype x)，删除不带头结点单链表head中第一个值为x 的结点。 并构造测试用例进行测试。 #include "slnklist.h" /*请将本函数补充完整，并进行测试*/ linklist delx(linklist head,datatype x) { linklist pre=NULL,p,q
带头结点与不带头结点的单链表-LinkList
知行合一，止于至善
05-04 6189
1.辅助文件包Assistance.h#ifndef __ASSISTANCE_H__ // 如果没有定义__ASSISTANCE_H__ #define __ASSISTANCE_H__ // 那么定义__ASSISTANCE_H__// 辅助软件包// ANSI C++标准库头文件 #include <cstring>
不带头结点的单链表c语言,不带头结点的单链表的实现（C语言）
weixin_42297675的博客
05-21 1543
不带头结点的单链表的实现(C语言)不带头结点的单链表的实现(C语言)链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示线性表称作线性链表(单链表)单链表是链式存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。因此，查找第 i 个数据元素的基本操作...
实现一个函数模板，以带头结点的单链表为存储结构实现简单选择排序
最新发布
05-24
下面是一个以带头结点的单链表为存储结构实现简单选择排序的函数模板： ```c++ template<typename T> void selectionSort(ListNode<T>* head) { if (!head || !head->next) return; // 空链表或只有一个节点，无需排序 auto p = head->next; while (p) { auto minNode = p; // 记录最小值节点 auto q = p->next; while (q) { if (q->val < minNode->val) minNode = q; q = q->next; } if (minNode != p) std::swap(minNode->val, p->val); // 若最小值不是当前节点，交换值 p = p->next; } } ``` 其中，`ListNode` 是一个带有 `val` 和 `next` 成员变量的结构体，表示链表节点的值和指向下一个节点的指针。函数的实现过程为：从链表头开始遍历每个节点，找到后续节点中的最小值节点，并将其与当前节点交换值。这样，每次遍历时，当前节点之前的节点已经有序。遍历结束时，整个链表就有序了。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值