初识单链表

已于 2024-02-11 15:12:47 修改
阅读量582 收藏 13
点赞数 19
文章标签： c语言 数据结构
于 2024-02-11 15:01:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73383358/article/details/136082849
版权

        大家好呀，今天我们来认识一下单链表。

单链表

目录

单链表

 对链表的认识

 创建单链表

 头插，尾插

 头删，尾删

 在任意位置前插入和删除

 查找

完整代码 

list.h 

 list.c

 test.c

 小结

 对链表的认识

        相比于顺序表，链表就相当于是申请了一个个内存块，用指针来进行访问，这一个个内存块也被称作一个个节点。节点与节点之间是没有关联的。就好比我申请了4个内存块，我要创建链表，那么我就在第一个内存块里存放第二个内存块的地址，第二个存放第三个的，依次内推。当然，链表的尾部也可以存放头部的地址，那就是循环链表了。我们今天先来认识一下单链表。

        对于链表来说插入和删除就比较简单了，我若想在头部插入，那么我可以让我想插入的节点存放原来的头节点的地址。在中间插入时，让上一个节点存放该节点的地址，该节点存放原来的下一个节点的地址。删除也是同理，只需要改变指针的指向就可以了，不需要挪动数据。

 创建单链表

        那么接下来我们就来创建单链表。

        首要的便是结构体存放数据，对于单链表，只需要元素和指针（指针当然得是结构体指针）。代码如下：

typedef struct SListNode
{
	int val;
	struct SListNode* next;
}SLNode;

        与顺序表一样，单链表的功能也有头插，头删；尾插，尾删；在任意位置插入和删除和查找位置。在编写单链表功能之前，我们先编写打印函数练习下手感。

        如何来编写打印函数呢，既然有指针，在非NULL的情况下，把phead（头节点）的地址给一个变量，让其循着指针依次遍历就可以了，达到尾节点指向的NULL结束。代码如下：

void SLPrint(SLNode* phead)
{
	SLNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d ", cur->val);
		cur = cur->next;
	}
}

 头插，尾插

        我们先来编写尾插函数。

        既然要尾插，那么找到尾部是必须的。如何找尾呢？我们定义一个指针变量tail，把头节点的地址赋给它。当tail的next指向空的时候，tail所指向的就是尾节点。

        既然要尾插，那么就需要创建新的节点。要创建一个新节点，那么就用malloc来开辟空间。开辟成功进行赋值，开辟失败进行提醒，退出。代码如下：

//创建新节点
SLNode* CreateNode(SLNDataType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->val = x;
	return newnode;
}

        我们再来考虑尾插，尾插有两种情况：一是链表为空，二是链表不为空。如果链表不为空让原来的尾节点指向该节点，让该节点的next指向空，尾插结束。 代码如下：

        

void SLPushBack(SLNode* phead, SLNDataType x)
{
	SLNode* tail = phead;
	while (tail->next != NULL)
	{
		tail = tail->next;
	}
	SLNode* newnode = CreateNode(x);
	tail->next = newnode;
}

        如果链表为空,这时我们就会发现，先要改变phead，就需要二级指针，因此我们就对传参进行修改。代码如下：

void SLPushBack(SLNode** pphead, SLNDataType x)
{
	SLNode* newnode = CreateNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
}

        修改后的整体代码如下：

void SLPushBack(SLNode** pphead, SLNDataType x)
{
	SLNode* newnode = CreateNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

        接下来就是头插。

        有了尾插的经验。我们首先进行考虑，头插是不是需要二级指针来进行改变呢？很明显这是需要的，头插时需要把原来头部位置的地址给新的头部，那么就需要二级指针来进行接收，我们改变参数。编写完成后改变头节点。

        当然此时我们就会思考一个问题，头插是否需要考虑链表为空的问题呢？其实是不需要的，因为在头插时，是将头节点指向原来的头节点，之后再将原来的头节点进行替换就不需要考虑对空指针的解引用的问题。代码如下：

void SLPushFront(SLNode** pphead, SLNDataType x)
{
	SLNode* newnode = CreateNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

 头删，尾删

        接下来就是头删和尾删。 

        我们先来编写尾删。

        尾删又该如何考虑呢？那么是不是把尾部位置直接free掉就可以了？当然不是，如果直接free，那么前一个节点就会变成野指针。所以最好用快慢指针进行标记。

        比如创建prev和tail两个快慢指针，当tail的next指向空的时候，那么tail就在尾部的位置，prev就在前一个节点。这时我们再把tail的位置释放，让prev位置的指针指向NULL，编写完成。当然，这时我们又得考虑链表为空或者只有一个节点的情况,为空的话就没必要删除节点了,进行检查。代码如下：

void SLPopBack(SLNode** pphead)
{
	SLNode* prev = NULL;
	SLNode* tail = *pphead;
	while (tail->next != NULL)
	{
		prev = tail;
		tail = tail->next;
	}
	free(tail);
	tail = NULL;
	prev->next = NULL;
}

        那么继续来考虑只有一个节点的情况。

        如果只有一个节点那么tail的next就指向空了，这时prev->next就没有了意义。因此需要重新进行判断。只有一个节点的话，删掉并制空就可以了。代码如下：

void SLPopBack(SLNode** pphead)
{
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
}

        整体代码如下：

//尾删
void SLPopBack(SLNode** pphead)
{
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLNode* prev = NULL;
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		prev->next = NULL;
	}
}

        之后便是头删。

        头删的思路比较简单，将头节点的地址先保存，让头节点指向下一个然后释放保存地址的空间就可以了。代码如下：

void SLPopFront(SLNode** pphead)
{
	assert(*pphead);
	SLNode* prev = (*pphead)->next;
	free(pphead);
	pphead = NULL;
}

 在任意位置前插入和删除

        首先来编写在任意位置进行插入。

        既然在任意位置进行插入，那么自然就包括头插，中间插入。但不推荐尾插，因为是在任意位置前进行插入。头插我们直接调用头插函数即可。在中间进行插入的话首先得找到上一个节点，让上一个节点指向该节点，该节点指向下一个节点。

        紧接着考虑如何进行传参，**pphead铁定是不会变的，但不妨碍不嫌事大者会传个NULL过去，因此先来断言一下。接下来就来考虑指定位置的pos，为了和stl库对齐，pos还是写成结构体指针,当然也是为了方便进行查找。那么pos可能会为空吗？是可能的，如果在*pphead和pos都为空，那么情况就变成了头插。但要是一个为空另一个不为空程序就会崩掉，因此我们得进行断言。我们按照思路编写代码。代码如下：

void SLTInsert(SLNode** pphead, SLNode* pos, SLNDataType x)
{
	assert(pphead);
	assert((!(*pphead) && !pos) || (pos && *pphead));
	//头插
	if (*pphead == pos)
	{
		SLPushFront(pphead, x);
	}
	//中间插入
	else
	{
		SLNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLNode* newnode = CreateNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

        接下来就是在任意位置前删除。那么这段代码该如何进行编写呢？其实思路都是大差不差的，找到前一个节点，让他指向删除节点的下一个节点。之后再对删除节点进行释放就可以了。接着我们对特殊情况进行考虑，若是链表只有一个节点的话，那么pos的next就会指向空了。因此首先得进行判断，若是只有一个节点，那么直接调用头删函数。代码如下：

        

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

 查找

        查找函数比较简单，只需要遍历一遍，找到时返回该节点的地址就可以了,没找到返回NULL。当然，为空不需要查找，需要判断。代码如下：

SLNode* SLTFind(SLNode* phead, SLNDataType x)
{
	assert(phead);
	SLNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->val == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

完整代码 

list.h 

#pragma once


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

typedef int SLNDataType;

typedef struct SListNode
{
	int val;
	struct SListNode* next;
}SLNode;


//遍历
void SLPrint(SLNode* phead);

//尾插
void SLPushBack(SLNode** pphead, SLNDataType x);

//头插
void SLPushFront(SLNode** pphead, SLNDataType x);

//尾删
void SLPopBack(SLNode** pphead);

//头删
void SLPopFront(SLNode** pphead);

//任意位置之前插入
void SLTInsert(SLNode** pphead, SLNode* pos, SLNDataType x);

//任意位置删除
void SLTErase(SLNode** pphead, SLNode* pos);

//查找
SLNode* SLTFind(SLNode* phead, SLNDataType x);

 list.c

#include"list.h"

//遍历
void SLPrint(SLNode* phead)
{
	SLNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d-> ", cur->val);
		cur = cur->next;
	}
}

//创建新节点
SLNode* CreateNode(SLNDataType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->val = x;
	return newnode;
}

//尾插
void SLPushBack(SLNode** pphead, SLNDataType x)
{
	SLNode* newnode = CreateNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

//头插
void SLPushFront(SLNode** pphead, SLNDataType x)
{
	SLNode* newnode = CreateNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

//尾删
void SLPopBack(SLNode** pphead)
{
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLNode* prev = NULL;
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		prev->next = NULL;
	}
}

//头删
void SLPopFront(SLNode** pphead)
{
	assert(*pphead);
	SLNode* prev = (*pphead)->next;
	free(pphead);
	pphead = NULL;
}

//任意位置之前插入
void SLTInsert(SLNode** pphead, SLNode* pos, SLNDataType x)
{
	assert(pphead);
	assert((!(*pphead) && !pos) || (pos && *pphead));
	//头插
	if (*pphead == pos)
	{
		SLPushFront(pphead, x);
	}
	//中间插入
	else
	{
		SLNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLNode* newnode = CreateNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

//任意位置删除
void SLTErase(SLNode** pphead, SLNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	if (*pphead == pos)
	{
		SLPopFront(pphead);
	}
	else
	{
		SLNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

//查找
SLNode* SLTFind(SLNode* phead, SLNDataType x)
{
	assert(phead);
	SLNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->val == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

 test.c

#include"list.h"

void Test1()
{
	SLNode* plist = NULL;
	//调用函数进行测试
	SLPushBack(&plist, 1);
	SLPushBack(&plist, 2);
}


int main()
{
	Test1();

	return 0;
}

 小结

         单链表就结束啦，单链表的编写的坑有点多。因此需要进行再三考虑，特别是在对任意位置插入时对pos和pphead为空的检查判定。好啦，单链表就到这里啦。另外祝大家新年快乐！

玄冥洛璃
关注
java 初识单链表
qq_43045259的博客
04-19 109
一、单链表是什么？ 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 现有一包糖果，班上共有三十六名同学，从第3个人数开始，每两个发两个糖果，问最后哪位同学没有糖果？请用程序计算出来。 创建NewBoy...
C语言（16）——初识单链表
2301_80065652的博客
08-17 406
1、链式机构在逻辑上是连续的，在物理结构上不⼀定连续2、节点⼀般是从堆上申请的3、从堆上申请来的空间，是按照⼀定策略分配出来的，每次申请的空间可能连续，可能不连续。
初识单链表/单链表头指针的创建
m0_73265646的博客
12-16 1985
无头单向非循环链表头指针的实现
大话数据结构4 - 初识单链表
高冷的上官梓芸的博客
04-06 1482
用C语言理解 单链表 的创建、删除、插入！
数据结构(八)——初识单链表
业精于勤，荒于嬉
03-07 910
本文介绍了单链表作为一种基本的链表结构，在数据结构中的重要性和应用。我们了解了单链表节点的组成和节点之间逻辑关系的表示方式，以及头指针和头结点的概念。通过学习单链表，我们可以实现各种常见的链表操作，如插入、删除和查找元素。同时，我们也了解到单链表的一些优点和缺点，这有助于我们在实际应用中选择适合的数据结构。掌握单链表的基本概念和操作是学习和理解更复杂的数据结构的基础。在接下来的学习中，我们将进一步深入探讨链表相关的知识，并学习更多高级的数据结构和算法。😁热门专栏推荐想学习vue的可以看看这个。
初识单链表--创建、插入、遍历
qq_41570500的博客
04-14 864
    前两天由于"q-&gt;next=p-&gt;next; p-&gt;next=q;"这两句代码的困扰，花了两天时间也算是搞清楚一点，记录下来与大家一起分享。该篇的核心内容在于：链表中每一个节点的"原生输出"与使用头指针访问的形式"遍历输出"头节点引入的目的、意义链表的遍历是如何一步一步演化成为我们所看到的样子的一、创建链表注意：一个链表中可以没有头结点，但是绝对不可能没有头指针的。链表中...
数据结构课后练习——初识单链表（单链表的创建，查找并删除）
My Struggle
09-13 1113
就保平布置的那个必做题。。。 题目：在一个按值递增的链表中删除值等于x的节点，成功返回1，失败返回0. 源代码如下： #include&lt;iostream&gt; #include&lt;stdlib.h&gt; using namespace std; class node { node* next; int data; public: node() {} ~node() {...
（带头结点）单链表初识
qq_51214556的博客
11-12 166
#include <stdio.h> #include <stdlib.h> typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList;
链表初识？嗯 -----单链表
lxs的博客
04-19 142
        在认识链表之前要熟悉一个新东西-----链结点        链结点 由两部分组成    数据(data)  和  下一个 链结点 引用(next);        在java中大概是这个样子的：public class Link { protected long data; //数据 protected Link next; //下一个链结点 public Li...
初识单链表：数据结构基础与实现原理
单链表是一种基本的数据结构，由节点组成，每个节点包含数据项和指向下一个节点的指针。单链表适用于插入、删除操作频繁的场景，但查找操作效率较低。 ### 1.3 为什么要学习单链表？ 学习单链表可以帮助理解数据...
初识C语言：单链表的基本概念与应用
## 1.2 单链表在程序设计中的重要性 在引言部分，我们将介绍C语言在数据结构中的应用以及单链表在程序设计中的重要性。随着计算机科学与技术的不断发展，数据结构作为计算机科学的重要基础之一，发挥着关键作用。...
初识数据结构之入门必懂——链表(单链表)
m0_64705485的博客
09-14 293
简单学习一下，单链表的定义，及对其增删查改函数的实现
无头单链表的增、删、改、查等相关操作
WangWt88的博客
05-17 305
我们都知道，链表是线性表的一种，那为什么会有链表这种数据存储结构呢？ 原因大致可以总结为以下三点： 线性表的长度不确定，难以事先确定数组长度。 存储空间必须是连续的，容易造成存储空间的“碎片”现象。 插入和删除操作需要移动大量元素。 为了克服以上缺点，我们可以采用链式存储的线性表，即单链表。 初识单链表 定义：一种链式存储的线性表，用一组地址任意的存储单元存放线性表的数据元素，...
C语言单链表初学容易掉的坑
weixin_50963006的博客
04-19 1794
C语言单链表初学容易掉的坑 结点的指针没有分配内存。 一个链表最基本的操作有建立、增加、删除、查找，几乎所有操作都离不开中间结点p。比如，建立时先检查是否空链表，若是，则令head指向结点p所指向的值，然后释放结点p，或对p重新分配内存；增删查时也需要借助p来进行操作。初学者最容易犯的错误是忘记在声明后对结点分配内存。比如，下面一段代码在建立链表时没有对结点分配内存而产生错误： #include<stdio.h> #include<stdlib.h> typedef s
C/C++漏洞检测数据集汇总
最新发布
阿航的博客
09-13 1080
漏洞检测这个方向最近几年尤为热门，尤其是与深度学习技术相结合的研究，同时一些公开可用的数据集的出现也进一步推动了这些技术的发展。本篇文章总结归纳了目前在 C/C++ 源代码漏洞检测方向的一些公开数据集以及相关文献。
SX_c语言替换文件中的字符串_22
Narnat的博客
09-12 255
项目实现中有时候需要根据一些设置的值替换掉代码文件中的一些字符串，让显示有所变化，这里有两种方式替换。可以对全局文件做查找操作，找到所有目标文件的位置。
c语言中为函数输入可变长的参数
wumingshi159的博客
09-12 350
代表将ap指向format后面的下一参数的位置，然后在循环中每次调用va_arg都会指向下一个参数，然后通过format中的指示，告诉我们第几个参数是哪种格式，就能正确地读取参数。va_end是对应于va_start的函数，在可变长参数的传递过程中，由va_start分配内存并将参数保存其中，最后由va_end释放内存。一个典型的可变输入函数就是printf()，该函数根据解析字符串中的%s， %d，%p等，就可以知道后面带有多少个参数。即写一个输入的参数数量是可变的。注意到上述的代码，输入处的"…
CCF刷题计划——垦田计划（手握map砍竹子）
Caspiannn的博客
09-12 412
使用优先队列还超时了，这是我没想到的，但是好歹得了70分，而且复习了优先队列，还是不亏的。经过我的优化，还是把这道题做出来了。
初识Visual Basic 6.0：打造Windows应用程序
在本章节中，我们将深入初识Visual Basic 6.0，了解其发展历史、开发环境、工程管理，以及如何创建首个VB应用程序。 Visual Basic 6.0，简称VB，是微软公司于1990年代推出的可视化软件开发工具，它的名称来源于其...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值