1. Toy模板网首页
  2. > Toy博客

【数据结构】吃透单链表！！！（详细解析~）

9月前 作者：～yY…s<#> 分类：Toy博客 阅读(39) 违法举报

这篇具有很好参考价值的文章主要介绍了【数据结构】吃透单链表！！！（详细解析~）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

前言：

上篇文章介绍了顺序表，这篇文章开始着重讲解链表了。
链表有很多种：单、双链表，循环、非循环链表还有带头、不带头的链表。本篇的主要内容是单链表（无头，单向，非循环）。
链表对比顺序表有哪些不同之处，接下来会带大家一起了解~

一.顺序表的缺陷 && 介绍链表

1.顺序表的缺陷

1.头部和中间的插入删除效率都较低，时间复杂度为O(N)。需要挪动数据。
2.空间不够用了，增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。（尤其是异地扩容）
3.扩容会有一定的空间浪费。（例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间）

2.介绍链表

针对顺序表的缺陷，就有了链表这个数据结构

（1）链表的概念

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
特点：按需申请释放
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言

顺序表是数组存储数据的，空间是连续的（可通过一个指针找到所有的值），通过size标记直到没有数据（前面的为size的个数即有效数据）。
链表的每个节点的大小没有关系，也不连续（多次malloc开辟出来的空间是随机的）。它是通过一个头指针（phead）先找到第一个节点，然后通过第一个节点的指针找到第二个节点，第二个节点的指针找到第三个节点，以此类推（通过指针链接）。每个位置的节点都有指针指向下一个，当下一个为空指针的时候，就结束。

（2）链表的结构

物理图：
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言
逻辑图：
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言
链表的节点组成（单链表）：
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言

注意：链表的最后一个节点的next指向空

看到这有些小伙伴可能有些疑惑，链表的每个节点是不连续的，为什么上面的两个图中每个节点都有线连接起来变成看似连续的呢？其实不是这样的，以上的两张图是为了方便理解。实际在内存中每个节点的地址是随机的，只不过用这个节点的指针（next）找到了下一个节点的地址，所以才能实现链接。

（3）链表的功能

链表的功能与顺序表类似，无非是增删查改，在某位置的插入与删除，对数据内容进行管理和操作。

二.单链表的实现

还是以多文件的形式分模块写

SList.h——函数和类型的声明
SList.c——函数的实现
Test.c——进行测试

1.创建节点的结构

单链表一个节点的结构：

存放数据：data
结构体指针：next

注意：不能这样写：

typedef int SListDataType;//方便更改存储的数据类型
typedef struct SListNode
{
	SListDataType data;
	SLTNode* next;
}SLTNode;//  <-重定义开始生效的位置

因为typedef重定义结构体类型的名称是在上面有箭头的一行开始生效，生效了才能使用，在前面就提前使用就会出现错误。

正确写法：

typedef int SListDataType;//方便更改存储的数据类型
typedef struct SListNode
{
	SListDataType data;
	struct SListNode* next;
}SLTNode;

2.头文件函数的声明

1.打印单链表
2.创建一个节点
3.尾插
4.头插
5.尾删
6.头删
7.查找（包含修改）
8.在pos位置前插入
9.在pos位置后插入
10.删除pos位置的节点
11.删除pos位置后一个的节点
12.清理单链表

//打印单链表
void SLTPrint(SLTNode* phead);
//创建一个节点
SLTNode* BuySLTNode(SListDataType x);
//尾插
void SLTPushBack(SLTNode** pphead, SListDataType x);
//头插
void SLTPushFront(SLTNode** pphead, SListDataType x);
//尾删
void SLTPopBack(SLTNode** pphead);
//头删
void SLTPopFront(SLTNode** pphead);
//查找
SLTNode* SLTFind(SLTNode* phead, SListDataType x);
//在pos位置前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SListDataType x);
//在pos位置后插入
void SLTInsertAfter(SLTNode* pos, SListDataType x);
//删除pos位置的节点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//删除pos位置后一个的节点
void SLTEraseAfter(SLTNode* pos);
//清理单链表
void SLTDestroy(SLTNode** pphead);

3.函数的实现

（1）打印单链表

创建一个结构体指针变量（cur），使它指向第一个节点（把头指针覆给cur）。利用循环如果cur不是空指针，就打印cur所指向的数据，然后cur往后走（到下一个节点）。直到cur为空跳出，最后打印NULL（最后一个节点为空指针）。

逻辑图：
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言
物理图：
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言
注意：与顺序表不同，顺序表传过来的指针一定不为空；链表传过来的指针可能为空，比如链表没有节点，头指针指向的就是NULL，所以不需要断言头指针。

所以在测试的文件里（Test.c）刚开始要让头指针指向NULL

SLTNode * plist = NULL;

void SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

（2）创建一个节点

为了方便后面的尾插、头插等操作，所以写个函数来创建一个新节点。
新节点的类型也是结构体指针，用malloc函数开辟一个新节点。如果新节点为空就报错。然后给新节点的data赋值，next为空，返回这个节点（方便其他的函数使用）

SLTNode* BuySLTNode(SListDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

（3）尾插

尾插一个新节点，假设有多个节点，首先要找到尾，定义一个变量tail去遍历链表找到尾
注意：用tail遍历找尾再尾插时不能写成：

       SLTNode* tail = *pphead;
       while (tail)
		{
			tail = tail->next;
		}
		tail = newnode;

这段代码看似没有什么问题，其实是与正确的代码差别很大。
tail刚开始指向第一个节点，如果不为空，到下一个节点；当tail为空时跳出循环，把newnode的值（新节点的地址）赋给tail。
如图：
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言
这里有一个问题，tail里面存放的是新节点的地址，但是原来链表的最后一个节点的next指针并没有存放新节点的地址，也就是说最后一个节点没有与新节点连接起来，就没有尾插了。其次还有可能存在内存泄漏，新创建的节点丢了。

因为tail是局部变量，newnode和phead也是，它们出这个函数就销毁了，所以给tail这个变量赋新节点的地址没有用。

要成功完成尾插，就必须改变结构体的内容，让最后一个节点的next指针指向新节点的地址。

这里大家可能有些疑惑，既然tail销毁了，那么链表的这些节点会不会销毁呢？
答案是不会，因为这些节点是malloc出来的，malloc在堆上开辟的空间，只有自己主动free释放掉才能销毁。

正确的思路：
首先想到的是要改变结构体（节点）的内容，那么tail这个指针变量就不能到空结束，而是到最后一个节点结束（tail的next为空就结束，tail的位置指向最后一个节点）。

此时尾节点的next为空，我们要做的是让尾节点的next存放新节点的地址。让tail的next存放newnode的值（新节点的地址），就可以改变结构体的内容。
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言

找尾尾插正确的一小段代码：

		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;

还有一种情况，如果刚开始链表没有节点，就不需要找尾了。直接将新节点的地址给头指针（plist）就行

但是这种情况要注意什么呢？
以下是错误示范：

	if (phead == NULL)
	{
		phead = newnode;
	}

这个代码的意思如图所示：
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言
有两个问题：
一：plist没有改变，还是指向空指针；新节点丢了，可能造成内存泄漏。
二：newnode和phead是形参，形参是实参的拷贝，出这个函数就销毁了，改变phead并没有改变plist。

注意！！！：plist是一级指针，改变一级指针需要用到二级指针，并且有解引用操作。所以在函数的参数应该用二级指针来接收（传参时plist要有取地址符才能与二级指针类型对应）
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言
正确的一小段代码：

	if (*pphead == NULL)
	{
		*pphead = newnode;
	}

总结：
1.改变结构体，要用结构体指针
2.改变结构体指针，要有结构体指针的指针（即二级指针）

最后一点：什么时候要断言指针
当一级指针（* pphead）为空时不需要断言，因为如果刚开始链表没有节点，* pphead所指向的就是空指针。二级指针pphead存放的是一级指针的地址，一级指针的地址不可能为空，所以二级指针需要断言。

void SLTPushBack(SLTNode** pphead, SListDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);
	//原来没有节点，改变结构体指针，用二级指针
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	//原来有节点，改变结构体，用结构体指针
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

（4）头插

头插也需要用到二级指针，因为每次头插头指针（plist）都要连接新的节点。（改变了头指针）
头插时原来链表没有节点与原来链表有节点的思路是一样的
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言
新节点先连接第一个节点或者空指针，然后plist再连接新节点

注意：两者的顺序不能换，因为如果先让plist连接newnode，那么原来链表plist头指针后面的节点就找不到了。newnode再连接plist所指向的下一个节点就是自己，导致死循环。

void SLTPushFront(SLTNode** pphead, SListDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

（5）尾删

前面的尾插、头插都有用到二级指针，那么尾删需不需要二级指针呢？接下来我们一点一点的分析：

尾删的大体思路是：找到尾，然后free释放掉尾节点就行。

但是链表有一个很重要的点：前后关联

这里我们定义一个指针变量tail去找尾，把尾节点删掉了，那么原来前一个节点变成新的尾节点，还需要用另一个变量当作原来尾节点的前一个节点，新的尾节点next指针就必须指向NULL（只需要改变结构体），否则就访问野指针了。
有两种写法，这里只展现一种，就用tail一个指针变量，让它的下一个的下一个指针为空时停下（tail->next->next==NULL），此时tail->next就是最后一个节点，tail是前一个节点，修改新的尾节点的next，让tail->next为NULL（改变结构体）就行了。

以上只是包括一类情况：一个以上节点的时候是这样的
如果尾删把节点只删到剩下一个节点时，还是如此吗？

【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言
按前面的思路来走，遇到尾节点就把它的前一个节点的next置空。

依图分析，只有一个节点时，前一个节点就不是节点了，是头指针。要让头指针指向NULL，即改变头指针，就要用到二级指针了。
让 * pphead置空，就可以改变头指针

plist 等价于 * pphead

没有节点的情况：
断言 * pphead，为空就不能再删了

void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	//空
	assert(*pphead);
	//一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//一个以上的节点
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next->next)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

（6）头删

通过前面的分析发现，有改变头指针所指向的内容就要用到二级指针，头删是把第一个节点除去，让头指针指向新的头节点。

画图分析：
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言
当链表没有节点时不能再删了，所以要对 * pphead断言（ * pphead等价于plist即第一个节点）

只有一个节点和有多个节点不需要分开处理，定义一个变量记录原来链表的第二个节点（新的头节点），free释放掉第一个节点，让头指针连接新的头节点

void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);
	//空
	assert(*pphead);
	//非空
	SLTNode* newhead = (*pphead)->next;//注意优先级
	free(*pphead);//不需要置空，因为头指针直接连接新的头
	*pphead = newhead;
}

（7）查找

定义一个变量cur遍历链表，先判断cur所指向的数据是否等于x，如果相等，返回cur，否则往后走；找不到返回空指针。

SLTNode* SLTFind(SLTNode* phead, SListDataType x)
{
	assert(phead);
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

查找可以包含修改这个节点的数据

	SLTNode* pos1 = SLTFind(plist, 2);//测试查找+修改
	if (pos1 != NULL)
	{
		printf("找到了\n");
		pos1->data *= 100;
		SLTPrint(plist);
	}
	else
	{
		printf("找不到\n");
	}

（8）在pos位置前插入

要在pos位置前插入一个新节点，首先pos这个位置的节点必须存在，所以要断言pos（后面有pos位置插入删除的函数也要用到）
pos可能在任意一个位置，如果pos在第一个节点，就相当于头插了。头插要改变头指针所指向的内容，所以要用二级指针。直接调用头插的函数即可。

pos不在第一个节点的情况：
首先要定义一个变量prev，遍历链表找到并指向pos的前一个节点，因为插入新的节点必须前后连接起来（单链表的不足之处，后期文章用双向循环带头链表就非常简单）。
当prev->next ！= pos，往后走；==pos时跳出循环，让prev->next连接新节点，新节点的next连接pos，完成插入。
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言

void SLTInsert(SLTNode** pphead, SLTNode* pos, SListDataType x)
{
	assert(pphead);
	assert(pos);
	//pos在第一个节点就是头插
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySLTNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

（9）在pos位置后插入

因为在pos位置后插入新的节点，所以可以不用头指针了，找到pos位置的下一个节点即可。可以定义一个变量posNext为pos位置的下一个节点，让新节点的next连接posNext，pos->next连接新节点
不需要考虑是不是尾插，因为在哪插入都是一样的
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言

void SLTInsertAfter(SLTNode* pos, SListDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	SLTNode* posNext = pos->next;
	newnode->next = posNext;
	pos->next = newnode;
}

（10）删除pos位置

删除pos位置的节点，必须把它的前一个节点与后一个节点连接起来，这里就要有头指针，去找pos位置的前一个节点。
我们要考虑一些情况，pos在第一个节点、中间某个节点和尾节点

当pos在第一个节点时，就是头删，要改变头指针指向的内容，所以要用二级指针，然后调用头删的函数即可

如果pos是在中间的某个节点或者尾节点呢？
其实两者的思路是一致的，把pos位置的节点删除，让前一个节点连接后一个节点就行（是尾节点的话，让前一个节点连接空指针）
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

（11）删除pos位置后的节点

要删除pos位置的后一个节点，除了pos这个位置要存在之外，pos位置的后一个节点也必须存在，所以pos->next要断言。假如pos是在尾节点，就没有意义了。

定义一个变量posNext为pos的下一个节点，然后使pos->next指向posNext->next，即把pos位置的节点与posNext的下一个节点连接起来，最后释放掉posNext

【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);//检查是否为尾节点
	SLTNode* posNext = pos->next;
	pos->next = posNext->next;
	free(posNext);
	posNext = NULL;
}

（12）清理单链表

清理（销毁）链表，必须要一个一个节点清理，因为链表在物理结构上是不连续的。

定义一个变量cur遍历链表，每到一个节点把它释放掉。但是这里又有一个问题，当前节点被释放了，怎么到下一个节点呢？所以我们循环里再定义一个变量next为cur的下一个节点，释放完当前的cur，然后把next赋给cur，这样cur就能到下一个节点了。

最后全部节点释放完，头指针要指向空，这里又有改变头指针了，所以有二级指针。
【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言

void SLTDestroy(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

三.全部代码

1.SList.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SListDataType;//方便更改存储的数据类型
typedef struct SListNode
{
	SListDataType data;
	struct SListNode* next;
}SLTNode;
//打印单链表
void SLTPrint(SLTNode* phead);
//创建一个节点
SLTNode* BuySLTNode(SListDataType x);
//尾插
void SLTPushBack(SLTNode** pphead, SListDataType x);
//头插
void SLTPushFront(SLTNode** pphead, SListDataType x);
//尾删
void SLTPopBack(SLTNode** pphead);
//头删
void SLTPopFront(SLTNode** pphead);
//查找
SLTNode* SLTFind(SLTNode* phead, SListDataType x);
//在pos位置前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SListDataType x);
//在pos位置后插入
void SLTInsertAfter(SLTNode* pos, SListDataType x);
//删除pos位置的节点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//删除pos位置后一个的节点
void SLTEraseAfter(SLTNode* pos);
//清理单链表
void SLTDestroy(SLTNode** pphead);

2.SList.c

#include "SList.h"
//打印
void SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}
//创建一个节点
SLTNode* BuySLTNode(SListDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
//尾插
void SLTPushBack(SLTNode** pphead, SListDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);
	//原来没有节点，改变结构体指针，用二级指针
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	//原来有节点，改变结构体，用结构体指针
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}
//头插
void SLTPushFront(SLTNode** pphead, SListDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}
//尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	//空
	assert(*pphead);
	//一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//一个以上的节点
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next->next)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}
//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);
	//空
	assert(*pphead);
	//非空
	SLTNode* newhead = (*pphead)->next;//注意优先级
	free(*pphead);//不需要置空，因为头指针直接连接新的头
	*pphead = newhead;
}
//查找
SLTNode* SLTFind(SLTNode* phead, SListDataType x)
{
	assert(phead);
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
//在pos位置前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SListDataType x)
{
	assert(pphead);
	assert(pos);
	//pos在第一个节点就是头插
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySLTNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}
//在pos位置后插入
void SLTInsertAfter(SLTNode* pos, SListDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	SLTNode* posNext = pos->next;
	newnode->next = posNext;
	pos->next = newnode;
}
//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
//删除pos位置后的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);//检查是否为尾节点
	SLTNode* posNext = pos->next;
	pos->next = posNext->next;
	free(posNext);
	posNext = NULL;
}
//清理
void SLTDestroy(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

3.Test.c

#include "SList.h"
test()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);//测试尾插
	SLTPrint(plist);

	SLTPushFront(&plist, 10);
	SLTPushFront(&plist, 20);
	SLTPushFront(&plist, 30);
	SLTPushFront(&plist, 40);//测试头插
	SLTPrint(plist);

	SLTPopBack(&plist);
	SLTPopBack(&plist);
	SLTPopBack(&plist);//测试尾删
	SLTPrint(plist);

	SLTPopFront(&plist);
	SLTPopFront(&plist);//测试头删
	SLTPrint(plist);

	SLTNode* pos1 = SLTFind(plist, 2);//测试查找+修改
	if (pos1 != NULL)
	{
		printf("找到了\n");
		pos1->data *= 100;
		SLTPrint(plist);
	}
	else
	{
		printf("找不到\n");
	}

	SLTNode* pos2 = SLTFind(plist, 10);//测试pos位置前插入
	if (pos2)
	{
		SLTInsert(&plist, pos2, 66);
		SLTPrint(plist);
	}

	SLTNode* pos3 = SLTFind(plist, 20);//测试pos位置后插入
	if (pos3)
	{
		SLTInsertAfter(pos3, 77);
		SLTPrint(plist);
	}

	SLTNode* pos4 = SLTFind(plist, 1);//测试删除pos位置
	if (pos4)
	{
		SLTErase(&plist, pos4);
		SLTPrint(plist);
	}

	SLTNode* pos5 = SLTFind(plist, 66);//测试删除pos位置的后一个节点
	if (pos5)
	{
		SLTEraseAfter(pos5);
		SLTPrint(plist);
	}

	SLTDestroy(&plist);
}
int main()
{
	test();
	return 0;
}

【数据结构】吃透单链表！！！（详细解析~）,数据结构,c语言,开发语言
总算把最费劲的写完了，感谢铁子们的观看，期待大家的支持~文章来源地址https://www.toymoban.com/news/detail-659567.html

到了这里，关于【数据结构】吃透单链表！！！（详细解析~）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【C语言】数据结构-单链表

    主页：114514的代码大冒险 qq:2188956112（欢迎小伙伴呀hi✿(。◕ᴗ◕。)✿ ） Gitee：庄嘉豪 (zhuang-jiahaoxxx) - Gitee.com 文章目录 目录 文章目录 前言（链表的优势） 一、单链表是什么 二、单链表操作的具体代码实现 1.准备工作 2.打印链表 2.尾插（在链表末端添加数据） 3、头插（

    2024年02月02日
    浏览(46)
  • 数据结构——单链表（C语言）

    数据结构——单链表（C语言）

    在这⼀条⼗分漫长的路上，我⾛过阳关⼤道，也⾛过独⽊⼩桥。路旁有深⼭⼤泽，也有平坡宜⼈；有杏花春⾬，也有塞北秋风；有⼭重⽔复，也有柳暗花明；有迷途知返，也有绝处逢⽣。——《⼋⼗述怀》 目录 一 . 什么是链表？ 二 . 实现单链表 （1）创建相关源文件和头文

    2024年02月08日
    浏览(115)
  • 单链表—C语言实现数据结构

    单链表—C语言实现数据结构

    本期带大家一起用C语言实现单链表🌈🌈🌈 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的；简单来说，线性表的链式存储结构生成的表，称作“链表”。 每个元素本身由两部分组成： 1、本身的信息，称为

    2024年02月07日
    浏览(83)
  • C语言：数据结构之单链表（二）

    C语言：数据结构之单链表（二）

    上一篇随笔谈了谈单链表是什么东西，然后进行了初始化，这篇随笔就开始对其进行操作了，首先是增，删，改，查的增。 增，顾名思义就是要增加新的元素，单链表是链式的，那就要考虑怎么去加新元素，有三种，从头部添加，从尾部添加，从中间添加。先说说从尾部添加

    2024年02月12日
    浏览(40)
  • ＜数据结构＞ 链表 - 单链表（c语言实现）

    ＜数据结构＞ 链表 - 单链表（c语言实现）

    哨兵位结点也叫哑节点。哨兵位结点 也是头结点 。该节点 不存储有效数据，只是为了方便操作 （如尾插时用带哨兵位的头结点很爽，不需要判空）。 有哨兵位结点的链表，第一个元素应该是链表第二个节点（head - next，head为哨兵位结点）对应的元素。 有哨兵位结点的链表

    2023年04月11日
    浏览(134)
  • C语言：数据结构之单链表（一）

    C语言：数据结构之单链表（一）

    当初刚开始学单链表学的是一头雾水，简直就是彻头彻尾灾难，一塌糊涂，过段时间后经过自己的重新认真思考再结合小练习明白了它是怎么个回事儿。 1、首先从它的逻辑上入手，对他有大体认知。 简单来说就是一个一个有方向小块儿连在一起，好像疫情期间大家排队做核

    2024年02月12日
    浏览(77)
  • C语言：数据结构之单链表（三）

    C语言：数据结构之单链表（三）

    上篇谈了谈尾插法和头插法，这篇谈谈中间插入元素和删除。 1、中间插入元素 既然谈到了要从中间插入那就得确定插入的位置是否合法了，我总不能链表总长为5，但是插入的位置是60，这就不对了。所以得先确定这个链表的长度为多少。这个比较简单，就是在寻找尾部的过

    2024年02月13日
    浏览(43)
  • C语言：数据结构之单链表（四）

    C语言：数据结构之单链表（四）

    本篇谈一谈单链表的 改 ，具体操作就是找到他，然后修改元素即可，上一篇有相关代码，可以参考。 改函数代码如下： main函数如下：（修改第6,8,3位） 结果如下：   至此，单链表的增删改查就谈完了，只需理解它的本质是干什么，代码就很好写了。 总结：①改比较简单，

    2024年02月16日
    浏览(43)
  • 数据结构之单链表非常详细介绍(适合小白）

    数据结构之单链表非常详细介绍(适合小白）

    之前有一篇文章介绍完顺序表，可以点击(顺序表文章)即可看到顺序表的知识后，我们就要开始学习链表了，链表的种类有很多，比如说 单链表 、 双向链表 、 循环或者非循环链表 以及 带头或者不带头链表等 ，那么链表和顺序表有哪些不同呢，相较于顺序表，链表做了哪些

    2024年02月06日
    浏览(41)
  • 【数据结构】移除链表元素-图文解析（单链表OJ题）

    【数据结构】移除链表元素-图文解析（单链表OJ题）

    LeetCode链接：203. 移除链表元素 - 力扣（LeetCode） 本文导航 💭做题思路 🎨画图更好理解： ✍️代码实现 🗂️分情况讨论： ❄️极端情况： 遍历链表，找到值为 val 的节点删除 这里需要两个指针  cur 用来遍历链表  prev 指向 cur 的前一个位置，方便删除一个节点后，链接前

    2024年02月14日
    浏览(35)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包