c语言单向链表

最新推荐文章于 2024-03-22 20:20:53 发布
最新推荐文章于 2024-03-22 20:20:53 发布
阅读量1.9k 收藏 14
点赞数 4
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71841506/article/details/126228601
版权

c语言实现简单的单向链表

文章目录

一、单向链表是什么？

单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点；（下图来自百度）

 

二、功能代码实现

1.包含头文件

#include<Stdio.h>
#include<string.h>
#include<stdlib.h>
#include<assert.h>

2.结构体（结点）

typedef int SLTDataType;//宏定义成员为整形
typedef struct SListNode
{
	SLTDataType data;//资料
	struct SListNode* next;//连接下一个节点的链子
}SLTNode;

3.定义 

SLTNode* BuyNewNode(SLTDataType X);//创建新节点
void SListPrint(SLTNode* phead);//打印
void SListDestory(SLTNode**phead);//销毁
void SListPushFront(SLTNode** pphead, SLTDataType X);//头插
void SListPushBack(SLTNode** pphead, SLTDataType X);//尾插
void SListPopFront(SLTNode** pphead);//头删
void SListPopBack(SLTNode** pphead);//尾删
SLTNode* SListFind(SLTNode* pphead, SLTDataType X);//查询
void SListInsert(SLTNode** pphead,SLTNode*pos, SLTDataType X);//插入-在pos之前插入
void SListInsert( SLTNode* pos, SLTDataType X);//插入-在pos之后插入

4.各类功能实现

SLTNode* BuyNewNode(SLTDataType X);//创建新节点-结构体指针类型函数-传值
SLTNode* BuyNewNode(SLTDataType X)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//先开辟一块空间给新节点
	if (newnode == NULL)//如果新节点为空-即开辟失败则报错
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = X;//把X的值赋给新节点的data
	newnode->next = NULL;//把链子设为空指针
	return newnode;//把节点传回去
}

void SListPrint(SLTNode* phead);//打印

void SListPrint(SLTNode* phead)
{
	SListNode* cur = phead;//新建一个结构体指针为表头
	while (cur != NULL)//如果指针指向的内容不为空则打印内容
	{
		printf("%d->", cur->data);
		cur = cur->next;
}
	printf("NULL\n");//为空则打印空指针
}

void SListDestory(SLTNode**phead);//销毁

void SListDestory(SLTNode** pphead)
{
	assert(pphead);//指向节点的指针不能为空
	SLTNode* cur = *pphead;//新建一个临时节点为链表头
	while (cur)//临时节点不为空时
	{
		SLTNode* next = cur->next;//链表下一个节点为临时节点的的下一个节点
		free(cur);//释放当前节点
		cur = next;//当前节点为下一个节点
	}
	*pphead = NULL;//最后释放完链表后置指针为空
}
void SListPushFront(SLTNode** pphead, SLTDataType X);//头插
void SListPushFront(SLTNode** pphead, SLTDataType X)//头插-链表吧不为空，要改变的是SList-用地址
{
	assert(pphead);
	SLTNode* newnode = BuyNewNode(X);//新建其含有对应内容的新节点
	newnode->next = *pphead;//新节点的下一个节点为表头
	*pphead = newnode;//新节点充当表头
}
void SListPopFront(SLTNode** pphead);//头删
void SListPopFront(SLTNode** pphead)//头删
{
	assert(pphead);
//	if (*pphead == NULL)//温柔检查
//	{
//		return;
//
//}
	assert(*pphead != NULL);//暴力检查
	
	SLTNode* del = *pphead;//建立新节点为表头
	*pphead = (*pphead)->next;//表头的下一个节点为表头
	free(del);//释放表头
	del = NULL;//新节点指针置为空
}
void SListPushBack(SLTNode** pphead, SLTDataType X);//尾插
void SListPushBack(SLTNode** pphead, SLTDataType X)//尾插-链表不为空，要改变的是SList 的成员-用结构体指针即可
{
	assert(pphead);
	SLTNode* newnode = BuyNewNode(X);//新建
	if (*pphead == NULL)//一种情况为表头为空-即链表只有一个空节点
	{
		*pphead = newnode;
	}
	else//另一种情况要找尾巴
	{
		//找尾
		SLTNode* tail = *pphead;//建立新节点为表头，依次找到表尾
		while(tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;//表尾替换为含有对应内容的新节点
	}
}

void SListPopBack(SLTNode** pphead);//尾删

A-单指针法

void SListPopBack(SLTNode** pphead)//尾删
{
	//	if (*pphead == NULL)//温柔检查
//	{
//		return;
//
//}
	assert(*pphead != NULL);//暴力检查
	assert(pphead);
	//对应链表只有一个节点-直接释放
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else//对应链表有多个节点
	{
		//找尾
		SLTNode* tail = *pphead;//新建节点为表头-开始找尾

		if (tail->next->next != NULL)//表尾为空指针-即要删除表尾前一个节点
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}



B-双指针（快慢指针法）

void SListPopBack(SLTNode** pphead)//尾删
{
	assert(pphead);
		//找尾
		SLTNode* tail = *pphead;
		SLTNode* open = NULL;
		while (tail->next != NULL)
		{
			open = tail;
			tail = tail->next;
		}
		open->next = NULL;
		free(tail->next);
		tail = NULL;
	
}

SLTNode* SListFind(SLTNode* pphead, SLTDataType X);//查询

SLTNode* SListFind(SLTNode* phead, SLTDataType X)
{
	SLTNode* cur = phead;//临时节点为表头
	while (cur)//临时节点不为空-还没遍历完链表
	{
		if (cur->data == X)//找到就返回临时节点
		{
			return cur;
		}
			cur = cur->next;
	}
	return NULL;//没找到返回空指针
	
}

void SListInsert(SLTNode** pphead,SLTNode*pos, SLTDataType X);//插入-在pos之前插入

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType X)//插入-在pos之前插入
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)//pos为表头直接用头插
	{
		SListPushFront(pphead,X);
	}
	else {
		SListNode* pre = *pphead;
		while (pre->next != pos)
		{
			pre = pre->next;
			assert(pre);//找到NULL还没找到pos说明pos传错了
		}
		SListNode* newnode = BuyNewNode(X);//串连起来
		pre->next = newnode;
		newnode->next = pos;
	}
}

void SListInsert( SLTNode* pos, SLTDataType X);//插入-在pos之后插入

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType X)//插入-在pos之后插入
{
	assert(pos);
	SListNode* newnode = BuyNewNode(X);
	newnode->next = pos->next;
	pos->next = newnode;
}

三、代码实现单向链表

SList.h

#include<Stdio.h>
#include<string.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;
SLTNode* BuyNewNode(SLTDataType X);//创建新节点
void SListPrint(SLTNode* phead);//打印
void SListDestory(SLTNode**phead);//销毁
void SListPushFront(SLTNode** pphead, SLTDataType X);//头插
void SListPushBack(SLTNode** pphead, SLTDataType X);//尾插
void SListPopFront(SLTNode** pphead);//头删
void SListPopBack(SLTNode** pphead);//尾删
SLTNode* SListFind(SLTNode* pphead, SLTDataType X);//查询
void SListInsert(SLTNode** pphead,SLTNode*pos, SLTDataType X);//插入-在pos之前插入
void SListInsert( SLTNode* pos, SLTDataType X);//插入-在pos之后插入
void SListEarse(SLTNode** pphead,SLTNode*pos);//删除-删除pos

SList.cpp

//顺序表的缺点
//1.中间或中部的插入和删除，时间复杂度为o（n）
//2.增容需要申请空间，拷贝数据，释放旧空间，会有消耗
//3.扩容一般以2倍的增长，易造成空间浪费

//链表
//无头单向非循环单链表：结构简单，一般不会单独用来存数据，实际上更多作为其他数据结构的子结构，如哈希表，图的邻接表
#include"SList.h"

void SListPrint(SLTNode* phead)
{
	SListNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
}
	printf("NULL\n");
}
SLTNode* BuyNewNode(SLTDataType X)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = X;
	newnode->next = NULL;
	return newnode;
}
void SListPushFront(SLTNode** pphead, SLTDataType X)//头插-链表吧不为空，要改变的是SList-用地址
{
	assert(pphead);
	SLTNode* newnode = BuyNewNode(X);
	newnode->next = *pphead;
	*pphead = newnode;
}

void SListPushBack(SLTNode** pphead, SLTDataType X)//尾插-链表不为空，要改变的是SList 的成员-用结构体指针即可
{
	assert(pphead);
	SLTNode* newnode = BuyNewNode(X);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾
		SLTNode* tail = *pphead;
		while(tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}
void SListPopFront(SLTNode** pphead)//头删
{
	assert(pphead);
//	if (*pphead == NULL)//温柔检查
//	{
//		return;
//
//}
	assert(*pphead != NULL);//暴力检查
	
	SLTNode* del = *pphead;
	*pphead = (*pphead)->next;
	free(del);
	del = NULL;
}
//void SListPopBack(SLTNode** pphead)//尾删
//{
//	assert(pphead);
//		//找尾
//		SLTNode* tail = *pphead;
//		SLTNode* open = NULL;
//		while (tail->next != NULL)
//		{
//			open = tail;
//			tail = tail->next;
//		}
//		open->next = NULL;
//		free(tail->next);
//		tail = NULL;
//	
//}
void SListPopBack(SLTNode** pphead)//尾删
{
	//	if (*pphead == NULL)//温柔检查
//	{
//		return;
//
//}
	assert(*pphead != NULL);//暴力检查
	assert(pphead);
	//一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else//多个节点
	{
		//找尾
		SLTNode* tail = *pphead;

		if (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

void SListDestory(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}
SLTNode* SListFind(SLTNode* phead, SLTDataType X)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == X)
		{
			return cur;
		}
			cur = cur->next;
	}
	return NULL;
	
}
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType X)//插入-在pos之前插入
{
	assert(pphead);
	assert(pos);//在pos之前插入
	if (pos == *pphead)
	{
		SListPushFront(pphead,X);
	}
	else {
		SListNode* pre = *pphead;
		while (pre->next != pos)
		{
			pre = pre->next;
			assert(pre);//找到NULL还没找到pos说明pos传错了
		}
		SListNode* newnode = BuyNewNode(X);
		pre->next = newnode;
		newnode->next = pos;
	}
}
void SListEarse(SLTNode** pphead, SLTNode* pos)//删除-删除pos
{

}
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType X)//插入-在pos之后插入
{
	assert(pos);
	SListNode* newnode = BuyNewNode(X);
	newnode->next = pos->next;
	pos->next = newnode;
}

test.cpp

#include"SList.h"
void TestSList1()
{
	SLTNode* plist = NULL;
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 4);
	SListPrint(plist);
	SLTNode* pos = SListFind(plist, 4);
	if (pos)
	{
		pos->data *= 2;
		printf("找到了\n");
	}
	else
	{
		printf("没找到\n");
	}
	SListPrint(plist);
	SListInsert(&plist,pos, 20);
	SListPrint(plist);
	SListDestory(&plist);
	SListPrint(plist);
}
int main()
{
	TestSList1();
	return 0;
}

以上只实现了部分功能，具体可以参考上功能代码实现，或者进到我的链接看噢

https://github.com/divertlee/opening.git

四、总结

本人纯新手昂，有啥问题评论区cue我噢，谢谢观看！！！

梨＋苹
关注
  • 4
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
单向链表的C语言实现
11-07
C语言指针实现单向链表 初学者看，非常简单。 时间非常多的功能不同位置的插入、删除、查找；
C语言——单向链表
DDsoup 24小时不打烊芜湖！
11-02 715
链表的概念：链表是一种动态存储分布的数据结构，由若干个同一结构类型的结点依次串连而成。 链表分为单向链表和双向链表。 链表变量一般用指针head表示，用来存放链表首结点的地址。 每个结点由数据部分和下一个结点的地址部分组成，即每个结点都指向下一个结点。最后一个结点称为表尾，其下一个结点的地址部分的值为NULL（表示为空地址）。 特别注意：链表中的各个结点在内存中是可以不连续存放的，具体存放位置由系统分配。 例如：int...
单向链表c语言
m0_73134296的博客
06-06 453
链表的插入大致需要进行两步操作，第一步是让上一处的指针指向待插入的这一处，此时待插入的节点已经与前半部分的链表产生了连接。接下来便需要将后半部分与前半部分断开并将后半部分与待插入的节点进行连接。由此可知第二步应该将待插入节点中的指针指向上一处指针原本所指向的位置。链表的删除主要包括三步，第一步为找到待删除的节点，第二步为修复链表，第三步为释放待删除节点所占用的空间。
单向链表——C语言
Ctrl_C_V_is_easy的博客
08-21 1593
链表相较于顺序表来说有很多优点，尤其是表中间插入和表头插入操作更简单，时间复杂度更低，而且空间利用率更高。单链表从表头开始，每个节点之间用指针来链接，最后一个节点的指针指向NULL，所以链表所用的计算机内存不一定是连续的，而每个节点都由数据域和指针域构成。
链表C语言实现--单向链表
qq_48639334的博客
08-01 3572
链表C语言实现--单向链表
C语言之单向链表
qq_35600620的博客
01-09 307
一、链表 链表是一种常见的数据结构，它可以动态的进行存储分配，根据需要开辟内存单元与释放内存单元，链表中的元素通常由两部份组成：数据域和指针域。 数据域用于存储数据，指针域用于节点的连接。 链表结构如下图所示：链表第一个节点是头指针，每个节点都都包含这数据域与指针域，每个节点与其下一个节点都是通过指针域进行相连的，且最后一个节点的指针域指向NULL。 二、单向链表基本操作 首先我们看...
C语言基础之单向链表
qq1074237849的博客
03-17 532
单向链表是由一个个节点组成，节点没有名字，链表中的每个节点都包含一个存储空间，用于存储数据，以及一个指针，指向下一个节点的位置 达到逻辑上连续。这些节点在内存中是分散存储的，而不是连续存储的。这种分散存储的方式使得链表具有了动态内存分配的能力，可以在运行时根据需要创建和删除节点。
c语言实现数据结构中的单向链表
qq_68695298的博客
09-03 1229
简单易懂教你用c语言实现链表。
数据结构——单向链表（C语言版）
最新发布
2301_80220607的博客
03-22 2606
数据结构单向链表简单直白的教学
单向链表实现（C语言）
li
06-11 1625
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 ...
C语言数据结构之单向链表
cesheng3410的博客
12-19 409
详细讲解单向链表的基础操作，图文并茂
C语言单向链表实现
qq_15983549的博客
12-12 329
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct node { int data; struct node *next; //节点的指针域 } ListNode; typedef ListNode LinkList;//带头节点的单链表 //初始化单链表只有头节点 void InitLinkLis...
【C语言】-- 数据结构 -- 单向单链表
weixin_64609308的博客
05-14 784
概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
C语言实现单向链表
m0_71299382的博客
01-12 600
线性表可以分成两种 一种就是顺序表 也就是我们所熟知的数组 一种是今天的主角–链表他们两者的区别在于 前者是顺序储存元素的 即数组元素的地址值是连续的后者则是链式储存的 节点的地址值不一定连续。
单向链表-C语言实现
To Be A Linux Graphics Coder
06-20 859
只实现了几个简单的操作。在Linux内核中链表的使用非常多，不过使用方法与本例完全不一样。后续有时间再详述。 ChainNode.c#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #define MAX_DATA_LEN 128 #define CN_TRUE 0 #define CN_...
C语言之 - 单向链表
热门推荐
Amosstan的博客
11-20 21万+
C语言之 - 单向链表 一、前言 做项目的时候，经常会遇到这么一个场景：**需要在具有相同属性的数据(例如:学生的学号、名字组成的一串数据)里面查找或者追加或者删除一些数据。**那么，简单的数组远远不能达到目的，因为数组必须实现确定大小，不能动态申请和释放。然而使用malloc动态分配也不能实现，不能够实现局部申请和释放。 那么，链表应运而生。我们这篇文章主要介绍单向链表。 二、链表定义 定义: ...
C语言-单向链表
below_happy的博客
01-12 362
#include <stdio.h> #include <stdlib.h> #include <stdbool.h> struct 结点 { int 数据; //数据域 struct 结点 *下一个; //指针域 }; struct 结点 *创建链表(); struct 结点 *创建结点(int 数据); void 遍历链表(struct 结点 *头结点); struct 结点 *查找结点(struct 结点 *头结点, unsigned .
C语言单向链表详解：表示与实现
C语言单向链表的表示与实现是一种常用的数据结构，它在编程中具有重要的地位，尤其适合于需要顺序遍历但不支持双向访问的场景。本文将详细介绍单向链表的概念、特点以及在C语言中的具体实现。 1. **概念与特点** -...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值