数据结构：无头单向非循环链表C语言实现

目录

链表的概念及结构

链表的分类

链表的实现

打印单链表

初始化链表

动态申请一个结点

单链表尾插

单链表头插

单链表尾删

单链表头删

单链表查找

单链表在pos位置之后插入x

单链表在pos位置之前去插入一个结点

单链表删除pos位置的结点

单链表删除pos位置之后的结点

单链表的销毁

---

链表的概念及结构

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的，结点可以在运行的时候动态生成，每个结点包括两个部分：一个是存储数据元素的数据域，另外一个数存储下一个结点地址的指针域。

链表的逻辑结构：想象出来的，更形象，方便理解。

 

链表的物理结构：在内存中实实在在如何存储的。

 

链表的分类

1.单向或者双向

 2.带头或者不带头

 3.循环或者非循环

因此我们的链表算起来就有八种结构：无头单向非循环链表、无头单向循环链表、带头单向非循环链表、带头单向循环链表、无头双向非循环链表、无头双向循环链表、带头双向非循环链表、带头双向循环链表。

链表的实现

链表的函数接口声明：

SList.h:

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;//数据域
	struct SListNode* next;//指针域

}SLTNode;

//打印单链表
void SListPrint(SLTNode *phead);

//动态申请一个
SLTNode* BuySlistNode(SLTDataType x);

//单链表尾插
void SListPushBack(SLTNode **pphead, SLTDataType x);

//单链表头插
void SListPushFront(SLTNode **pphead, SLTDataType x);

//单链表尾删
void SListPopBack(SLTNode **pphead);

//单链表头删
void SListPopFront(SLTNode **pphead);

//单链表查找
SLTNode* SListFind(SLTNode *phead, SLTDataType x);

//单链表在pos位置之后插入x
void SListInsertAfter(SLTNode *pos, SLTDataType x);

// 在pos位置之前去插入一个结点
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

//单链表删除pos位置的结点
void SListErase(SLTNode** pphead, SLTNode* pos);

//单链表删除pos位置之后的结点
void SListEraseAfter(SLTNode *pos);

//单链表的销毁
void SListDestory(SLTNode **pphead);

打印单链表

打印链表的时候，我们需要从头指针指向的位置开始，依次向后打印，直至指针指向NULL结束。

//单链表的打印
void SListPrint(SLTNode *phead)
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

初始化链表

在对链表进行其他操作之前，我们首先得对链表进行初始化，我们知道链表是由一个又一个的结点链接而成的，因此我们需要创建一个结点类型，该结点包含两部分：存储元素的数据域与存储下一个结点地址的指针域。

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;//数据域
	struct SListNode* next;//指针域

}SLTNode;

动态申请一个结点

由于每次插入都需要动态申请一个结点，那么我们为了减少代码的冗余度，就直接创建了一个动态申请一个结点的接口函数。

//动态申请一个结点
SLTNode* BuySlistNode(SLTDataType x)
{
	SLTNode* NewNode = (SLTNode*)malloc(sizeof(SLTNode));
	if (NewNode == NULL)
	{
		printf("malloc failed\n");
		exit(-1);
	}
	NewNode->data = x;
	NewNode->next = NULL;
	return NewNode;
}

单链表尾插

尾插的时候首先我们要判断链表是否为空，若为空，则让头指针指向动态申请的新结点即可。若不为空，我们需要通过遍历链表，找到链表中的尾结点，再将尾结点链接到动态申请的新结点上，此时动态申请的新结点就成了我们新的尾结点。

//单链表的尾插
void SListPushBack(SLTNode **pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* NewNode = BuySlistNode(x);
	if (*pphead == NULL)
	{
		*pphead = NewNode;
	}
	else
	{
		//找到尾结点
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = NewNode;
	}

}

单链表头插

头插的时候，我们先动态申请一个结点，再让动态申请的新结点链接到头指针指向的结点即可，最后将头指针指向我们动态申请的新结点。

//单链表头插
void SListPushFront(SLTNode **pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* NewNode = BuySlistNode(x);
	NewNode->next = *pphead;
	*pphead = NewNode;
}

单链表尾删

单链表的尾删相对麻烦一点需要分为以下的三种情况：

1.当链表为空时，不需要做任何处理。

2.当链表只有一个结点时，将头指针指向的结点给free掉，再将头指针给置空

3.当链表有2个或者2个以上结点时，我们需要通过遍历链表，找到尾结点与尾结点的前一个结点，然后将尾结点给free掉，将尾结点的前一个结点的next指向NULL，使其成为新的尾结点。

//单链表尾删
void SListPopBack(SLTNode **pphead)
{
	assert(pphead);
	//1个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//2个或者2个以上结点
	else
	{
		SLTNode* cur = *pphead;
		SLTNode* prev = NULL;
		//找尾
		while (cur->next != NULL)
		{
			//先存再走
			prev = cur;
			cur = cur->next;
		}
		free(cur);
		prev->next = NULL;

		第二种实现的方法
		//SLTNode* prev = *pphead;
		//while (prev->next->next != NULL)
		//{
		//	prev = prev->next;
		//}
		//free(prev->next);
		//prev->next = NULL;
	}
}

单链表头删

头删与尾删相比较为简单，只需让头指针指向第二个结点，然后再释放掉第一个结点的内存空间即可。

//单链表头删
void SListPopFront(SLTNode **pphead)
{
	assert(pphead);
	SLTNode* cur = (*pphead)->next;
	free(*pphead);
	*pphead = NULL;
	*pphead = cur;
}

单链表查找

查找数据的话，我们需要遍历链表，看结点中的data是否与我们要查查找的数据相等，若相等则返回当前结点的地址，若遍历完了还是找不到，那就返回NULL即可。

//单链表查找
SLTNode* SListFind(SLTNode *phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	//找不到
	return NULL;
}

单链表在pos位置之后插入x

我们需要先动态申请一个结点，让该结点指向pos的后一个结点，再让pos结点指向这个动态申请的新节点即可。

//单链表在pos位置之后插入x
void SListInsertAfter(SLTNode *pos, SLTDataType x)
{
	assert(pos);
	//先创建一个结点
	SLTNode* NewNode = BuySlistNode(x);
	SLTNode* cur = pos->next;
	//把pos的next指向新结点，再将新节点的next指向cur结点
	pos->next = NewNode;
	NewNode->next = cur;
}

单链表在pos位置之前去插入一个结点

首先我们先动态申请一个新结点，然后还要分两种情况，若pos位置为头指针指向的位置时，就相当于我们前面的头插，若不是头指针指向的位置，我们需要先遍历链表找到pos的前一个结点，再将pos的前一个结点指向动态申请的新结点，再让新结点指向pos结点即可。

// 在pos位置之前去插入一个结点
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);

	SLTNode* newnode = BuyListNode(x);
	if (*pphead == pos)
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
	else
	{
		// 找到pos的前一个位置
		SLTNode* posPrev = *pphead;
		while (posPrev->next != pos)
		{
			posPrev = posPrev->next;
		}

		posPrev->next = newnode;
		newnode->next = pos;
	}
}

单链表删除pos位置的结点

我们首先需要判断一下pos位置是否为头指针指向的位置，若是的话就相当于我们前面的头删，若不是的话，我们需要找到pos的前一个结点，再让pos的前一个结点指向pos的后一个结点，最后再将pos结点给释放掉。

//单链表删除pos位置的结点
void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);

	if (*pphead == pos)
	{
		/**pphead = pos->next;
		free(pos);*/
		SListPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		prev->next = pos->next;
		free(pos);
		//pos = NULL;
	}
}

单链表删除pos位置之后的结点

pos不能够是尾结点，因为尾结点后面已经没有内容可以删除了，所以我们需要断言一下，防止出问题。然后我们再将pos结点指向pos后面结点的结点，再将pos的后一个结点给free掉即可

//单链表删除pos位置之后的结点
void SListEraseAfter(SLTNode *pos)
{
	assert(pos);
	assert(pos->next);
	SLTNode* next = pos->next;
	pos->next = next->next;
	free(next);
	next = NULL;
}

单链表的销毁

我想很多人可能觉得在单链表销毁这里只要将头指针指向的结点给释放掉就算完事了，这样并不好，因为这样做会造成内存泄漏的风险。

那么我们应该如何做呢：循环遍历释放当前结点前，需要先保存当前结点的后一个结点的地址，防止地址丢失而无法释放。

释放完后，再将头指针置空（避免成为野指针）

//单链表的销毁
void SListDestory(SLTNode **pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur != NULL)
	{
		//先指后删
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

无头单向非循环链表的内容就讲到这里了，后期博主还会更新链表的Leetcode题以及带头双向循环链表的文章，如果觉得文章对你有帮助的话可以点赞关注一波哦！！！