【数据结构|C语言版】单链表

已于 2024-04-20 15:15:41 修改
阅读量688 收藏 24
点赞数 32
分类专栏： 【数据结构（C语言版）学习】 文章标签： 数据结构 链表 c语言
于 2024-04-15 21:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_80269373/article/details/137748994
版权

在这里插入图片描述

前言

各位小伙伴大家好！时隔不久，小编来给大家讲解一下单链表的相关知识。
在这里插入图片描述

1. 单链表的概念和结构

1.1 单链表的概念

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

  • 逻辑上连续
  • 物理上非连续

1.2 单链表的结构

链表是由一个个结点组成的

【节点】
在这里插入图片描述
【单链表雏形】
在这里插入图片描述

2. 单链表的分类

链表的结构⾮常多样，以下情况组合起来就有8种（2 x 2 x 2）链表结构。
在这里插入图片描述
【常见分类】
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

比较常见的是无头单向非循环链表和带头双向循环链表。
在这里插入图片描述

3.单链表的实现

3.1 新节点创建

//创建一个新节点
SListNode* BuySLTNode(SLDateType x)
{
	SListNode* newNode = (SListNode*)malloc(sizeof(SListNode));
	if(newNode == NULL)
	{
		perror("malloc:");
		return;
	}
	newNode->data = x;
	newNode=>next = NULL;
	return newNode;
}

3.2 单链表头插

//头插
void SListPushFront(SListNode** pphead,SLDateType x)
{
	assert(pphead);
	SListNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

3.3 单链表头删

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

3.4 单链表尾插

//尾插
void SLTPushBack(SListNode**pphead, SLDateType x)
{
	assert(pphead);
	SListNode* newnode = BuySLTNode(x);
	//1.链表为空
	//2.链表不为空
	if (*pphead == NULL)
	{
		*pphead = newnode;
        //不需要让newnode->next=NULL,在BuySLTNode中我们就已经进行过这个操作了
	}
	else
	{
		//找到链表的尾巴tail
		SListNode* tail = *pphead;
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

3.5 单链表尾删

//尾删
void SListPopBack(SListNode**pphead)
{
	assert(pphead);
	assert(*pphead);
	//1.链表只有一个元素
	//2.链表有两个及两个以上的元素
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SListNode* tail = *pphead;
		SListNode* prev = NULL;
		//找尾
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		prev->next = NULL;
		tail = NULL;
·       另一种方法
		//SListNode* tail = *pphead;
		//while (tail->next->next)
		//{
		//	tail = tail->next;
		//}
		//free(tail->next);
		//tail->next = NULL;
	}
}

3.6 链表销毁

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

4. 代码总结

4.1 SLT.h

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int SLTDateType;
typedef struct SLTNode
{
	SLTDateType data;
	struct SLTNode* next;
}SLTNode;
//创建一个结点
SLTNode* BuyListNode(SLTDateType x);
//销毁单链表
void SLTDestory(SLTNode** pphead);
//单链表头插
void SLTPushFront(SLTNode** pphead, SLTDateType x);
//单链表尾插
void SLTPushBack(SLTNode** pphead, SLTDateType x);
//单链表头删
void SLTPopFront(SLTNode** pphead);
//单链表尾删
void SLTPopBack(SLTNode** pphead);
//单链表结点查找
SLTNode* SLTNodeFind(SLTNode* phead, SLTDateType x);
//单链表结点删除(删除pos位置的结点)
void SLTErase(SLTNode** pphead, SLTNode* pos);
//单链表结点插入(在pos之前插入)
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDateType x);
// 单链表结点插入(在pos之后插入)
void SLTInsertBack(SLTNode** pphead, SLTNode* pos, SLTDateType x);
// 单链表结点修改
void SLTModify(SLTNode* phead, SLTNode* pos, SLTDateType x);
//打印单链表
void PrintSLT(SLTNode * phead);

4.2 SLT.c

#include"SLT.h"
 
//建立一个新的结点
//这是链表的缺点：经常需要使用malloc为newnode开辟空间
SLTNode* BuyListNode(SLTDateType x)
{
	//为什么要用malloc，是因为，如果在BuyListNode函数中SLTNode newnode，出了这个函数，newnode就被销毁了，
	//用malloc开辟空间，只要我们不主动释放这个空间，这个空间的数据一直存在，
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	//static SLTNode newnode；
	if (newnode == NULL)
	{
		perror("malloc:");
		exit(0);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
 
//头插
void SLTPushFront(SLTNode** pphead, SLTDateType x)
{
	assert(pphead);//phead可能为NULL，但是pphead指向phead，不可能为空
	SLTNode* newnode = BuyListNode(x);
	//这里可不是newnode->next = (*pphead)->next;
	newnode->next = *pphead;
	*pphead = newnode;
}
 
 
//尾插
//尾插特别容易出错，当链表中没有数据，即phead=NULL时，尾插就相当于头插了，此时需要改变phead的值
void SLTPushBack(SLTNode** pphead, SLTDateType x)
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);
	//1、空
	//2、非空
	if (*pphead == NULL)
	{
		*pphead = newnode;
		//newnode->next = NULL;这一步是不需要的，newnode在建立的时候就默认newnode->next=NULL；
	}
	else
	{
		SLTNode* cur = *pphead;
		//这是单向链表的缺点，需要去找尾
		while (cur->next != NULL)
		{
			cur = cur->next;
		}
		cur->next = newnode;
	}
}
 
//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);
	//温柔的检查
	if (*pphead == NULL)
		return;
	//暴力的检查
	assert(*pphead);
	SLTNode* head = *pphead;
	*pphead = (*pphead)->next;
	free(head);
	head = NULL;
}
 
//尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	//1、一个结点
	//2、两个结点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* cur = *pphead;
		while (cur->next->next)
		{
			cur = cur->next;
		}
		free(cur->next);
		cur->next = NULL;
	}
}
//打印单向链表
void PrintSLT(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL");
	printf("\n");
}
 
//单链表查找某个结点
SLTNode* SLTNodeFind(SLTNode* phead, SLTDateType x)
{
	SLTNode* find = phead;
	//别忘记分析找不到结点的情况
	while (find)
	{
		if (find->data == x)
		{
			return find;
		}
		find = find->next;
	}
	return NULL;
}
 
//删除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
			//证明pos传入有误
			assert(prev->next);
		}
		prev->next = pos->next;
		free(pos);
		//pos = NULL;这个没必要，改变不了pos
	}
}
//单链表结点前插
//一般插入结点都是在pos之前插入，但单链表在实现前插是比较困难的
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDateType x)
{
	assert(pphead);
	//头插
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	//非头插
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
			assert(prev->next);
		}
		SLTNode* newnode = BuyListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}
//单链表结点后插
void SLTInsertBack(SLTNode** pphead, SLTNode* pos, SLTDateType x)
{
	SLTNode* cur = *pphead;
	while (cur != pos)
	{
		cur = cur->next;
		//防止pos传错了
		assert(cur);
	}
	SLTNode* newnode = BuyListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}
 
// 单链表结点修改
void SLTModify(SLTNode* phead, SLTNode* pos, SLTDateType x)
{
	SLTNode* cur = phead;
	while (cur != pos)
	{
		cur = cur->next;
		assert(cur);
	}
	pos->data = x;
}
//销毁链表
void SLTDestory(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	//比cur->next!=NULL更好一些
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

4.3 test.c

#include"SLT.h"
void test1()
{
	SLTNode* plist = NULL;
	SLTPushFront(&plist, 0);
	SLTPushFront(&plist, -1);
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	PrintSLT(plist);
	SLTPopFront(&plist);
	SLTPopBack(&plist);
	PrintSLT(plist);
	SLTNode* pos = SLTNodeFind(plist, 0);
	SLTInsert(&plist, pos, -2);
	PrintSLT(plist);
	SLTInsert(&plist, pos, -1);
	PrintSLT(plist);
	SLTInsertBack(&plist, pos, 3);
	PrintSLT(plist);
	SLTModify(plist, pos, 4);
	PrintSLT(plist);
}
int main()
{
	test1();
}

后言

以上就是小编对单链表的一些初步认识。
如果觉得小编讲的还可以，还请一键三连。互三必回！
持续更新中~，下周见！
在这里插入图片描述

C_GUIQU
关注
  • 32
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 12
    评论
专栏目录
数据结构C语言版之单链表的逆置.cpp
10-07
数据结构老师布置的作业，运用课本代码，较为基础经典，适合大学本科在上数据结构这门课的同学参考，简单易懂，关于单链表的逆置问题
【数据结构】C语言实现单链表
SHLYYY
04-30 2668
SLLNode;// 打印 void SLLPrint(SLLNode * phead);// 头插、尾插 void SLLPushFront(SLLNode * * pphead , SLLDataType x);// 头删、尾删 void SLLPopFront(SLLNode * * pphead);// 查找 SLLNode * SLLFind(SLLNode * phead , SLLDataType x);
【数据结构】C语言实现单链表基本操作
weixin_43716338的博客
02-05 2987
#include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int Status; typedef int ElemType; //单链表的存储结构 typedef struct LNode { ElemType data; struct LNode *next; //next指向自身类型struct LNode *的指
＜数据结构＞ C语言实现 单链表
shinamashiro_的博客
04-17 1969
1.链表的概念及结构 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序时通过链表中的指针链接次序实现的。 从上图可以看出： 1.链式结构在逻辑上时连续的，但在物理上不一定连续 2.显示中的节点一般都是从堆上申请出来的 3.从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续 2.实现单链表 2.1 SList.h #pragma once #include <stdio.h> #include <string.
数据结构之C语言实现单链表
five-five
05-13 1532
数据结构之C语言实现单链表定义什么是单链表用代码定义一个单链表typedef使用不带头节点带头结点基本操作的实现插入删除操作查找操作单链表的建立 定义 什么是单链表 优点：不要求大片不连续空间，改变容量方便 缺点：不可随机存取，要耗费一定空间存放指针 用代码定义一个单链表 struct LNode{ ElementType data; struct LNode *next; } struct LNode* p=(struct LNode*)malloc(sizeof(struct LNod
c语言实现单链表(数据结构)
m0_62143067的博客
04-25 2380
目录 实现单链表的基本操作 想要把链表研究透彻 就需要对指针的深入了解 先引入一个概念 什么是指针？什么是变量？什么是指针变量？ 我们创建的 int char double 都属于变量 变量有地址 指向这个地址就能改变这个变量 我们创建的指针也是变量 那指针变量也有自己的地址 指向这个地址就能改变这个变量 这个问题非常抽象 改变变量 就需要创建一个指针指向这个变量的地址 如果我们想要改变指针变量(注意这时就应该是指针变量)就要创建一个指针指向指针变量的地址 才能改变这个...
数据结构C语言-单链表操作实验
04-23
数据结构C语言版，单链表操作的菜单式实验，包括单链表的初始化、创建、求表长、插入删除元素、销毁和清空单链表等操作，具体操作根据屏幕提示进行。
数据结构-C语言版：单链表例题.ppt
06-06
数据结构-C语言版：单链表例题.ppt
数据结构 C语言实现循环单链表的实例
08-30
主要介绍了数据结构 C语言实现循环单链表的实例的相关资料,需要的朋友可以参考下
C语言数据结构单链表的增删查改
04-29
C语言数据结构单链表的增删查改
408专项数据结构2013
m0_60441630的博客
04-23 205
思考：对序列进行排序后，判断一段连续序列的长度是否超过n/2;用快排注意平均时间复杂度是O(nlogn)，归并才是真正的最坏O(nlogn)。但我不确定实际书写的时候能否用sort函数代替加快速率，如果不能，我大概率不会选择去手写一个快排。思考：个人理解就是军团打架，一v一剩下来的肯定是最多军团的人。正式一点说应该是摩尔投票法。没必要纠结名字，思想很简单。思考：暴力双循环，但时间复杂度有点低，拿分可以拿9分。
数据结构 栈实现队列
JINbigXIA的博客
04-28 631
然后了解栈的创建：stack<int> jinzihao；操作：stout.push(stin.top());表示把in最上面的数导入stout中。注意要返回并且移除，如果我们直接使用pop只能删除stin中的最后进入的元素。队列应当支持一般队列支持的所有操作（一：pop前函数里面没有内容（需要把stin的内容转移到stout中）二：首先找到stout.top() 并且保存到变量中。这个函数的实现就需要用到我们刚刚写的pop函数，直接使用push将x值放入stin的栈中。将元素 x 推到队列的末尾。
数据结构之“快慢指针”
最新发布
CH3_CH2_CHO的博客
04-29 299
是解决链表环问题的一个常见技巧在这个方法中，我们设置两个指针，一个快指针（每次移动两步）和一个慢指针（每次移动一步）
C++信息学奥赛 数据结构认识
博樽
04-23 787
数据结构认识的练习训练
数据结构（九）---并查集
weixin_69884785的博客
04-26 681
数据结构（九）---并查集 1.集合 2.集合的相关操作 (1)查(Find)： •Find操作的优化 (2)并(Union)： •Union操作的优化
408数据结构专项算法题-2018年
m0_60441630的博客
04-24 421
思考：思路一开空间的思路无疾而终，在思路二中发现重要的性质1
数据结构—单链表
lihaolihao111111的博客
04-23 791
之前的文章已经谈到了顺序表，关于顺序表，有一下的几种特点1.中间，头部的删除，复杂度为O(N);2.增容会有申请新的空间，拷贝数据，释放旧的空间，会有不小的消耗；3：整容一般是呈2的倍数增长，但是也会造成一定的空间浪费，比如，当前的容量是100，满了以后·增加到200，我们继续插入5个数据，后面没有数据插入，就浪费了95个空间。
【数据结构】 第一章+第二章 课后习题概念+算法设计题
Sy的博客
04-26 1052
概念简述题算法设计题。
VTK----VTK数据结构详解3（代码篇）
charce_you的专栏
04-26 1067
上篇文章（）从计算机数据结构（数组、链表等）的角度对的实现原理进行了说明，下面从代码的层面详细说明它们的使用及相关实现逻辑。
数据结构c语言实现顺序表创建
06-03
以下是C语言实现顺序表创建的示例代码： ``` #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 // 定义顺序表的最大长度 typedef struct { int data[MAXSIZE]; // 存储顺序表元素的数组 int length; // 记录顺序表当前长度 } SqList; // 定义顺序表类型 int main() { SqList L; // 定义顺序表变量 int n, i; printf("请输入顺序表的长度: "); scanf("%d", &n); if (n < 1 || n > MAXSIZE) { // 判断输入的长度是否合法 printf("输入的顺序表长度不合法！\n"); exit(1); // 退出程序 } L.length = n; // 记录顺序表的长度 printf("请输入 %d 个整数作为顺序表的元素:\n", n); for (i = 0; i < n; i++) { scanf("%d", &L.data[i]); // 读取顺序表元素 } printf("顺序表创建完成，当前长度为 %d，元素为:\n", L.length); for (i = 0; i < n; i++) { printf("%d ", L.data[i]); // 输出顺序表元素 } printf("\n"); return 0; } ``` 使用该程序，用户可以输入顺序表的长度和元素，程序可以创建一个顺序表并输出创建结果。在程序中，我们使用了结构体来定义顺序表类型，并定义了一个包含顺序表元素和当前长度的结构体变量L来存储顺序表。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值