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

飞鸟吟2025-03-28 19:34

前言

本篇主要介绍单链表的概念以及用C语言单链表常见功能实现：打印、头插、尾插、任意位置插入、头删、尾删 、任意位置删、查找以及销毁。

用C

单链表

正文

1 概念与结构

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

链表中的每节"车厢"（即数据单元）是独立申请下来的空间，称之为"结点" 。结点的组成主要有两个部分：当前结点要保存的数据和保存下一个结点的地址(指针变量)。

链表的性质：

  1. 链式机构在逻辑上是连续的，在物理结构上不一定连续。
  2. 结点一般是从堆上申请的。
  3. 从堆上申请来的空间，是按照一定策略分配出来的，每次申请的空间可能连续，可能不连续。

假设当前保存的结点为整型，对应的结构体代码：

c 复制代码 
struct SListNode
{
    int data; // 结点数据
    struct SListNode* next; //指针变量用保存下一个结点的地址
};
3.1.3 链表的打印
c 复制代码 
void SLTPrint(SLTNode* phead)
{
    SLTNode *pcur = phead;
    while(pcur)
    {
        printf("%d ",pcur->data);
        pcur = pcur->next;
    }
    printf("\n");
}

思考 ：当我们想保存的数据类型为字符型、浮点型或者其他自定义的类型时，该如何修改？

答：将数据类型用typedef取别名，需要时修改别名即可，代码如下：

c 复制代码 
typedef int SLTDataType;

3.2 纯C语言实现单链表

本代码依旧用工程文件的形式给出：

SList.h

.h文件包括创建单、链表函数声明

c 复制代码 
//SList.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>

//定义链表的结构
typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

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

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);

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

//头删
void SLTPopFront(SLTNode** pphead);

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);

//指定位置之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

//在指定位置之后插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

//删除pos结点
void SLTErase(SLTNode** pphead, SLTNode* pos);

//删除pos之后的结点
void SLTSraseAfter(SLTNode* pos);

//销毁链表
void SListDestroy(SLTNode** pphead);
SList.c（分模块）

我们分模块完成

头插、尾插以及创建结点

插入必须创建新结点，在后续过程中要重复很多次，不如我们直接封装成函数

c 复制代码 
 SLTNode* SLTbuyNode(SLTDataType x)
{
	//根据x创建节点
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

头插

c 复制代码 
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTbuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

新建立一个结点，让他的next指针指向头节点（pphead）,然后让新节点成为头节点，实现一次头插
尾插

c 复制代码 
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTbuyNode(x);

	//链表尾空
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	//链表不为空
	else 
	{
		//找尾
		SLTNode* ptail = *pphead;
		while (ptail ->next)
		{
			ptail = ptail->next;
		}
		ptail->next = newnode;
	}	
}

链表为空，直接创立新结点，不为空，遍历找到尾节点，尾结点的next指针指向newnode

指定位置插入

指定位置之前插入

c 复制代码 
//指定位置之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead&&pos);
	//当pos指向第一个结点
	if (pos == *pphead)
	{
		//直接头插
		SLTPushFront(pphead, x);
	}

	//不是头节点
	else
	{
		SLTNode* newnode = SLTbuyNode(x);

		//找pos的前一个结点
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//注意插入顺序
		prev->next = newnode;
		newnode->next = pos;
	}
}

找到pos的前一个结点，插入新节点，注意插入方法
指定位置之后插入

c 复制代码 
//在指定位置之后插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTbuyNode(x);

	newnode->next = pos->next;
	pos->next = newnode;
}


注意 /后面是第一步

头删、尾删、指定位置删除

头删

c 复制代码 
//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

保存头节点的下一个结点，释放头节点，next成为新的头节点
尾删

c 复制代码 
//尾删
void SLTPopBack(SLTNode** pphead) 
{
    // 断言确保传入的指针有效，且链表不为空
    assert(pphead && *pphead);

    // 处理链表只有一个节点的情况
    if ((*pphead)->next == NULL) 
    {
        free(*pphead);    // 释放头节点
        *pphead = NULL;  // 头指针置空，防止悬垂指针
    } 
    else 
    {
        SLTNode* prev = NULL;       // 记录尾节点的前驱节点
        SLTNode* ptail = *pphead;   // 用于遍历找到尾节点
        
        // 遍历直到ptail指向尾节点（ptail->next为NULL时停止）
        while (ptail->next) 
        {
            prev = ptail;          // prev跟随ptail移动
            ptail = ptail->next;   // ptail前进到下一个节点
        }
        
        // 此时：
        // - ptail指向尾节点
        // - prev指向尾节点的前驱节点
        
        prev->next = NULL;  // 断开前驱节点与尾节点的连接
        free(ptail);       // 释放尾节点
        ptail = NULL;      // 可选：局部变量置空（实际无必要）
    }
}

指定位置删

c 复制代码 
//删除pos结点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos && pphead);
	//pos是头结点
	//头删
	if (pos == pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		//遍历寻找pos结点
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		找到后prev指向pos的下一个结点
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

//删除pos之后的结点
void SLTSraseAfter(SLTNode* pos)
{
	assert(pos&&pos->next );

	SLTNode* del = pos->next;
	//可以理解为将pos的下一个结点指向它下下个结点
	pos->next = del->next;
	free(del);
	del = NULL;
}
查找

查找较简单，遍历，找到返回，找不到返回NULL

c 复制代码 
//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}
摧毁
c 复制代码 
//销毁链表
void SListDestroy(SLTNode** pphead)
{
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}
SList.c
c 复制代码 
#include"SList.h"


void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d -> ", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

 SLTNode* SLTbuyNode(SLTDataType x)
{
	//根据x创建节点
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTbuyNode(x);

	//链表尾空
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	//链表不为空
	else 
	{
		//找尾
		SLTNode* ptail = *pphead;
		while (ptail ->next)
		{
			ptail = ptail->next;
		}
		ptail->next = newnode;
	}	
}


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


//尾删
void SLTPopBack(SLTNode** pphead) 
{
    // 断言确保传入的指针有效，且链表不为空
    assert(pphead && *pphead);

    // 处理链表只有一个节点的情况
    if ((*pphead)->next == NULL) 
    {
        free(*pphead);    // 释放头节点
        *pphead = NULL;  // 头指针置空，防止悬垂指针
    } 
    else 
    {
        SLTNode* prev = NULL;       // 记录尾节点的前驱节点
        SLTNode* ptail = *pphead;   // 用于遍历找到尾节点
        
        // 遍历直到ptail指向尾节点（ptail->next为NULL时停止）
        while (ptail->next) 
        {
            prev = ptail;          // prev跟随ptail移动
            ptail = ptail->next;   // ptail前进到下一个节点
        }
        
        // 此时：
        // - ptail指向尾节点
        // - prev指向尾节点的前驱节点
        
        prev->next = NULL;  // 断开前驱节点与尾节点的连接
        free(ptail);       // 释放尾节点
        ptail = NULL;      // 可选：局部变量置空（实际无必要）
    }
}

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


//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

//指定位置之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead&&pos);
	//当pos指向第一个结点
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}

	//不是头节点
	else
	{
		SLTNode* newnode = SLTbuyNode(x);

		//找pos的前一个结点
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = newnode;
		newnode->next = pos;
	}
}

//在指定位置之后插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTbuyNode(x);

	newnode->next = pos->next;
	pos->next = newnode;
}

//删除pos结点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos && pphead);
	//pos是头结点
	if (pos == pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

//删除pos之后的结点
void SLTSraseAfter(SLTNode* pos)
{
	assert(pos&&pos->next );

	SLTNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

//销毁链表
void SListDestroy(SLTNode** pphead)
{
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}
test.c

根据需要调试使用

c 复制代码 
#include"SList.h"

void test()
{
	SLTNode *node = (SLTNode*)malloc(sizeof(SLTNode));
	//SLTPrint();//不需要修改内容，传值
}

void test02()
{
	//创建新链表
	SLTNode* plist = NULL;
	/*SLTPrint(plist);
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);*/

	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPushFront(&plist, 5);
	SLTPushFront(&plist, 6);
	SLTPushFront(&plist, 7);
	SLTPrint(plist);
	//SLTPopBach(&plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	SLTNode *find = SLTFind(plist, 4);
	//if (find)
	//{
	//	printf("找到了\n");
	//}
	//else
	//{
	//	printf("找不到！\n");
	//}
	//SLTPrint(plist);

	//SLTInsert(&plist, find, 7);
	SLTInsertAfter(find, 100);
	SLTPrint(plist);

	SLTErase(&plist, find);
	SLTPrint(plist);
	SListDestroy(&plist);
}

int main()
{
	test02();
	return 0;
}

总结

这篇文章是单链表的基础内容，如有错误，还望指正，共同进步，谢谢

相关推荐
失去妙妙屋的米奇7 分钟前
Python库与Excel
开发语言·python·excel
API小爬虫20 分钟前
如何设置动态代理提高Python爬虫稳定性？
开发语言·爬虫·python
无名之逆21 分钟前
hyperlane：Rust HTTP 服务器开发的不二之选
服务器·开发语言·前端·后端·安全·http·rust
篝火悟者23 分钟前
自学-python-爬虫入门
开发语言·爬虫·python
老赵骑摩托31 分钟前
Go语言nil原理深度解析：底层实现与比较规则
开发语言·后端·golang
酷爱码31 分钟前
python和Java的区别
java·开发语言
胡斌附体42 分钟前
Qt下载模板到本地文件内容丢失问题
开发语言·qt
愚戏师1 小时前
数据结构与算法分析：树与哈希表（一）
数据结构·算法·链表·深度优先·广度优先·宽度优先
编码小笨猪1 小时前
[ C++ ] | C++11 从左值引用到右值引用
开发语言·c++
freexyn1 小时前
Matlab自学笔记四十九：类型识别：判断数据的类型和类别
数据结构·笔记·matlab
热门推荐
01【笔记】MJ Prompt02RAG 实践- Ollama+RagFlow 部署本地知识库03DeepSeek各版本说明与优缺点分析04uniApp使用XR-Frame创建3D场景(3)光源投影的运用。05本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程06从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑07【通信中间件】Fdbus HelloWorld实例08苍穹外卖面试总结09如何在WPS和Word/Excel中直接使用DeepSeek功能10HTML项目一键打包工具：HTML2EXE 最新版