数据结构（初阶）—— C语言实现单链表

已于 2022-06-20 16:54:52 修改
阅读量1.7k 收藏 10
点赞数 14
分类专栏： 数据结构初阶 文章标签： c语言 算法 数据结构
于 2022-04-02 17:20:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sjsjnsjnn/article/details/123920224
版权

 

目录

一、链表的概念

二、单链表的接口实现

1.首先创建一个链表的结构

2.单链表的结点申请

3.单链表的打印 

4.单链表的尾插 

5.单链表的头插

6.单链表的尾删 

7.单链表的头删 

8.单链表的查找 

9.单链表在pos位置前插入一个结点 

10.单链表在pos位置后插入一个结点

11.单链表删除pos位置的结点 

12.单链表删除pos位置后的结点 

13.单链表的销毁 

三、源文件

SList.h 

SList.c 

Test.c 

一、链表的概念

        链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
        链表由两个部分组成：数据域和指针域，数据域用来存放数据，指针域用来链接到下一个数据，具体看下图；

         从图中可以看出，每个数据的下面的指针域里都存储了下一个数据的地址，那么我们通过访问第一个数据的地址，顺藤摸瓜就能访问到其他数据 

二、单链表的接口实现

1.首先创建一个链表的结构

typedef int SLDataType;//这里typedef可以用于存储类型之间的切换

typedef struct SListNode
{
	SLDataType Data;//数据域
	struct SListNode* next;//指针域
}SLNode;

2.单链表的结点申请

//动态申请一个结点
SLNode* BuyListNode(SLDataType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->Data = x;       //x的值存放在newnode数据域中
	newnode->next = NULL;    //newnode的指针域置空
	return newnode;
}

3.单链表的打印 

//单链表的打印
void SListPrint(SLNode* phead)
{
	assert(phead);
	SLNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->Data);  //打印链表数据
		cur = cur->next;  //让cur指向下一个数据
	} //当cur为空时，链表打印结束
	printf("NULL\n\n");
}

  

4.单链表的尾插 

//单链表的尾插
void SListPushBack(SLNode** pphead, SLDataType x)
{
	assert(pphead);
	SLNode* newnode = BuyListNode(x);//插入数据需要申请结点
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
        //尾插--就去找链表的尾巴
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
        //找到尾巴，把尾结点的指针域指向插入的新结点的地址
		tail->next = newnode;
	}
}

5.单链表的头插

//单链表的头插
void SListPushFront(SLNode** pphead, SLDataType x)
{
	assert(pphead);
	SLNode* newnode = BuyListNode(x);
	newnode->next = *pphead; //让newnode的指针域指向链表的数据域（就是链表的头）
	*pphead = newnode; //让newnode作新链表的头
}

6.单链表的尾删 

//单链表的尾删
void SListPopBack(SLNode** pphead)
{
	assert(*pphead);
    //如果链表为空
	if (*pphead == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
        //先要找到尾结点（tail），在记录一下尾结点的前一个结点（prev）；
		SLNode* tail = *pphead;
		SLNode* prev = NULL;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
        //找到尾结点了，释放它并置空；
		free(tail);
		tail = NULL;
        //此时尾结点的前一个结点（prev）还保存着tail结点的数据的地址，要让它置空；
		prev->next = NULL;
	}
}

7.单链表的头删 

//单链表的头删
void SListPopFront(SLNode** pphead)
{
	assert(*pphead);
	SLNode* next = (*pphead)->next;//记录头结点的下一个结点的地址
	free(*pphead);//释放头结点
	*pphead = next;//头结点的下一个结点作新的头
}

8.单链表的查找 

//单链表的查找
SLNode* SListFind(SLNode* phead, SLDataType x)
{
	assert(phead);
	SLNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->Data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

9.单链表在pos位置前插入一个结点 

//单链表在pos位置前插入一个结点
void SListInsert(SLNode** pphead, SLNode* pos, SLDataType x)
{
	assert(pphead);
	assert(pos);
	SLNode* newnode = BuyListNode(x);//申请结点
    //如果只有一个结点
	if (*pphead == pos)
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
	else
	{
        //找到pos位置的前一个结点，并记录
		SLNode* posprev = *pphead;
		while (posprev->next != pos)
		{
			posprev = posprev->next;
		}
        //让新结点的指针域指向pos，再让pos的前一个结点的指针域重新指向新结点的数据域地址，就很好的插入到pos的前面了
		newnode->next = pos;
		posprev->next = newnode;
	}
}

10.单链表在pos位置后插入一个结点

//单链表在pos位置后插入一个节点
void SListInsertAfter(SLNode* pos, SLDataType x)
{
	assert(pos);
	SLNode* newnode = BuyListNode(x);//申请结点
	newnode->next = pos->next;//让新结点的指针域指向pos位置的下一个结点的数据域地址
	pos->next = newnode;//pos的指针域指向新结点的数据域地址
}

11.单链表删除pos位置的结点 

//单链表删除pos位置的节点
void SListErase(SLNode** pphead, SLNode* pos)
{
	assert(*pphead);
    //如果链表只有一个结点
	if (*pphead == pos)
	{
		SListPopBack(pphead);
	}
	else
	{
        //找到pos位置的前一个位置（posPrev），并记录
		SLNode* posPrev = *pphead;
		while (posPrev->next != pos)
		{
			posPrev = posPrev->next;
		}
        //让pos位置的前一个结点posPrev的指针域指向pos结点的指针域，如果pos位置还有结点，即指向了pos位置的下一个结点的数据域的地址；
		posPrev->next = pos->next;
		free(pos);//释放pos
	}
}

12.单链表删除pos位置后的结点 

//单链表删除pos位置后的节点
void SListEraseAfter(SLNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLNode* next = pos->next;
	pos->next = next->next;
	free(next);
}

13.单链表的销毁 

        单链表的销毁并不能和顺序表一样直接释放，顺序表是开辟的连续的空间，链表不是；

要将链表释放需要释放每一个结点；

        可以采用双指针； 

//单链表的销毁
void SListDestroy(SLNode** pphead)
{
	assert(*pphead);
	SLNode* cur = *pphead;
	while (cur != NULL)
	{
		SLNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

三、源文件

SList.h 

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


typedef int SLDataType;

typedef struct SListNode
{
	SLDataType Data;
	struct SListNode* next;
}SLNode;


//动态申请一个节点
SLNode* BuyListNode(SLDataType x);

//单链表的打印
void SListPrint(SLNode* phead);

//单链表的尾插
void SListPushBack(SLNode** pphead, SLDataType x);

//单链表的头插
void SListPushFront(SLNode** pphead, SLDataType x);

//单链表的尾删
void SListPopBack(SLNode** pphead);

//单链表的头删
void SListPopFront(SLNode** pphead);

//单链表的查找
SLNode* SListFind(SLNode* phead, SLDataType x);

//单链表在pos位置前插入一个节点
void SListInsert(SLNode** pphead, SLNode* pos, SLDataType x);

//单链表在pos位置后插入一个节点
void SListInsertAfter(SLNode* pos, SLDataType x);

//单链表删除pos位置的节点
void SListErase(SLNode** pphead, SLNode* pos);

//单链表删除pos位置后的节点
void SListEraseAfter(SLNode* pos);

//单链表的销毁
void SListDestroy(SLNode** pphead);

SList.c 

#include "SList.h"


//动态申请一个结点
SLNode* BuyListNode(SLDataType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->Data = x;       //x的值存放在newnode数据域中
	newnode->next = NULL;    //newnode的指针域置空
	return newnode;
}

//单链表的打印
void SListPrint(SLNode* phead)
{
	assert(phead);
	SLNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->Data);  //打印链表数据
		cur = cur->next;  //让cur指向下一个数据
	} //当cur为空时，链表打印结束
	printf("NULL\n\n");
}

//单链表的尾插
void SListPushBack(SLNode** pphead, SLDataType x)
{
	assert(pphead);
	SLNode* newnode = BuyListNode(x);//插入数据需要申请结点
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//尾插--就去找链表的尾巴
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		//找到尾巴，把尾结点的指针域指向插入的新结点的地址
		tail->next = newnode;
	}
}

//单链表的头插
void SListPushFront(SLNode** pphead, SLDataType x)
{
	assert(pphead);
	SLNode* newnode = BuyListNode(x);
	newnode->next = *pphead; //让newnode的指针域指向链表的数据域（就是链表的头）
	*pphead = newnode; //让newnode作新链表的头
}

//单链表的尾删
void SListPopBack(SLNode** pphead)
{
	assert(*pphead);
	//如果链表为空
	if (*pphead == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//先要找到尾结点（tail），在记录一下尾结点的前一个结点（prev）；
		SLNode* tail = *pphead;
		SLNode* prev = NULL;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		//找到尾结点了，释放它并置空；
		free(tail);
		tail = NULL;
		//此时尾结点的前一个结点（prev）还保存着tail结点的数据的地址，要让它置空；
		prev->next = NULL;
	}
}

//单链表的头删
void SListPopFront(SLNode** pphead)
{
	assert(*pphead);
	SLNode* next = (*pphead)->next;//记录头结点的下一个结点的地址
	free(*pphead);//释放头结点
	*pphead = next;//头结点的下一个结点作新的头
}

//单链表的查找
SLNode* SListFind(SLNode* phead, SLDataType x)
{
	assert(phead);
	SLNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->Data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

//单链表在pos位置前插入一个结点
void SListInsert(SLNode** pphead, SLNode* pos, SLDataType x)
{
	assert(pphead);
	assert(pos);
	SLNode* newnode = BuyListNode(x);//申请结点
	//如果只有一个结点
	if (*pphead == pos)
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
	else
	{
		//找到pos位置的前一个结点，并记录
		SLNode* posprev = *pphead;
		while (posprev->next != pos)
		{
			posprev = posprev->next;
		}
		//让新结点的指针域指向pos，再让pos的前一个结点的指针域重新指向新结点的数据域地址，就很好的插入到pos的前面了
		newnode->next = pos;
		posprev->next = newnode;
	}
}

//单链表在pos位置后插入一个节点
void SListInsertAfter(SLNode* pos, SLDataType x)
{
	assert(pos);
	SLNode* newnode = BuyListNode(x);//申请结点
	newnode->next = pos->next;//让新结点的指针域指向pos位置的下一个结点的数据域地址
	pos->next = newnode;//pos的指针域指向新结点的数据域地址
}

//单链表删除pos位置的节点
void SListErase(SLNode** pphead, SLNode* pos)
{
	assert(*pphead);
	//如果链表只有一个结点
	if (*pphead == pos)
	{
		SListPopBack(pphead);
	}
	else
	{
		//找到pos位置的前一个位置（posPrev），并记录
		SLNode* posPrev = *pphead;
		while (posPrev->next != pos)
		{
			posPrev = posPrev->next;
		}
		//让pos位置的前一个结点posPrev的指针域指向pos结点的指针域，如果pos位置还有结点，即指向了pos位置的下一个结点的数据域的地址；
		posPrev->next = pos->next;
		free(pos);//释放pos
	}
}

//单链表删除pos位置后的节点
void SListEraseAfter(SLNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLNode* next = pos->next;
	pos->next = next->next;
	free(next);
}

//单链表的销毁
void SListDestroy(SLNode** pphead)
{
	assert(*pphead);
	SLNode* cur = *pphead;
	while (cur != NULL)
	{
		SLNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

Test.c 

#include "SList.h"


void TestList1()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPushBack(&plist, 5);
	SListPrint(plist);
	//SListPushFront(&plist, 1);
	//SListPushFront(&plist, 2);
	//SListPushFront(&plist, 3);
	//SListPushFront(&plist, 4);
	//SListPushFront(&plist, 5);
	//SListPrint(plist);
}

void TestList2()
{
	SLTNode* plist = NULL;
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 4);
	SListPushFront(&plist, 5);
	SListPopFront(&plist);
	SListPopFront(&plist);

	SListPrint(plist);
}

void TestList3()
{
	SLTNode* plist = NULL;
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 5);
	SListPrint(plist);

	SLTNode* pos = SListFind(plist, 2);
	int i = 1;
	while (pos)
	{
		printf("%d个pos节点:%p->%d\n", i++, pos, pos->data);
		pos = SListFind(pos->next, 2);
	}

	pos = SListFind(plist, 3);
	if (pos)
	{
		pos->data = 30;
	}
	SListPrint(plist);
}

void TestList4()
{
	SLTNode* plist = NULL;
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 4);
	SListPushFront(&plist, 5);

	SListPrint(plist);

	//SLTNode* pos = SListFind(plist, 5);

	//if (pos)
	//{
	//	SListInsert(&plist, pos, 30);
	//}
	//SListPrint(plist);
}

void TestList5()
{
	SLTNode* plist = NULL;
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 4);
	SListPushFront(&plist, 5);

	SListPrint(plist);

	/*
	SLTNode* pos = SListFind(plist, 5);
	SListInsertAfter(pos, 20);
	SListPrint(plist);
	*/

	/*
	SLTNode* pos = SListFind(plist, 3);
	SListEase(&plist, pos);
	SListPrint(plist);
	*/
	SLTNode* pos = SListFind(plist, 5);
	SListEaseAfter(pos);
	SListPrint(plist);
	SListDestory(&plist);
}
int main()
{
	TestList1();
	//TestList2();
	//TestList3();
	//TestList4();
	//TestList5();
	return 0;
}

下一期更新顺序表和链表相关的LeetCode题

霄沫凡
关注
  • 14
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
C语言实现数据结构算法初阶算法
06-15
C语言实现数据结构算法初阶算法：顺序表、单向链表、双向循环链表、栈、队列、二叉树的遍历、创建哈夫曼树、求解哈夫曼编码。
C语言实现单链表（超多配图，这下不得不学会单链表了）
2301_76269963的博客
03-16 7762
C语言实现单链表
【数据结构】—C语言实现单链表（超详细！）
B1ue还在专注
08-02 3512
这是作者对于单链表学习历程的记录，C语言做到了单链表的实现!很详细，细节都很到位！
【 数据结构 】单链表的实现 - 详解（C语言版）
上上谦. 的博客
03-22 1万+
前言 简单用C语言来描述数据结构中的单链表，本文实现的只是简单的无头单链表，包括单链表的增加数据，删除数据，查找指定数据，修改指定数据，也就是简单的增删查改等操作。
单链表（C语言实现）
cw412524的博客
11-20 1690
数据结构单链表（C语言实现），干货满满！
【数据结构】C语言实现单链表
SHLYYY
04-30 2682
SLLNode;// 打印 void SLLPrint(SLLNode * phead);// 头插、尾插 void SLLPushFront(SLLNode * * pphead , SLLDataType x);// 头删、尾删 void SLLPopFront(SLLNode * * pphead);// 查找 SLLNode * SLLFind(SLLNode * phead , SLLDataType x);
数据结构初阶数据结构初阶
02-12
数据结构
本仓库用于记录与发布日常学习中所编写的C语言代码以及使用C语言实现的初阶数据结构代码 .zip
最新发布
04-19
C语言诞生于美国的贝尔实验室，由丹尼斯·里奇（Dennis MacAlistair Ritchie）以肯尼斯·蓝·汤普森（Kenneth Lane Thompson）设计的B语言为基础发展而来，在它的主体设计完成后，汤普森和里奇用它完全重写了UNIX，...
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-23
数据结构
C语言初阶-(单向链表)
03-08
适用于数据结构初学者使用 线性表的单链表存储结构，整个链表的存取必须从头指针开始进行，头指针指示链表中第一个结点 (第一个数据元素的存储映像，也称首元结点)的存储位置。同时，由于最后一个数据元素没有 直接...
单链表的实现（C语言）
weixin_57604904的博客
10-11 1232
单链表的实现
【数据结构】---单链表【C语言实现】
mike_jun的博客
07-10 4081
1. 单向链表 我们都熟悉数组，它作为一个顺序储存方式数据结构为我们的程序设计带来了大量的便利，几乎任何的高级程序设计，算法设计都离不开数组的灵活使用。 但是，数组最大的缺点就是我们的插入和删除时需要移动大量的元素，显然这需要消耗大量的时间。 数组找到指定元素很快，O（1）复杂度就可以，而链表只能是遍历，O(n)的复杂度。 数组是顺序存储的，链表是通过指针实现不连续的存储 相比起数组，链表解决了数组不方便移动，插入，删除元素的弊端，但相应的，链表付出了更加大的内存牺牲换来的这些功能的实现。 ...
单链表—C语言实现数据结构
2201_76062618的博客
05-28 4517
本文具体讲解单链表的结构，内容较为丰富，干货多多
单链表详解（C语言版）
热门推荐
qq_44075108的博客
09-27 2万+
本文介绍单链表的定义、常用操作、优化和使用的注意点等内容。
C语言实现单链表
m0_70885714的博客
10-19 5469
单链表的基本操作 单链表的基本操作包括单链表的初始化、建立、插入、查找、修改、打印、表长的输出等等运算。其中比较重要的是按值查找元素、查找某位置并插入元素、修改某位置的元素以及尾插法建表。目前该表是只实现了这些操作，并进行的测试。
数据结构：单链表的实现(C语言)
li209779的博客
07-31 1243
本博客将要实现的无头单向不循环链表。我们将节点定义为如下结构：其成员变量有data，next。将int重命名为STLDataType，方便我们以后修改数据域的内容。//无头单向不循环链表 typedef int SLTDataType;以上就是我对于无头单向不循环链表的实现！！！
数据结构—单链表C语言实现
weixin_56438185的博客
03-19 1226
目录 一、链表的概念与结构 二、定义结构体 三、打印单链表 四、增加链表结构 五、尾插 六、尾删 七、头插 八、头删 九、查找指定数据 十、在pos位置之前插入 十一、在pos位置之后插入 十二、删除pos位置数据 十三、删除pos之后一个位置数据 十四、销毁动态开辟的空间 总结 一、链表的概念与结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 结构： 二、定义结构体 typedef .
【数据结构】单链表详解
weixin_60371270的博客
11-07 923
该篇文章主要讲述了链表的分类和其中的单链表的实现。
数据结构——单链表详解（C语言实现）
sinzz的博客
03-08 1221
首先，我们需要知道，单链表内所需要的数据有两种，一种是数据，还有就是下一个节点的指针。所以我们需要定义一个结构体。//重命名单链表的数据 //便于不同数据类型的切换 typedef struct SLTNode {//SLTNode* next//错误 //改写法C语言是不支持的 //struct SLTNode//错误 } SLTNode;
c语言入门自学零基础
09-05
- *1* *2* *3* [C语言初阶——手把手教零基础/新手入门（万字心得笔记）](https://blog.csdn.net/m0_63312733/article/details/122145605)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

霄沫凡

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

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

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

打赏作者

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

抵扣说明：

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

余额充值