c语言单向链表的实现（带哨兵位）

已于 2023-03-18 11:56:03 修改
阅读量757 收藏 9
点赞数 5
分类专栏： c语言知识总结分享 数据结构 文章标签： 链表 c语言 数据结构
于 2023-03-14 23:00:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72575802/article/details/129458651
版权

文章目录

数据结构中单链表属于基础知识，所谓大厦建立始于地基，基础更加需要牢固地掌握。

提示：以下是本篇文章正文内容，下面案例可供参考

一、单链表的基本介绍

单链表是一种链式存取的数据结构，单链表中的数据是以结点的形式存在，每一个结点是由数据元素和下一个结点的存储的位置组成。单链表与数组相比的最大差别是：单链表的数据元素存放在内存空间的地址是不连续的，而数组的数据元素存放的地址在内存空间中是连续的，这也是为什么根据索引无法像数组那样直接就能查询到数据元素。

但这种不连续的特点为其数据的插入与删除也提供了便捷

二、单链表的实现（带哨兵位）

1.带表头（哑结点/哨兵位）的好处

在没有表头的情况下，涉及到头结点的删除与插入时，必须考虑到NULL在修改时可能导致的编程错误，但加入表头之后，则可以更加简单地解决这个问题。

当然，表头的使用与否取决于个人，部分人认为，添加假想的单元只是为了避免特殊情况，这样的理由并不充分，他们把表头的使用看成和老式的随意删改没有区别。不过，以上争论并不在本篇讨论范围内。

2.基本结构体的建立

为了方便展示链表，数据的存储此处简单的使用了一个int来代替，在实际的使用中，则往往是利用结构体保存数据。

typedef int SLlistData;//（模拟作为存储数据的结构体）保存数据
typedef struct SLlist {
	SLlistData Data;
	struct SLlist* next;
}SLlist;

3.表头的建立（初始化）

在建立链表之前，我们往往将函数的声明放在一个单独的头文件中，函数的定义置于另一.c文件（include包含该.h文件），最后建立test.c文件执行

  • SLlits.h文件内部
SLlist* InitSLlist(SLlist *node);//初始化头结点,返回值为结构体地址，
  • SLlist.c文件内部
#include"Slist.h"
SLlist* InitSLlist(SLlist* node) {
	node = (SLlist*)malloc(sizeof(SLlist));
	if (node == NULL)
	{
		perror("malloc error:");
		exit(-1);//开辟失败，终止程序
	}
	node->next = NULL;
	return node;
}

值得一提的是，此处不可以利用realloc来代替malloc开辟空间，realloc会直接初始化node的节点地址为0，即NULL，导致开辟失败。

  • test.c文件内部
#include"Slist.h"
int main()
{
	SLlist* Head=NULL;//建立表头
	Head=InitSLlist(Head);
}

4.创建节点元素与查找

  • 创建元素节点
SLlist* BuySListnode(SLlistData x) {
	SLlist* node = (SLlist*)malloc(sizeof(SLlist));
	if (node == NULL)
	{
		perror("realloc error:");
		exit(-1);//开辟失败，终止程序
	}
	node->Data = x;
	node->next = NULL;
	return node;
}
  • 创建Find函数(Find函数往往与后面的Print（SLlistprint）函数一起使用
SLlist* FindSLlistnode(SLlist* pHead,SLlistData x) {//cur指current
	assert(pHead);//因为带表头，而表头不被允许为NULL所以要进行断言
	SLlist* cur;
	cur = pHead->next;
	while (cur)
	{
		if (cur->Data == x)
			return cur;
		else
			cur = cur->next;
	}
	return NULL;
}

注意：因为带表头，而表头不被允许为NULL所以要进行断言（或者采取更加温和的方式进行检查）

5.头插头删

表头使用的好处在此处可以很好地体现出来，实现相应功能的代码能清楚的表达基本的指针操作，而不至于因特殊情况而导致含糊不清

  • 头插
void PushFront(SLlist* pHead, SLlistData x) {//头插
	assert(pHead);
	SLlist* node=(SLlist*)malloc(sizeof(SLlist));

	if (node == NULL)
	{
		perror("malloc error:");
		exit(-1);//开辟失败，终止程序
	}
	node = BuySListnode(x);
	node->next = pHead->next;
	pHead->next = node;

}
  • 头删
void PopFront(SLlist* pHead) {
	assert(pHead);//注意此处的pHead指向表头，非真的头结点，不可为NULL
	if (pHead->next == NULL)
		return;
	else
		pHead->next = pHead->next->next;
}

6.尾插尾删

  • 尾插
  • BuySLlistnode(x)创建时next就已经置空，因此后面不必再对next进行操作
  • 真实的头结点可能为NULL，所以需要考虑到一开始头（head）节点就是尾（tail)节点的情况，此时cur可能已经为NULL，则NULL->next的操作非法，因此while内条件采取合取式
void PushBack(SLlist* pHead, SLlistData x) {
	assert(pHead);
	SLlist* cur=pHead->next;
	SLlist* node = BuySLlistnode(x);//创建时next就已经置空
	while (cur&&cur->next)//真实的头结点可能为NULL，所以需要考虑到一开始头（head）节点就是尾（tail)节点的情况
	{
		cur = cur->next;
	}
	if (NULL == cur)
		pHead->next = node;
	else
		cur->next = node;
}
  • 尾删

真头结点为空时也用不上prev，所以prev直接赋为头节点

void PopBack(SLlist* pHead) {
	assert(pHead);
	SLlist* cur = pHead->next;
	SLlist* prev = pHead->next;//真头结点为空时也用不上prev，所以直接赋为头节点
	while (cur && cur->next)
	{
		prev = cur;//保存上一节点
		cur = cur->next;
	}
	if (cur == NULL)
		return;
	else
		prev->next = NULL;
}

7.删除与插入

在这里插入图片描述

  • 删除

值得一提的是，此处free(position)与置空在此处并不起作用，究其根本，在于position在此处本质为地址的形参，其修改不会影响实参。所以，该指针的置空应当在调用完函数后再对实参进行执行/在一开始就传入position的地址（二级指针）以完成对一级指针的修改

  • 还需要注意的是，free的作用是将该数字（转化成十六进制）表示的地址释放，所以此处position虽是形参，但表示的内容是外部实参的地址，因此free在此处是可以释放实参的
void Erasenode(SLlist* pHead, SLlist* position) {
	assert(pHead);
	assert(position);
	SLlist* cur = pHead->next;
	SLlist* prev = pHead->next;
	while (cur != position)
	{
		prev = cur;
		cur = cur->next;
	}
	prev->next = position->next;
	free(position)
	//position=NULL;
}

在这里插入图片描述

  • 插入

此处可能会存在某些任意让人疑惑的点

  • position的值（地址）从何而来：一般通过Find函数来查找到链表内部的节点地址
  • 为何要对position进行断言：若position为NULL，无非两种情况a.未查询到 b.原链表就为NULL.
    以a情况来说，在未查询到节点位置时进行插入这一行为本来就是错误的，所以应该不被允许；
    以b情况来看，原链表为空，则一开始的查询行为就不该存在，而应该直接使用头插/尾插。当查询行为不存在时，Insert函数自然也不会使用（需要的传参不足）；
void Insertnode(SLlist* pHead, SLlist* position, SLlistData x) {//插入数据（找到position地址，插在前面），插入节点的地址position通过Find来查找
	assert(pHead);
	assert(position);//若为NULL则未查询到，或原链表就为空。
	SLlist* node=pHead->next;
	
		if (position == pHead->next)//插为头节点
			PushFront(pHead, x);
		else{
			
				SLlist* prev = node;
				while (node!=position)
				
				{
					//此处判断节点相等时，可能会存在某些疑惑，如poition的地址与链表中相同元素的节点的地址是相同的吗
					node = node->next;
				}
				SLlist* newnode = BuySListnode(x);
				newnode->next = node;
				prev->next = newnode;
			)
}

三、源码

1.SLlist.h

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int SLlistData;//（模拟作为存储数据的结构体）保存数据
typedef struct SLlist {
	SLlistData Data;
	struct SLlist* next;
}SLlist;
SLlist* InitSLlist(SLlist *node);//初始化头结点,返回值为结构体地址
SLlist* BuySLlistnode(SLlistData x);//创建节点
SLlist* FindSLlistnode(SLlist* pHead,SLlistData x);//查找数据节点
void PushFront(SLlist* pHead, SLlistData x);//头插
void PopFront(SLlist* pHead);//头删
void PopBack(SLlist* pHead);//尾删
void Insertnode(SLlist* pHead, SLlist* position, SLlistData x);//插入数据
void Erasenode(SLlist* pHead, SLlist* position);//删除当前节点

void SLlistprint(SLlist* pHead);//展示

2.SLlist.c

#include"Slist.h"
void SLlistprint(SLlist* pHead) {
	SLlist* cur = pHead->next;
	while (cur)
	{
		printf("%d->", cur->Data);
		cur = cur->next;
	}
	printf("NULL\n");
}


SLlist* InitSLlist(SLlist* node) {//初始化头结点,返回值为结构体地址
	node = (SLlist*)malloc(sizeof(SLlist));
	if (node == NULL)
	{
		perror("malloc error:");
		exit(-1);//开辟失败，终止程序
	}
	node->next = NULL;
	return node;
}

SLlist* BuySLlistnode(SLlistData x) {//创建节点
	SLlist* node = (SLlist*)malloc(sizeof(SLlist));
	if (node == NULL)
	{
		perror("malloc error : ");
		exit(-1);//开辟失败，终止程序
	}
	node->Data = x;
	node->next = NULL;
	return node;
}

SLlist* FindSLlistnode(SLlist* pHead,SLlistData x) {//cur指current
	assert(pHead);//因为带表头，而表头不被允许为NULL所以要进行断言
	SLlist* cur;
	cur = pHead->next;
	while (cur)
	{
		if (cur->Data == x)
			return cur;
		else
			cur = cur->next;
	}
	return NULL;
}
void PushFront(SLlist* pHead, SLlistData x) {//头插
	assert(pHead);
	SLlist* node=(SLlist*)malloc(sizeof(SLlist));
	if (node == NULL)
	{
		perror("malloc error:");
		exit(-1);//开辟失败，终止程序
	}
	node = BuySLlistnode(x);//Buy内部为node使用malloc开辟空间了
	node->next = pHead->next;
	pHead->next = node;

}

void PopFront(SLlist* pHead) {
	assert(pHead);//注意此处的pHead指向表头，非真的头结点，不可为NULL
	if (pHead->next == NULL)
		return;
	else
		pHead->next = pHead->next->next;
}

void PushBack(SLlist* pHead, SLlistData x) {
	assert(pHead);
	SLlist* cur=pHead->next;
	SLlist* node = BuySLlistnode(x);//创建时next就已经置空
	while (cur&&cur->next)//真实的头结点可能为NULL，所以需要考虑到一开始头（head）节点就是尾（tail)节点的情况
	{
		cur = cur->next;
	}
	if (NULL == cur)
		pHead->next = node;
	else
		cur->next = node;
}

void PopBack(SLlist* pHead) {
	assert(pHead);
	SLlist* cur = pHead->next;
	SLlist* prev = pHead->next;//真头结点为空时也用不上prev，所以直接赋为头节点
	while (cur && cur->next)
	{
		prev = cur;//保存上一节点
		cur = cur->next;
	}
	if (cur == NULL)
		return;
	else
		prev->next = NULL;
}
void Insertnode(SLlist* pHead, SLlist* position, SLlistData x) {//插入数据（找到position地址，插在前面），插入节点的地址position通过Find来查找
	assert(pHead);
	assert(position);//若为NULL则未查询到，或原链表就为空。
	SLlist* node=pHead->next;
	
		if (position == pHead->next)//插为头节点
			PushFront(pHead, x);
		else
		{
			SLlist* prev = node;
			while (node != position)

			{
				//此处判断节点相等时，可能会存在某些疑惑，如poition的地址与链表中相同元素的节点的地址是相同的吗
				node = node->next;
			}
			SLlist* newnode = BuySLlistnode(x);
			newnode->next = node;
			prev->next = newnode;
		}
}
 
void Erasenode(SLlist* pHead, SLlist* position) {
	assert(pHead);
	assert(position);
	SLlist* cur = pHead->next;
	SLlist* prev = pHead->next;
	while (cur != position)
	{
		prev = cur;
		cur = cur->next;
	}
	prev->next = position->next;
	free(position)
	//position=NULL;
}

结言

带哨兵位的单链表属于最基本的知识，相较于不带哨兵位的单链表在某些方面代码更加简单，但不带表头的链表往往在后面的学习中起着更加重要的作用。所以之后还会写一篇不带表头的单链表与循环的双向链表来进一步加深这方面的学习

Dandely_蒲公英
关注
专栏目录
带哨兵节点和不带哨兵节点的单链表操作的对比
bg2wlj的博客
08-24 1万+
哨兵节点（sentinel）是一个哑元节点（dummy node），可以简化边界条件。
6. 带哨兵的单向循环链表
weixin_30414635的博客
12-25 201
《算法导论》10.2-5 使用单向循环链表实现字典操作插入、删除、查找，并给出运行时间。 单链表虽然不能像双链表一样，实现在任意位置上时间O(1)的插入删除，但是可以在预先指定的位置上实现O(1)时间的插入删除。因为只有该位置的前驱后继两个元素会受到影响，只要维护起这两个元素的信息就够了。 也因为这一点，当使用链表实现栈和队列的时候，采用单链表和双链表的运行时间是一样的，单链表更节省空...
C语言实现单向链表
2401_86557724的博客
09-09 1958
本章使用C语言实现了数据结构中的单向链表，难度也不高，但值得作为学习数据结构的人去亲自实现一下。
10.2-5 带哨兵的单向循环链表
yuanjianchuan的专栏
08-15 478
//带哨兵的单向循环链表。NIL的next是头结点，尾结点的next是NIL #include #include typedef struct NODE{ char key;struct NODE* next; }NODE; NODE *NIL=NULL; void insert(NODE* p) {//插入到头结点 p->next=NIL->next; NIL->next
Java单向链表 带哨兵(黑马)
weixin_53184944的博客
03-28 216
Java单向链表 带哨兵(黑马)
c语言单向链表建立
Jiiaaaoooo的博客
08-07 384
typedef struct Node{ int val; struct Node *next; }Node,*ptrNode; 1、结构体的大小 参考链接 https://blog.csdn.net/jiaozhenxinaichenme/article/details/53097007 char 1 int 4 64位系统中，不管什么类型的指针的大小都是8 cpu一次读取8...
C语言实现单链表 && 双向链表
m0_64240499的博客
08-03 715
单链表&&双向链表
【C语言】链表详解（无头单向非循环）
杨同学的博客
07-29 1845
学习链表之前，先让我们来思考一个问题为什么有了顺序表，还需要有链表这样的数据结构呢？顺序表存在的一些问题顺序表在中间/头部的插入删除，要挪动很多数据，时间复杂度为O(N)，效率太低了。增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。增容一般是一次增长2倍，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。为了更好的解决上述问题，引入了链表。...
C语言详解双向链表的基本操作
qq_61386381的博客
05-17 3666
双链表的定义与接口函数 定义双链表 接口函数 详解接口函数的实现 创建新节点（BuyLTNode） 初始化双链表（ListInit） 双向链表打印（ListPrint） 双链表查找（ListFind） 双链表销毁（ListDestory） 1、双链表pos位置之前插入（ListInsert） 2、双链表删除pos位置（ListEarse） 3、双向链表尾插（ListPushBack） 4、双向链表头插（ListPushFront） 5、双链表头删（ListPopF.......
C语言实现链表排序功能实训
最新发布
xiaohangying的博客
09-15 1490
实训目的:掌握链表的基本概念和操作。学习如何在C语言中实现链表的创建、插入和删除。 理解并实现链表的排序算法，如插入排序。提高编程能力和解决实际问题的能力。
【数据结构】链表其实并不难 —— 手把手带你实现双向链表
StackFrame
11-10 3249
简述双向链表概念、C语言实现双向链表
【C语言】创建单向链表
qq_62704693的博客
03-22 1631
#include<stdio.h> #include<malloc.h> typedef int items; typedef struct cell { items data; struct cell* next; }celltype; typedef celltype* pcelltype; pcelltype top, rear; void push(items x) { pcelltype p; p = (pcelltype)malloc(sizeof(cellty.
C语言 单向链表创建
halikuiyin的博客
07-29 424
单向链表的创建： 1、首先是创建一个头结点，他的数据域可以不设置，也可以设置成记录链表的长度； 2、创建一个尾节点； 3、创建一个要插入的节点； 尾节点的作用是作为新节点的插入点 #include #include #define LEN 8 struct node { int name; struct node *next;
链表：自引用结构
zhoufy的博客
02-13 1136
链表： 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作。 例： #include typedef struct student {
单向链表的C语言实现
Broken_x的博客
05-28 1349
首先，我们需要定义单向链表的结点和链表本身的结构// 单向链表的结点定义// 数据域// 指针域，指向后继结点} Listnode;// 单向链表的定义// 头结点// 整个链表的元素个数和：包含标准输入输出和标准库函数。：定义链表中数据的类型为int，可以根据需要更改。：定义链表结点结构体，包含数据域data和指向后继结点的指针next。：定义链表结构体，包含指向头结点的指针head和链表的元素个数size。
c语言创建单链表
weixin_30549657的博客
06-07 168
//创建单链表 #include <stdio.h>#include <string.h>#include <stdlib.h>typedef struct Student STU; //用typedef 新定义结构体名字为 STU；struct Student //定义时不能直接用STU{char name[20];float score;STU* n...
c语言单向链表的实现
小明的专栏
08-26 366
链表由一系列不必在内存中相连的结构组成。每一个结构均有表元素和执行包含该元素后继元的结构的指针，我们称之为Next指针，最后一个单元的Next指针指向NULL,ANSI C规定NULL为零。 以下为我的单向链表的c语言实现 #include #include struct SignalNode{ int num; struct SignalNode *n
【数据结构】—C语言实现单链表（超详细！）
B1ue还在专注
08-02 4939
这是作者对于单链表学习历程的记录，C语言做到了单链表的实现!很详细，细节都很到位！
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值