单链表的实现（C语言）

已于 2024-01-19 09:14:34 修改
阅读量1.4k 收藏 4
点赞数 3
分类专栏： 数据结构 文章标签： c语言 数据结构
于 2022-10-11 12:23:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57604904/article/details/127252041
版权

目录

前言（顺序表的问题及思考）

一、链表

1.1. 概念与结构

 1.2 链表的分类

        1.2.1. 单向或者双向

        1.2.2.带头或者不带头 

        1.2.3.循环或者非循环

 1.3 链表的实现

 二、链表的具体实现

1.单链表的空间分配

2. 打印链表

3. 尾插

4. 头插

5. 尾删

 6. 头删

 7. 查找

 8. 在pos位置插入

9. 在pos位置删除

10. 销毁

总结

动态内存分配（malloc）详解-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/TheWhiteFox/article/details/108502906

前言（顺序表的问题及思考）

问题：
1. 中间/头部的插入删除，时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
思考：如何解决以上问题呢？下面给出了链表的结构来看看。

一、链表

1.1. 概念与结构

        概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

 

 1.2 链表的分类

        实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

        1.2.1. 单向或者双向

        1.2.2.带头或者不带头 

         

        1.2.3.循环或者非循环

         虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

 1.3 链表的实现

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data; // val
	struct SListNode* next; // 存储下一个节点的地址
}SListNode, SLN;

void SListPrint(SListNode* phead);
void SListPushBack(SListNode** pphead, SLTDataType x);
void SListPushFront(SListNode** pphead, SLTDataType x);
void SListPopBack(SListNode** pphead);
void SListPopFront(SListNode** pphead);
SListNode* SListFind(SListNode* phead, SLTDataType x);

// 在pos位置之前插入
void SListInsert(SListNode** pphead, SListNode* pos, SLTDataType x);
// 删除pos 位置
void SListErase(SListNode** pphead, SListNode* pos);

// 在pos之后插入
void SListInsertAfter(SListNode* pos, SLTDataType x);
// 删除pos位置后面的值
void SListEraseAfter(SListNode* pos);

void SListDestroy(SListNode** pphead);

 二、链表的具体实现

 注意以下几点：

1）.每个节点都有一个data并且存放着下一个节点的地址；

2）.单链表的每一次都要用malloc开辟一个新的空间，由于堆区每次malloc开辟的空间不一定是连续的，所以链表在物理上看上去连续，但是其实不连续，它只是在逻辑上是连续的。

3）.链表有一个头指针变量，它可以说是第0个节点，称为整个单链表的头结点，其存放的是一个地址，一般不存放任何数据，只是存放第一个节点的地址，以找到该链表。

4）.只有链表不为空的时候，才需要对单链表进行空间分配，需要一个节点，就开辟一个节点进行连接。

5）.记住最后一个节点所存放的地址被要求为空，作为链表的结束，代表后续没有节点。

1.单链表的空间分配

SListNode* BuySListNode(SLTDataType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		printf("BuySListNode error\n");
		exit(-1);
	}
	else
	{
		newnode->data = x;
		newnode->next = NULL;
	}
    return newnode;
}

2. 打印链表

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

3. 尾插

        注意：传址，头指针的改变

//空链表的创建
//SListNode* SList = NULL;
//SListPushBack(SList,i)
//void SListPushBack(SListNode* phead,SLDataType x)尾插
//SList是一个指向SListNode的指针，phead也是一个指向SListNode的指针，属于传值传参
//这样只是一份临时拷贝，形参的改变不会影响实参
//c语言指针有一个这样的原则：若想改变int变量，就需要传int*变量
//&SList，SList的地址可以这么理解，SList存放的是SListNode的地址，解引用才能得到&SList
//所以相当于传&SList可以改变SList
//所以若这里传址的话即SListPushBack(&SList,i)
//pphead是指向SListNode*类型的指针，即指向指针（该指针指向SListNode类型）的指针
//即存放指向SListNode类型的指针的地址
//&SList是指针的地址，而该指针存放的是SListNode的地址
void SListPushBack(SListNode** pphead, SLTDataType x)
{
	assert(pphead);//空指针的解引用是耍流氓
	SListNode* newnode = BuySListNode(x);
	if (*pphead == NULL)//pphead接收的&SList,*pphead就是SList本身
	{
		//这就是说该链表无节点，可以直接插入
		*pphead = newnode;//现在让SList指向newnode即可插入成功
	}
	else
	{//找尾，尾插即可
		SListNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

4. 头插

void SListPushFront(SListNode** pphead, SLTDataType x)
{
	assert(pphead);
	SListNode* newnode = BuySListNode(x);
	newnode->next = *pphead;//如果是空链表的时候，*pphead == NULL,先让newnode->next=NULL也是合理的
	*pphead = newnode;
}

5. 尾删

        分情况讨论

                1）单节点2）多节点3）空脸变

void SListPopBack(SListNode** pphead)
{
	assert(pphead);
	if (*pphead == NULL)
	{
		//空链表
		return;
	}
	else
	{
		//单节点的时候，改变了头结点
		if ((*pphead)->next == NULL)
		{
			free(*pphead);//释放第一个节点
			*pphead = NULL;
		}
		else
		{
			//多节点找尾尾删

			/*经典错误,
			单链表是以尾结点指向空作为结束，free(tail)后，会让上一个结点指向野指针
			while (tail->next != NULL)
			{
				tail = tail->next;
			}
			free(tail);
			tail = NULL;*/
			SListNode* tail = *pphead;
			SListNode* prev = NULL;
			while (tail->next != NULL)
			{
				prev = tail;//记录前一个指针
				tail = tail->next;
			}
			free(tail);
			tail = NULL;
			prev->next = NULL;//单链表的结束
		}
	}
}

 6. 头删

void SListPopFront(SListNode** pphead)
{
	assert(pphead);
	if (*pphead == NULL)
	{
		return;
	}
	if ((*pphead)->next == NULL)//一个节点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else//多个节点
	{
		SListNode* next = (*pphead)->next;
		free(*pphead);
		*pphead = next;
	}
}

 7. 查找

        注意：别忘记尾结点也要查找得到才行

SListNode* SListFind(SListNode* phead, SLTDataType x)
{
	assert(phead);
	SListNode* cur = phead;
	while (cur != NULL)//只有这样才能检查最后一个节点
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;//找不到返回NULL
}

 8. 在pos位置插入

        思考：pos位置后插入更简单！

// 在pos位置之前插入
void SListInsert(SListNode** pphead, SListNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	//1.空链表
	if (*pphead == NULL)
	{
		return;//空链表都没有pos位置，无意义
	}
	//2.单节点
	else if ((*pphead)->next == NULL)
	{
		SListPushFront(pphead, x);//pphead是SList的地址
	}
	//3.多节点
	else
	{
		SListNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SListNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

//在pos位置之后插入
void SListInsertAfter(SListNode* pos, SLTDataType x)
{
	assert(pos);
	//SListNode* next = pos->next;
	//SListNode* newnode = BuySListNode(x);

	//pos->next = newnode;
	//newnode->next = next;

	SListNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

9. 在pos位置删除

// 删除pos 位置
void SListErase(SListNode** pphead, SListNode* pos)
{
	assert(pphead);
	assert(pos);
	if (*pphead == NULL)
	{
		return;
	}
	else if ((*pphead) == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		SListNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
void SListEraseAfter(SListNode* pos)
{
	assert(pos);

	SListNode* next = pos->next;
	if (next)
	{
		pos->next = next->next;
		free(next);
		next = NULL;
	}
}

10. 销毁

        同样注意尾结点也需要销毁。

void SListDestroy(SListNode** pphead)
{
	assert(*pphead);
	SListNode* cur = *pphead;
	SListNode* next = NULL;
	while (cur)//这样才能free掉尾结点
	{
		next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

总结

        多动手画图！

白少平
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现单链表
08-23
C语言实现单链表
数据结构——单链表（C语言实现）
weixin_57154303的博客
08-23 3836
单链表的基本操作有 初始化，头插，尾插，按位置插，头删，尾删，按位置删，查找，按值删，获取有效值个数，判空，清空，销毁，打印 - 单链表是一种链式存取的数据结构，链表中的数据是以结点来表示的，每个结点的构成：==元素(数据元素的映象)== + ==指针(指示后继元素存储位置)==，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。
C语言实现单链表（超多配图，这下不得不学会单链表了）
2301_76269963的博客
03-16 8116
C语言实现单链表
单向链表的C语言实现
最新发布
Broken_x的博客
05-28 1027
首先，我们需要定义单向链表的结点和链表本身的结构// 单向链表的结点定义// 数据域// 指针域，指向后继结点} Listnode;// 单向链表的定义// 头结点// 整个链表的元素个数和：包含标准输入输出和标准库函数。：定义链表中数据的类型为int，可以根据需要更改。：定义链表结点结构体，包含数据域data和指向后继结点的指针next。：定义链表结构体，包含指向头结点的指针head和链表的元素个数size。
【数据结构】—C语言实现单链表（超详细！）
B1ue还在专注
08-02 4145
这是作者对于单链表学习历程的记录，C语言做到了单链表的实现!很详细，细节都很到位！
【 数据结构 】单链表的实现 - 详解（C语言版）
热门推荐
上上谦. 的博客
03-22 1万+
前言 简单用C语言来描述数据结构中的单链表，本文实现的只是简单的无头单链表，包括单链表的增加数据，删除数据，查找指定数据，修改指定数据，也就是简单的增删查改等操作。
单链表（C语言实现）
cw412524的博客
11-20 1765
数据结构单链表（C语言实现），干货满满！
【数据结构】---单链表【C语言实现】
mike_jun的博客
07-10 4206
1. 单向链表 我们都熟悉数组，它作为一个顺序储存方式数据结构为我们的程序设计带来了大量的便利，几乎任何的高级程序设计，算法设计都离不开数组的灵活使用。 但是，数组最大的缺点就是我们的插入和删除时需要移动大量的元素，显然这需要消耗大量的时间。 数组找到指定元素很快，O（1）复杂度就可以，而链表只能是遍历，O(n)的复杂度。 数组是顺序存储的，链表是通过指针实现不连续的存储 相比起数组，链表解决了数组不方便移动，插入，删除元素的弊端，但相应的，链表付出了更加大的内存牺牲换来的这些功能的实现。 ...
C语言单链表实现
01-16
单链表是计算机科学中数据结构的基础之一，它在C语言中的实现对于理解和掌握数据结构的概念至关重要。在本文中，我们将深入探讨C语言如何通过结构体和指针来实现单链表。 首先，我们需要理解单链表的基本概念。...
单链表_c语言/单链表_
09-29
单链表是计算机科学中一种基础且重要的数据结构，它在C语言中有着广泛...通过以上介绍，我们可以看出，单链表是C语言中实现数据结构的重要手段，理解和熟练掌握单链表及其操作对于学习更高级的数据结构和算法至关重要。
C语言单链表实现多项式相加
08-29
C语言单链表实现多项式相加 多项式是数学中的一种重要概念，表示为一个变量的幂的和。多项式相加是指将两个或多个多项式进行加法运算，结果仍然是一个多项式。在计算机科学中，实现多项式相加需要使用数据结构和...
C语言单链表实现方法详解
08-27
C语言单链表实现方法详解 单链表是一种基本的数据结构，在C语言中实现单链表可以提高程序的效率和灵活性。本文将详细介绍C语言单链表的实现方法，包括单链表的定义、创建、添加、删除、排序、打印等操作技巧，并...
【数据结构】C语言实现单链表
SHLYYY
04-30 2928
SLLNode;// 打印 void SLLPrint(SLLNode * phead);// 头插、尾插 void SLLPushFront(SLLNode * * pphead , SLLDataType x);// 头删、尾删 void SLLPopFront(SLLNode * * pphead);// 查找 SLLNode * SLLFind(SLLNode * phead , SLLDataType x);
单链表的基本实现(详细图解+解说)
Eliauk_U的博客
03-16 4877
目录 一.前言： 二.链表的结构实现: 三.单链表的功能实现-增删查..... 1.结点的申请 2.数据的头插 3.数据的打印 4.数据的尾插 5.数据的头删 6.数据的尾删 7.数据的查找 8.数据的指定插入和指定删除 9.链表的销毁 四.后言 一.前言： 我们都知道，顺序表是一块连续的可以存放数据的存储空间，其可以通过下标或指针解引用的方式快速访问某个位置的数据，但是由于空间的连续性，想要灵活的插入和删除数据便较为困难。 区别于顺序表，链表由一个个独立的可以存放数..
单链表（c语言实现）
MsPu_的博客
04-09 636
前言对于结构体和指针的深层运用，建议具有一定基础食用。单向性：每个节点只有一个指针，指向下一个节点，不能回溯到前面的节点。动态性：单链表的长度可以动态地改变，可以根据需要进行节点的添加和删除操作。存储效率较低：与数组相比，单链表的存储效率较低，因为每个节点需要额外的指针空间来指向下一个节点。随机访问效率较低：由于单链表只能从头节点开始逐个遍历，因此访问某个特定位置的节点需要线性时间，效率较低。插入和删除操作效率较高：由于单链表的动态性，插入和删除操作只需要改变指针的指向，效率较高。空间分配灵活：单链表的节点
c语言实现单链表(数据结构)
m0_62143067的博客
04-25 2436
目录 实现单链表的基本操作 想要把链表研究透彻 就需要对指针的深入了解 先引入一个概念 什么是指针？什么是变量？什么是指针变量？ 我们创建的 int char double 都属于变量 变量有地址 指向这个地址就能改变这个变量 我们创建的指针也是变量 那指针变量也有自己的地址 指向这个地址就能改变这个变量 这个问题非常抽象 改变变量 就需要创建一个指针指向这个变量的地址 如果我们想要改变指针变量(注意这时就应该是指针变量)就要创建一个指针指向指针变量的地址 才能改变这个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值