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

最新推荐文章于 2024-07-20 11:22:21 发布
最新推荐文章于 2024-07-20 11:22:21 发布
阅读量51 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72387202/article/details/129915504
版权

文章目录

1. 链表的概念及结构

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

  1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
  2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，下一章我们代码实现了就知道了。

2单链表的实现

2.1新节点的创建

SLTNode* BuySTLNode(x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("SLTpushback::malloc");
		return NULL;
	}
	newnode->date = x;
	newnode->next = NULL;
	return newnode;
}

2.2单链表尾插

void SLTPushBack(SLTNode** pphead, SLTDateType x)
{
	assert(pphead);
	SLTNode* newnode = BuySTLNode(x);
	//找尾
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

2.3单链表尾删

void SLTPopback(SLTNode** pphead)
{
	assert(pphead);
	//链表为空
	assert(*pphead);
	//1.只有一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//2.多个节点
	else
	{
		SLTNode* tail = *pphead;
		SLTNode* prev = NULL;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		prev->next = NULL;
	}
}

2.4单链表头插

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

2.5单链表头删

void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLTNode* tail = *pphead;
	*pphead = (*pphead)->next;
	free(tail);
	tail = NULL;

}

2.6单链表查找

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

2.7在pos前插入

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDateType x)
{
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
	{
		SLTPushFront(pphead, x);
	}
	SLTNode* newnode = BuySTLNode(x);
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = newnode;
	newnode->next = pos;

}

2.8删除pos位置的值

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

2.9单链表在pos位置之后插入x

void SListInsertAfter(SLTNode* pos, SLTDateType x)
{
	assert(pos);
	SLTNode* newnode = BuySTLNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

2.10单链表删除pos位置之后的值

void SListEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLTNode* cur = pos->next;
	pos->next = cur->next;
	free(cur);
	cur = NULL;
}

2.11单链表的销毁

void SListDestroy(SLTNode* phead)
{
	SLTNode* prev = NULL;
	while (phead)
	{
		prev = phead;
		phead = phead->next;
		free(prev);
		prev = NULL;
	}
}

3.源代码

3.1 SList.h

#pragma once

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

typedef int SLTDateType;

typedef struct SListNode
{
	SLTDateType date;
	struct SListNode* next;

}SLTNode;

//单链表打印
void SLTPrint(SLTNode* phead);

//单链表尾插
void SLTPushBack(SLTNode** pphead, SLTDateType x);

//void SLTPushBack(SLTNode* phead, SLTDateType x);

//单链表头插
void SLTPushFront(SLTNode** pphead, SLTDateType x);

//单链表尾删
void SLTPopback(SLTNode** pphead);

//单链表头删
void SLTPopFront(SLTNode** pphead);

//单链表查找
SLTNode* SLTFind(SLTNode* phead, SLTDateType x);

//在pos前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDateType x);

//删除pos位置的值
void SLTErase(SLTNode** pphead, SLTNode* pos);

// 单链表的销毁
void SListDestroy(SLTNode* phead);

// 单链表在pos位置之后插入x
void SListInsertAfter(SLTNode* pos, SLTDateType x);

// 单链表删除pos位置之后的值
void SListEraseAfter(SLTNode* pos);

3.2 SList.c

#define  _CRT_SECURE_NO_WARNINGS 1

#include"SList.h"

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

//新节点
SLTNode* BuySTLNode(x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("SLTpushback::malloc");
		return NULL;
	}
	newnode->date = x;
	newnode->next = NULL;
	return newnode;
}
//尾插
void SLTPushBack(SLTNode** pphead, SLTDateType x)
{
	assert(pphead);
	SLTNode* newnode = BuySTLNode(x);
	//找尾
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

//void SLTPushBack(SLTNode* phead, SLTDateType x)
//{
//	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
//	if (newnode == NULL)
//	{
//		perror("SLTpushback::malloc");
//		return;
//	}
//	newnode->date = x;
//	newnode->next = NULL;
//	//找尾
//	if (phead == NULL)
//	{
//		phead = newnode;
//	}
//	else
//	{
//		SLTNode* tail = phead;
//		while (tail->next != NULL)
//		{
//			tail = tail->next;
//		}
//		tail->next = newnode;
//	}
//}

//头插
void SLTPushFront(SLTNode** pphead, SLTDateType x)
{
	assert(pphead);
	SLTNode* newnode = BuySTLNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

//尾删
void SLTPopback(SLTNode** pphead)
{
	assert(pphead);
	//链表为空
	assert(*pphead);
	//1.只有一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//2.多个节点
	else
	{
		SLTNode* tail = *pphead;
		SLTNode* prev = NULL;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		prev->next = NULL;

		//SLTNode* tail = *pphead;
		//while (tail->next->next != NULL)
		//{
		//	tail = tail->next;
		//}
		//free(tail->next);
		//tail->next = NULL;
	}
}

//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLTNode* tail = *pphead;
	*pphead = (*pphead)->next;
	free(tail);
	tail = NULL;

}

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDateType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->date == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

//在pos前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDateType x)
{
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
	{
		SLTPushFront(pphead, x);
	}
	SLTNode* newnode = BuySTLNode(x);
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = newnode;
	newnode->next = pos;

}

//删除pos前位置的值
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(*pphead);
	if (*pphead == pos)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
	}
}

// 单链表在pos位置之后插入x
void SListInsertAfter(SLTNode* pos, SLTDateType x)
{
	assert(pos);
	SLTNode* newnode = BuySTLNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

// 单链表删除pos位置之后的值
void SListEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLTNode* cur = pos->next;
	pos->next = cur->next;
	free(cur);
	cur = NULL;
}

// 单链表的销毁
void SListDestroy(SLTNode* phead)
{
	SLTNode* prev = NULL;
	while (phead)
	{
		prev = phead;
		phead = phead->next;
		free(prev);
		prev = NULL;
	}
}

3.3 test.c

#define  _CRT_SECURE_NO_WARNINGS 1

#include"SList.h"


void TestList1()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);
	//SLTNode s;
	//SLTPushBack(&s, 1);
	//SLTPushBack(&s, 2);
	//SLTPushBack(&s, 3);
	//SLTPushBack(&s, 4);
	//SLTPrint(&s);
	SLTNode* pos = SLTFind(plist, 3);
	if (pos)
	{
		SLTInsert(&plist, pos, 20);
	}
	SLTPrint(plist);

}
void TestList2()
{
	SLTNode* plist = NULL;
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);
	SLTPopback(&plist);
	SLTPrint(plist);
	SLTPopback(&plist);
	SLTPrint(plist);
	SLTPopback(&plist);
	SLTPrint(plist);
	SLTPopback(&plist);
	SLTPrint(plist);

}

void TestList3()
{
	SLTNode* plist = NULL;
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);

}

void TestList4()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);
	SLTNode* pos = SLTFind(plist, 3);
	if (pos)
	{
		SListEraseAfter(pos);
	}
	SLTPrint(plist);
	pos = SLTFind(plist, 2);
	if (pos)
	{
		SListEraseAfter(pos);
	}
	SLTPrint(plist);
	pos = SLTFind(plist, 1);
	if (pos)
	{
		SListEraseAfter(pos);
	}
	SLTPrint(plist);
	//pos = SLTFind(plist, 1);
	//if (pos)
	//{
	//	SLTErase(&plist, pos);
	//}
	//SLTPrint(plist);
	//pos = SLTFind(plist, 2);
	//if (pos)
	//{
	//	SLTErase(&plist, pos);
	//}
	//SLTPrint(plist);
	//pos = SLTFind(plist, 4);
	//if (pos)
	//{
	//	SLTErase(&plist, pos);
	//}
	//SLTPrint(plist);
	SListDestroy(plist);
}
int main()
{
	//TestList1();
	//TestList2();
	//TestList3();
	TestList4();

	return 0;
}
CC小师弟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构之单链表（C语言版）
m0_57969151的博客
11-28 222
本篇为单链表实现的具体代码
数据结构-单链表（c语言）
jxau_dslj的博客
03-07 1875
线性表的链式表示和实现： 提示：这里简述项目相关背景： 例如：项目场景：示例:通过蓝牙芯片(HC-05)与手机 APP 通信，每隔 5s 传输一批传感器数据(不是很大) 问题描述： 提示：这里描述项目中遇到的问题： 例如：数据传输过程中数据不时出现丢失的情况，偶尔会丢失一部分数据 APP 中接收数据代码： @Override public void run() { bytes = mmInStream.read(buffer); mHandl
数据结构之单链表（c语言附完整代码）
热门推荐
m0_62795460的博客
11-01 1万+
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。声明单链表//数据域 struct LNode * next;//指针域，指向后继结点 } LinkNode;//声明单链表结点类型注意：本文章讨论的单链表是带头结点的单链表。
数据结构——单链表详解（C语言实现）
sinzz的博客
03-08 1272
首先，我们需要知道，单链表内所需要的数据有两种，一种是数据，还有就是下一个节点的指针。所以我们需要定义一个结构体。//重命名单链表的数据 //便于不同数据类型的切换 typedef struct SLTNode {//SLTNode* next//错误 //改写法C语言是不支持的 //struct SLTNode//错误 } SLTNode;
数据结构——单链表（C语言实现）
weixin_57154303的博客
08-23 3841
单链表的基本操作有 初始化，头插，尾插，按位置插，头删，尾删，按位置删，查找，按值删，获取有效值个数，判空，清空，销毁，打印 - 单链表是一种链式存取的数据结构，链表中的数据是以结点来表示的，每个结点的构成：==元素(数据元素的映象)== + ==指针(指示后继元素存储位置)==，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
C语言 数据结构之单链表基本操作
10-05
单链表的各种操作，适合于初学，也适合于复习 单链表操作介绍 1. 创建头节点 2. 创建有数据节点 3. 判断链表是否为空 4. 遍历链表(有头节点链表) 5. 遍历链表(无头节点链表) 6. 头插、头删、尾插、尾删 7. 按照顺序...
数据结构单链表（C语言）
03-27
通过c语言实现单链表的建立、初始化、尾插法插入结点、头插法插入结点、数据的查找、删除、在指定位置插入结点、在指定位置删除结点、打印输出数据、统计单链表的长度等功能。
数据结构---线性表之单链表（C语言）
03-28
单链表是数据结构中的一种基础类型，尤其在C语言编程中经常被使用。它是一种线性的、非连续的数据组织形式，每个元素称为节点，每个节点包含数据和一个指向下一个节点的指针。本篇文章将深入探讨单链表的创建、插入...
数据结构C语言版之单链表的逆置.cpp
10-07
数据结构老师布置的作业，运用课本代码，较为基础经典，适合大学本科在上数据结构这门课的同学参考，简单易懂，关于单链表的逆置问题
数组算法--基本查找
最新发布
2303_78660417的博客
07-20 279
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1022
可以参考以下视频。
数据结构day3
qq_55245263的博客
07-18 255
顺序表实现学生管理系统
【面试题】数据结构：堆排序的排序思想？
Colorful___的博客
07-18 698
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 215
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1075
如有错误，欢迎指出~
数据结构第32节 无锁编程
hummhumm的专栏
07-17 846
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
数据结构——栈
weixin_45942515的博客
07-19 241
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
数据结构之细说链表
m0_73634434的博客
07-17 1057
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
数据结构循环单链表C语言上机操作
06-13
在C语言中，操作循环单链表通常涉及创建、插入、删除和遍历等基本操作。 以下是一些基本操作的C语言实现概览： 1. **创建循环链表**: - 定义节点结构体，包含数据域和指向下一个节点的指针（如果是在头结点的最后...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CC小师弟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值