数据结构—单向链表

目录

什么是链表？

初始化链表

打印链表

创建新结点的函数

单链表的插入

头插

尾插

在给定位置之前插入

在给定位置之后插入

链表结点的删除

头删

尾删

删除给定位置的结点

查找数据

修改数据

销毁链表

---

什么是链表？

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

 

链表一共有8种，带头单向循环链表、带头单向非循环链表、带头双向循环链表、带头双向非循环链表、无头单向循环链表、无头单向非循环链表、无头双向循环链表、无头双向非循环链表。

本篇讲解的是无头单向非循环链表 

初始化链表

typedef int SLTDataType;
typedef struct SListNode//一个结点
{
	SLTDataType data;//数据域
	struct SListNode* next;//指针域
}SLTNode;

创建一个结构体，其实就是一个结点，该节点包括数据域和指针域（存放下一个结点的地址），重新命名为SLTNode，更方便后续的表述和函数接口的撰写

打印链表

void SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		printf("%d->",cur->data);
		cur = cur->next;//指针指向下一个结点
	}
	printf("NULL\n");
}

一般我们传过来的头指针不直接使用，而是新定义一个相同类型的局部变量保存一下，方便后续的使用，这里只需写一个循环遍历一下就可以了。再动图讲解一下cur变量的遍历。

创建新结点的函数

//创造新结点的函数
SLTNode* BuyListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//开辟一个新节点
	if (newnode==NULL)
	{
		printf("malloc fail\n");
		exit(-1);//终止程序
	}
	newnode->data = x;
	newnode->next = NULL;//新开辟的newnode 也有个地址
	return newnode;
}

我们每次的增删查改操作都会涉及到一个结点的操作，于是我们就将结点的创建把它封装成一个函数

单链表的插入

头插

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuyListNode(x);

	newnode->next = *pphead;//让新结点的指针域指向原来的头

	*pphead = newnode;//让原来的头指针更新为新地址

}

注意：后面的两部顺序不能颠倒，若先让头指针指向新结点，那么就无法找到原来第一个结点的位置了。

这里可能很多小伙伴会疑问，这里为什么要用二级指针来接收呢？

我们在这里可以调用一下函数接口看看效果：

​
void test()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist,1);
	SLTPushBack(&plist, 2);//plist是实参  phead是形参   都是头指针把plist的地址传递给了pphead
	SLTPushBack(&plist, 3);

	SLTPrint(plist);

	SLTPushFront(&plist,0);
	SLTPushFront(&plist,-1);
	SLTPushFront(&plist,-2);

	SLTPrint(plist);
}
int main()
{
	test();
	return 0;
}

​

如果这里用一级指针，虽然可以创建一个链表，但是这是形式参数，出了作用域就会销毁，回来后会发现原来的plist链表依旧为空，不会传递给外面的plist头指针，更别说将其进行其他操作，所以必须传二级指针（pphead是形参，plist是实参），通过对地址进行传地址才能外部链表里面的值。

尾插

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
     SLTNode* newnode = BuyListNode(x);

	if (*pphead == NULL)//*pphead就是plist的地址
	{
		*pphead = newnode;//newnode的地址传给plist
	}
	else//找到尾结点
	{

		SLTNode* tail =*pphead;
		
		while (tail->next)//找到尾结点
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

尾插就是在尾部插入一个新节点，由于我们的链表不支持随机访问，所以不能直接找到尾部的元素，我们只能定义一个tail变量来遍历链表，直到找的的 tail->next==NULL为止。

在给定位置之前插入

// 在pos位置之前去插入一个节点 （更少用）  O(n)
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	SLTNode* newnode = BuyListNode(x);//创建一个新的结点
	if (*pphead == pos)
	{
		newnode->next = *pphead;//指向头
		*pphead=newnode;//让newnode变成头指针
	}
	else
	{    //找到pos的前一个位置
		SLTNode* posPrev = *pphead;//posPrev是pos的前一个位置的地址
		while (posPrev->next != pos)
		{
			posPrev = posPrev->next;
		}
		posPrev->next = newnode;
		newnode->next = pos;
	}
	
}

在给定位置之后插入

// 在pos的后面插入，这个更适合，也更简单   O(1)
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	SLTNode* newnode=BuyListNode(x);
	newnode->next = pos->next;
	pos->next=newnode;

}

链表结点的删除

头删

//头删
void SLTPopFront(SLTNode** pphead, SLTDataType x)
{
	assert(*pphead);//判断是否为空
	SLTNode* next = (*pphead)->next;//记录第一个结点的位置
	                                
	free(*pphead);
	*pphead = next;//让头指针指向第二个结点
}

尾删

//尾删
void SLTPopBack(SLTNode** pphead, SLTDataType x)
{
	//表为空时
	assert(*pphead);
	//只有一个结点时
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else//两个结点以上的情况
	{
		SLTNode* prev = NULL;
		SLTNode* tail = *pphead;//接收第一个结点的地址
		while (tail->next)//当tail找到最后一个结点时停止
		{
			prev = tail;//使prev始终指向tail的前一个结点
			tail = tail->next;
		}
		这样写，上一个结点的next就是野指针     所以要分类讨论
		free(tail);//释放最后一个结点
		tail = NULL;//及时置空
		prev可能为空指针
		prev->next = NULL;//将倒数第二个结点的指针域置空，使它变成最后一个新结点
	}
}

尾删相对复杂一些，我们需要考虑三种特殊情况：

①当链表为空时，不做处理。
②当链表中只有一个结点时，直接释放该结点，然后将头指针置空。
③当链表中有多个结点时，我们需要先找到最后一个结点的前一个结点，然后将最后一个结点释放，将前一个结点的指针域置空，使其成为新的尾结点。

第三种情况下，我们需要新定义两个指针变量，tail(找到尾)和prev（保存tail的上一个结点的地址） 。

删除给定位置的结点

//删除给定位置的数据
void SLTErase(SLTNode** pphead,SLTNode* pos)
{
	if (*pphead == pos)//头删  可以直接调用头删函数
	{
		*pphead = pos->next;
		free(pos);
	}
	else//其余pos位置删除
	{
		SLTNode* prev = *pphead;
		while (prev->next!=pos)
		{
			prev->next = pos->next;
			free(pos);
		}
	}

}

查找数据

//查找函数
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

 不涉及数据的改变，只需要传一级指针即可完成。新定义一个cur指针进行遍历即可。

修改数据

//修改指定位置pos的数据
void SListmodify(SLTNode* pos, SLTDataType x)
{
	pos->data = x;
}

销毁链表

//销毁函数
void SLTDestory(SLTNode**pphead)
{
	assert(*pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

我们最开始可能由于惯性思维，直接free（*pphead）但是这样做的话，只将第一个结点给free，而且找不到后面的所有结点，会造成内存泄漏问题，这是不允许的。我们需要新定义一个cur指针变量先存头指针，再遍历free即可，最后将头置为空即可。

谢谢大家的观看！