不带哨兵卫单链表实现（C语言版）

一个不是程序员的程序员*

已于 2023-09-14 16:17:39 修改

阅读量29

点赞数

分类专栏：数据结构文章标签： c语言链表数据结构算法 c++

于 2023-09-14 16:07:35 首次发布

本文链接：https://blog.csdn.net/m0_71253709/article/details/132881038

版权

数据结构专栏收录该内容

4 篇文章 0 订阅

订阅专栏

背景

不带哨兵卫的单链表代码构建，方便以后复习。

code

1、SLT.h

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once 
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

//打印节点
void SLTPrint(SLTNode* phead);

//动态申请一个节点
SLTNode* BuySListNode(SLTDataType x);

//尾插:想要尾插肯定要传入一个头指针呀 不然的话怎么找到尾呢？
void SLTPushBack(SLTNode** pphead, SLTDataType x);

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);
 
//尾删:通过plist找到尾巴进行删除(当删除到最后一个的时候我们需要将plist置空，改变plist,用二级指针)
void SLTPopBack(SLTNode** pphead);

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

//按值查找某个元素的位置
SLTNode* SLTFindval(SLTNode* phead, SLTDataType x);

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

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

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

//删除pos后一个位置
void SLTEraseAfter(SLTNode* pos);

2、STL.c

#include"SLT.h"

void SLTPrint(SLTNode* phead)
{
	//assert(phead != NULL);     //不用断言 当phead为NULL时 表示没有链表 正常
	SLTNode* cur = phead;        //cur指向第一个节点（节点就是指向这个SListNode的结构体指针）
	while (cur != NULL)          //最后一个节点为空   //这里为什么不可以用 cur->next != NULL 来当成循环终止的条件呢？（类似与尾插的终止条件）
	{                                                 //因为链表的尾节点的指针域肯定为空的呀
		printf("%d->", cur->data);                    //我认为当链表存在（有一个或以上）的时候，用以上条件应该没有问题，
		                                              //但是当只有一个头指针的时候我们还如何用cur->next != NULL来判断呢 头指针为NULL哪里来的指针域呢？
		cur = cur->next;        
	}
	printf("NULL\n");
}

SLTNode* BuySListNode(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;
}


//平时我们采用地址传参时，实际上是两个指针指向了同一块空间，通过解引用的方式改变这块空间里面的值
//在这里我们需要改变的是头指针（指针实际上就是地址）的地址(我们需要将头指针的地址给新节点)，一个指针的地址，我们在传参的时候
//应该用一个二级指针来接收，我们通过解引用的操作就可以找到一级指针
//想改变int用int*；想要改变int*用int**;
// 改变结构体用结构体的指针，改变结构体指针要用结构体指针的指针（二级指针 ）
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead != NULL); //pphead为plist的地址，plist有可能为空，但是plist的地址不可能为空呀！
	SLTNode* newnode = BuySListNode(x);   //为x申请一个新节点（堆区申请）

	if (*pphead == NULL)             //pphead = plist;
	{
		//改变的结构体的指针，所以要用二级指针
		*pphead = newnode;            //当没有节点的时候，我们先插入一个节点，但是当你这么写的时候有问题没有呢？
		                             //显然当phead出来这个函数的作用域就销毁了，但是节点的地址newnod没有给到外面的plist
		                             //那你外面的plist如何可以访问到newnode呢？这里的解决办法是采用二级指针
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next != NULL)            //找到最后一个节点
		{
			tail = tail->next;
		}

		//改变结构体，所以用结构体指针即可
		tail->next = newnode;                 //最后一个节点的指针域指向新节点
											  //有节点的时候才能这样用啊，要是没有节点，就一个
											  //头指针哪里来的指针域呢？
	}
}
//调用这个函数完之后，局部变量 phead、tail、newnode都要销毁，但是这个节点不会销毁，因为是在堆区开辟的
//这里的newnode指针域不用置空，因为malloc新节点的时候，已经置空了


void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead != NULL);  //空链表可以尾插，所以*pphead = plist不需要断言；
	SLTNode* newnode = BuySListNode(x);
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	else
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
}

//尾删
void SLTPopBack(SLTNode** pphead)
{
	//1、空
	assert(pphead != NULL);      //*pphead != NULL为真 断言成功表示程序正确 assert() 不进行任何操作
	assert(*pphead != NULL);     //空链表不可以尾删，所以*pphead = plist需要断言；
	//2、一个节点 没有前一个的next 所以需要单独判断
	//3、两个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//1、 
		SLTNode* tail = *pphead;
		SLTNode* tailPrev = NULL;
		
		while (tail->next != NULL)  //找到最后一个节点
		{
			tailPrev = tail;
			tail = tail->next;
		}
		
		free(tail);               //释放最后一个节点
		tailPrev->next = NULL;    //将最后一个节点的前一个节点的指针域置空

		//2、
		//SLTNode* trail = *pphead;
		//while (trail->next->next == NULL)  //就是trail每移动一步，我们移动两步进行判断
		//{
		//	trail = trail->next;
		//}

		//free(trail->next);          //释放最后一个节点
		//trail->next = NULL;   //将最后一个节点的前一个节点的指针域置空
	}

}


//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead != NULL);
	assert(*pphead != NULL);                 //当没有节点时，直接断言失败
	                                         //当只有一个节点的时候，下面的逻辑也可解决

	SLTNode* newnode = (*pphead)->next;     //先将第一个节点的指针域保存到newnode
	free(*pphead);                          //释放第一个节点
	*pphead = newnode;                      //头指针指向新的第一个节点           
}


SLTNode* SLTFindval(SLTNode* phead, SLTDataType x)
{
	assert(phead != NULL);

	SLTNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}

	perror("findval fail:");
	return NULL;
}


//在pos之前插入一个数
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	
	SLTNode* newnode = BuySListNode(x);
	assert(pphead != NULL);
	assert(pos != NULL);

	1、
	//if ((*pphead) == pos)   //只有一个元素
	//{
	//	newnode->next = *pphead;
	//	*pphead = newnode;
	//}
	//else
	//{	 
	//	SLTNode* prev = NULL;       //找到某个元素之前的一个指针
	//	SLTNode* phead = *pphead;   //定义一个头指针
	//	while (phead != pos)
	//	{
	//		prev = phead;
	//		phead = phead->next;
	//	}		
	//	newnode->next = pos;
	//	prev->next = newnode;		
	//}

	2、
	if (pos == *pphead)
	{
		SLTPopFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos) //注意这里prev != pos 与 prev->next != pos的区别
		{                         //prev->next != pos 循环之后prev是pos的前一个节点
			prev = prev->next;    //prev != pos  循环之后prev和pos是一个节点
		}                         //同理 要是prev->next != NULL 循环之后prev指向为最后一个节点
		prev->next = newnode;     //prev = NULL 循环之后prev指向为最后一个节点的下一个节点
		newnode->next = pos;
	}
}

//在pos之后调用
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos != NULL);
	SLTNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

//删除pos位置 
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead != NULL);
	assert(*pphead != NULL);
	assert(pos != NULL);

	if (pos == *pphead)
	{
		*pphead = (*pphead)->next;
		free(pos);
		//pos = NULL;
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		//pos = NULL; //这里置空与否无所谓 因为这个形参的改变不会影响实参，除非你传的是一个二级指针
		              //外面的这个pos实际上还是一个野指针，所以外面的使用者要注意这个野指针的情况
	}
}

//删除pos位置的下一个位置
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos != NULL);        //检查是否存在pos节点
	assert(pos->next != NULL);  //检查pos是否为尾节点

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

//单链表头插头删用的比较多，而且效率也比较高
//对于链表断言 头插、尾插只有pphead需要断言 因为pphead表示的时一级指针的地址 地址不能为空
//对于链表断言 头删、尾删 pphead与*pphead都需要断言*pphead表示头指针，头指针都为空了表示没有没有链表节点了 你还怎么删除呢？

3、Test_SLT.c

#include"SLT.h"

void test1()
{

	SLTNode* plist = NULL;

	SLTPushBack(&plist, 6);
	SLTPushBack(&plist, 7);
	SLTPushBack(&plist, 8);
	SLTPushBack(&plist, 9);
	SLTPushBack(&plist, 10);
	//SLTPrint(plist);

	SLTPushFront(&plist, 60);
	SLTPushFront(&plist, 70);
	SLTPushFront(&plist, 80);
	SLTPushFront(&plist, 90);
	SLTPushFront(&plist, 100);
	SLTPrint(plist);

	SLTNode* pos = SLTFindval(plist, 6);
	SLTInsert(&plist, pos, 1000);
	SLTInsertAfter(pos, 200);
	SLTPrint(plist);

	SLTErase(&plist, 60);
	SLTErase(&plist, 70);
	SLTPrint(plist);
}


void test2()
{
	SLTNode* plist = NULL;

	SLTPushBack(&plist, 6);
	SLTPushBack(&plist, 7);
	SLTPushBack(&plist, 8);
	SLTPushBack(&plist, 9);
	SLTPushBack(&plist, 10);
	SLTPrint(plist);

	//int x;
	//scanf("%d", &x);
	//SLTNode* pos = SLTFindval(plist, x);
	//if (pos)
	//{
	//	SLTErase(&plist, pos);
	//	pos = NULL;
	//}
	//SLTPrint(plist);
	SLTNode* pos = SLTFindval(plist, 6);
	SLTEraseAfter(pos);
	SLTPrint(plist);
}

int main()
{
	//test1();
	test2();
	return 0;
}