数据结构之单链表(C语言版)

已于 2024-07-17 23:44:15 修改
阅读量1.5k 收藏 28
点赞数 29
分类专栏： 数据结构笔记(C语言版) 文章标签： c语言 数据结构
于 2024-06-09 13:05:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A2885A/article/details/139549577
版权

前言

上期我们讲了顺序表，顺序表的底层是数组，通过realloc函数来对数组进行扩容，但是再realloc扩容的过程中会有后面内存不够用，再另外开辟一块空间并且把原来的数据拷贝会过去并且释放原空间的过程，也有可能会有扩容失败的情况，而且在我们进行插入和删除数据的时候会移动大量的数据，造成程序运行效率低下的问题。

那么有没有其他的数据结构来解决这个问题呢？链表。这一期我们主要来讲一讲单链表。

一. 链表

1. 链表的概念

链表也是线性表的一种，它物理结构上是不连续的，逻辑结构上是连续的。链表是由一个个节点组成的，每一个节点是存储着数据和下一个结点的地址，最后一个节点的地址是NULL。
在这里插入图片描述
就像上图一样。

2. 链表的分类

  • 单向链表
  • 双向链表
  • 循环链表

3.单链表要实现的功能

  • 单链表的插入:头插和尾插
  • 单链表的删除：头删和尾删
  • 单链表的数据查找
  • 在指定位置之前/之后插入数据
  • 删除pos节点/删除pos之后的节点
  • 销毁链表

接下来我们一一实现这些功能

二. 单链表的代码实现

1. 单链表的结构

typedef int SLTDataType;//数据类型方便以后的替换

typedef struct SListNode//定义节点的结构  存储的数据和下一个节点的地址
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

2. 单链表的插入:头插和尾插

2.1单链表的尾插

所谓尾插，就是在链表的末尾插入一个新的节点。我们应该遍历完单链表找到单链表的尾节点，
在这里插入图片描述
然后将尾节点的next指针改为新增的结点的地址，如图所示。
我们要在链表的末尾插入一个新节点就要创建一个新的节点

//新节点的创建
SLTNode* SLTByNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)//申请失败就直接退出
	{
		perror("malloc");
		exit(1);
	}
	newnode->data = x;//申请成功，就将申请成功的结点的data赋值为x,将NULL赋值给next
	newnode->next = NULL;
	return newnode;
}

以上实现了新节点的创建，接下来继续讲解尾插，当链表不为空的时候，我们给函数传递一个指针，然后通过指针修改即可。但是，当链表为空时，我们要在空链表中插入一个新的节点，然后让头指针指向这个新的节点就涉及到了头指针的修改，因此就应该将头指针的地址传给尾插函数，尾插函数中用二级指针接收头指针的地址，然后再对头指针的地址解引用修改头指针。（传址调用修改主调函数的内容）
以下是代码实现：

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);//指向第一个节点的指针的地址不能为空
	//尾插一个新节点也要先创建一个新节点
	SLTNode* newnode = SLTByNode(x);
	//空链表
	if (*pphead == NULL)
	{
		*pphead = newnode;//这里要改变头指针的值要用头指针的地址因此要传二级指针
	}
	else//先找到尾，传过来头指针
	{
		SLTNode* ptail = *pphead;//用ptail来代替pphead移动，不会改变头指针的值，
		//不会影响后续再次使用头指针
		while (ptail->next)
		{
			ptail = ptail->next;
		}
		ptail->next = newnode;
	}
}

2.2 单链表的打印函数

为了更方便的测试，我们来写一个单链表的打印函数

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

这里定义了一个指针变量pcur来接收头指针，当pcur指向的节点不为空时进入while循环，然后打印这个节点的数据，pcur指向了下一个节点，当pcur指向NULL时，打印NULL。
在这里插入图片描述

2.3 单链表的头插

头插即在单链表的头节点之前再插入一个新的节点，如图所示，我要在第一个节点前插入存放6的新节点，那么应该将新节点的next地址改为头指针指向的地址，头指针指向的地址改为newnode的地址
在这里插入图片描述
看一下代码：

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	 assert(pphead);
	//尾插一个新节点也要先创建一个新节点
	 SLTNode* newnode = SLTByNode(x);
	 newnode->next = *pphead;
	 *pphead = newnode;
}

这个代码对于空链表适用吗？画图分析一下
在这里插入图片描述
对于空链表来说，头指针（*pphead）是NULL，在插入新节点之后，新节点指向的下一个结点的地址是NULL，newnode->next = *pphead（NULL），因此这段代码对于空链表是适用的。

3. 单链表的删除：头删和尾删

3.1 单链表的尾删

在这里插入图片描述
根据图示，我们分析一下，要删除最后一个节点，我们不仅要将最后一个节点申请的内存空间释放，还要将尾节点之前的节点的next指针置为NULL。

//尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead && *pphead);//断言指向头节点的指针的地址是否为空
	//并且断言指向头节点的指针是否为空（链表是否为空）
	//找尾节点和尾节点的前一个节点
	SLTNode* ptail = *pphead;//尾节点
	SLTNode* prev = *pphead;//尾节点的前一个结点
	while (ptail->next)//ptail指向的内容的next指针不为空
	{
		prev = ptail;
		ptail = ptail->next;//ptail后移
	}
	prev->next = NULL;
	free(ptail);
	ptail = NULL;
}

对于上面的代码，当链表只有一个节点时，是有bug的
在这里插入图片描述
我将ptail和prev指向的next指针置为NULL，那么整个链表就为空链表了，因此必须将头节点释放，再将头指针置为NULL，修改后的代码如下：

void SLTPopBack(SLTNode** pphead)
{
	assert(pphead && *pphead);//断言指向头节点的指针的地址是否为空
	//并且断言指向头节点的指针是否为空（链表是否为空）
	if ((*pphead)->next == NULL)//头指针指向的节点的next指针为空，即链表只有一个节点
	{
		free(*pphead);
		*pphead = NULL;
	}
	//找尾节点和尾节点的前一个节点
	else
	{
		SLTNode* ptail = *pphead;//尾节点
		SLTNode* prev = *pphead;//尾节点的前一个结点
		while (ptail->next)//ptail指向的内容的next指针不为空
		{
			prev = ptail;
			ptail = ptail->next;//ptail后移
		}
		prev->next = NULL;
		free(ptail);
		ptail = NULL;
	}
}

3.2 单链表的头删

在这里插入图片描述
将第一个节点删除，头指针指向第二个节点，将第一个节点释放。
代码如下：

void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* phead = *pphead;
	*pphead = (*pphead)->next;
	free(phead);
	phead = NULL;
}

这里一样还是要断言一下指向头节点的指针的地址是否为空以及链表是否为空，这里我用phead来接收指向头节点的指针，然后将头指针指向第二个节点，最后将头节点释放并将头指针置空。对于单节点的链表适不适用呢？
在这里插入图片描述
根据图示分析，头指针指向了NULL，头节点被释放了，因此是适用于单个结点的链表的。

4. 单链表的数据查找

数据的查找需要我们遍历整个链表，找到就返回节点的地址，没有找到就返回NULL。

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

这里的遍历思路和上面打印顺序表的思路一样，当找到该数据时就返回该数据所在结点的地址，没有找到就让节点指向下一个节点接着遍历，当整个链表遍历结束后还是没有找到该元素就返回NULL，表示没找到。

5. 在指定位置插入数据

5.1 在指定位置之前插入数据

在这里插入图片描述
根据图示分析，我们应该找到pos前面的节点，并使它的next指针指向新插入的节点，新插入的节点的next指针指向pos这个节点。但是当pos是头指针的时候如下图：
在这里插入图片描述
这种情况就相当于对链表进行头插，直接调用上面写的头插代码即可。

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);//pos不能为空
	//创建新的节点
	SLTNode* newnode = SLTByNode(x);
	if (*pphead == pos)
	{
		SLTPushFront(pphead, x);//头插调用头插函数
	}
	else
	{
		//找到pos节点以及前面的节点
		SLTNode* prev = *pphead;
		while (prev->next != pos)//prev节点的next指针不是指向pos时进入循环
			//当循环条件不成立时，prev也就来到了pos的前一个结点
		{
			prev = prev->next;
		}
		prev->next = newnode;
		newnode->next = pos;
	}
}

5.2. 在指定位置之后插入数据

在这里插入图片描述

实现这个函数，我们只需要pos一个指针即可，因为通过pos->next就可以找到pos的下一个节点。

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTByNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

这里我们考虑当pos是尾节点（即pos->next==NULL)时
在这里插入图片描述
根据分析代码适用。

6. 删除pos节点/删除pos之后的节点

6.1 删除pos节点

在这里插入图片描述
这里，将pos节点删除后，pos的前一个节点指向了pos的后一个节点。当pos是头结点时，就相当于是进行头删，直接调用头删代码即可。

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

6.2 删除pos之后的节点

在这里插入图片描述
这里我要将pos后面的节点删掉，要让pos的next节点指向下下一个节点，即pos->next=pos->next->next；然后将pos的next节点释放，但是要注意，如果直接将pos的next节点释放，其实是将pos的下下一个节点释放了，因此要创建一个变量(next)来存储下下一个节点的地址，然后再进行释放。代码如下：

void SLTEraseNext(SLTNode* pos)
{
	assert(pos && pos->next);//pos不能为空并且pos的next节点不能为空
	//即保证pos不能是尾节点
	SLTNode* next = pos->next->next;
	free(pos->next);
	pos->next = next;
}

还要注意，这里的pos节点不能是尾节点。

7. 链表的销毁

链表的内存空间也是动态内存申请得来的，因此在不需要再使用的时候要把申请来的内存空间还给操作系统。链表是由一个一个的节点组成的，因此也要一个一个节点的销毁。在销毁节点时，我们不能直接将节点释放，需要保存下一个节点的地址。
在这里插入图片描述

void SLTDestroy(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;//保存下一节点的地址
		free(pcur);//释放当前节点
		pcur = next;//pcur后移
	}
	*pphead = NULL;//当链表被完全销毁后将头指针置为NULL
}

以上就实现好了单链表的所有功能，下面是整体代码呈现

三. 单链表的整体代码呈现

1. SList.h

#pragma once

#include<stdio.h>
#include<assert.h>
#include<stdlib.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 SLTPopBack(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 SLTEraseNext(SLTNode* pos);
//链表的销毁
void SLTDestroy(SLTNode** pphead);

2. SList.c

#include"SList.h"
//链表的打印
void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}
//新节点的创建
SLTNode* SLTByNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)//申请失败就直接退出
	{
		perror("malloc");
		exit(1);
	}
	newnode->data = x;//申请成功，就将申请成功的结点的data赋值x,next赋值NULL
	newnode->next = NULL;
	return newnode;
}

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);//指向第一个节点的指针的地址不能为空
	//尾插一个新节点也要先创建一个新节点
	SLTNode* newnode = SLTByNode(x);
	//空链表
	if (*pphead == NULL)
	{
		*pphead = newnode;//这里要改变头指针的值要用头指针的地址因此要传二级指针
	}
	else//先找到尾，传过来头指针
	{
		SLTNode* ptail = *pphead;//用ptail来代替pphead移动，不会改变头指针的值，
		//不会影响后续再次使用头指针
		while (ptail->next)
		{
			ptail = ptail->next;
		}
		ptail->next = newnode;
	}
}
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	 assert(pphead);
	//尾插一个新节点也要先创建一个新节点
	 SLTNode* newnode = SLTByNode(x);
	 newnode->next = *pphead;
	 *pphead = newnode;
}
//尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead && *pphead);//断言指向头节点的指针的地址是否为空
	//并且断言指向头节点的指针是否为空（链表是否为空）
	if ((*pphead)->next == NULL)//头指针指向的节点的next指针为空，即链表只有一个节点
	{
		free(*pphead);
		*pphead = NULL;
	}
	//找尾节点和尾节点的前一个节点
	else
	{
		SLTNode* ptail = *pphead;//尾节点
		SLTNode* prev = *pphead;//尾节点的前一个结点
		while (ptail->next)//ptail指向的内容的next指针不为空
		{
			prev = ptail;
			ptail = ptail->next;//ptail后移
		}
		prev->next = NULL;
		free(ptail);
		ptail = NULL;
	}
}
//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* phead = *pphead;
	*pphead = (*pphead)->next;
	free(phead);
	phead = NULL;
}

//数据查找
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 && *pphead);
	assert(pos);//pos不能为空
	//创建新的节点
	SLTNode* newnode = SLTByNode(x);
	if (*pphead == pos)
	{
		SLTPushFront(pphead, x);//头插调用头插函数
	}
	else
	{
		//找到pos节点以及前面的节点
		SLTNode* prev = *pphead;
		while (prev->next != pos)//prev节点的next指针不是指向pos时进入循环，当循环条件不成立时，prev也就来到了
			//pos的前一个结点
		{
			prev = prev->next;
		}
		prev->next = newnode;
		newnode->next = pos;
	}
}
在指定位置之后插入节点
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTByNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}
//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);
	assert(pos);
	if (*pphead == pos)
	{
		//头删
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
//删除pos节点后的节点
//void SLTEraseNext(SLTNode* pos)
//{
//	assert(pos && pos->next);//pos不能为空并且pos的next节点不能为空
//	//即保证pos不能是尾节点
//	SLTNode* Del = pos->next;
//	pos->next = Del->next;
//	free(Del);
//	Del = NULL;
//}
void SLTEraseNext(SLTNode* pos)
{
	assert(pos && pos->next);//pos不能为空并且pos的next节点不能为空
	//即保证pos不能是尾节点
	SLTNode* next = pos->next->next;
	free(pos->next);
	pos->next = next;
}

//链表的销毁
void SLTDestroy(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;//保存下一节点的地址
		free(pcur);//释放当前节点
		pcur = next;//pcur后移
	}
	*pphead = NULL;//当链表被完全销毁后将头指针置为NULL
}

结语

以上就讲完了单链表的内容，希望对大家有所帮助，也欢迎大家批评指正。

跃渊Yuey
关注
  • 29
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 单链表 C语言实现
Baron_wu的博客
03-05 903
单链表 单链表 顺序存储线性表 分配方式 分散存储 集中存储 时间性能 查找O(n) 插入删除O(1) 查找O(1) 插入删除O(n) 空间性能 无需分配空间，元素可以无限扩充 分配空间，元素个数有限 c语言代码实现（单链表） // // main.c // 线性表链式存储结构 // // Created by Kinble Wu on 2020/3/2. /...
【数据结构】【C语言】------ 单链表
m0_63601181的博客
05-14 4194
前言 大家好，我是Abert。 这篇文章和大家分享用C语言实现数据结构中的单链表。 单链表可以看作是“拆分开”的顺序表。在顺序表的基础上，单链表做了一些优化，但同时也丧失了一些顺序表有的功能。 我们一起来学习单链表吧！！！ 文章目录 一、单链表的讲解 二、程序基本框架的搭建与讲解 2.1 文件的创建 2.2 变量的创建 三、各种功能的实现及逻辑关系的讲解 3.1 尾插 3.2 头插 3.3 尾删 ...
数据结构之单链表（c语言附完整代码）
热门推荐
m0_62795460的博客
11-01 1万+
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。声明单链表//数据域 struct LNode * next;//指针域，指向后继结点 } LinkNode;//声明单链表结点类型注意：本文章讨论的单链表是带头结点的单链表。
数据结构——单链表详解（C语言实现）
sinzz的博客
03-08 1281
首先，我们需要知道，单链表内所需要的数据有两种，一种是数据，还有就是下一个节点的指针。所以我们需要定义一个结构体。//重命名单链表的数据 //便于不同数据类型的切换 typedef struct SLTNode {//SLTNode* next//错误 //改写法C语言是不支持的 //struct SLTNode//错误 } SLTNode;
数据结构——单链表（C语言实现）
weixin_57154303的博客
08-23 3866
单链表的基本操作有 初始化，头插，尾插，按位置插，头删，尾删，按位置删，查找，按值删，获取有效值个数，判空，清空，销毁，打印 - 单链表是一种链式存取的数据结构，链表中的数据是以结点来表示的，每个结点的构成：==元素(数据元素的映象)== + ==指针(指示后继元素存储位置)==，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。
数据结构 ——单链表【c语言版】
clear-ninghongkang的博客
11-18 1709
线性表：具有相同特性的数据元素（既同类型数据）的一个有限序列. 注：同一线性表中的元素必定具有相同特性 线性表的特性：1.有穷性 2.一致性 3.序列性 线性表的最本质特征：有唯一的前驱和后继 线性表的链式存储结构称为链表 链式存储：逻辑上相邻的数据元素，物理上不一定相邻 在单链表中，假设每个节点的类型用SLinkList表示，它包括存储元素的数据域（data），其类型用通用类型标识符ElemType表示，还包括存储后继节点位置的指针域（next）。SLinkList类型声明如下 ty..
数据结构与算法（C语言版）之单链表
qq_41743824的博客
03-13 1880
单链表介绍 与线性表在内存中的储存结构不同（线性表在内存中是一块连续的空间），链表的存储结构是组成链表的数据元素在内存中既可以是连续的，也可以是不连续的。链表中的每个元素都应该包含两个信息：一个是储存数据的信息，即数据域；另一个为储存与之相连的元素的位置信息，即指针域。 而单链表指的是链表中的每个节点中只包含一个指针域。整个链表的存取必须从头指针开始，头指针指示链表中的第一个节点的储存位置（头指针不用存放数据）。由于最后一个元素没有其后继元素，因此最后一个元素的指针域应为...
单链表数据结构代码（C语言）
m0_51512094的博客
04-25 2428
利用单链表数据结构实现一组数据的存储，通过简单的交互实现单链表的增删改查。 //ADT 线性表（List） 链式存储结构 LinkList #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType; typedef int Status; //定义单链表 typedef struct Node {
数据结构之单链表（c语言版）
y_k_j_c的博客
09-08 462
关于typedef与结构体此时的LNode *等价于LinkList上下两种效果相同上面解释相当于*LinkList=LNode（LinkList取值是LNode）也就是LinkList=struct LNode *p(LinkList是结构体的指针)不同的对应用于上面位置最好。
单链表C语言版
iwkxi的博客
03-19 1614
文章目录0.前言1.链表的概念及结构2.链表的分类3单链表的实现3.1 Slist.h3.2 Slist.c3.2.1 打印链表3.2.2 动态开辟一个节点3.2.3 尾插3.2.4 头插3.2.5 尾删3.2.7 头删3.2.8 单链表查找3.2.8 单链表插入数据(在pos之前还是之后？）3.2.9 单链表删除pos的数据（pos之前还是之后）3.2.10 删除单链表3.2.11 SList.c完整代码3.3 Test.c4运行结果 0.前言 1.链表的概念及结构 概念：链表是一种物理存储结构上非连
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
数据结构C语言版之单链表的逆置.cpp
10-07
数据结构老师布置的作业，运用课本代码，较为基础经典，适合大学本科在上数据结构这门课的同学参考，简单易懂，关于单链表的逆置问题
C语言 数据结构之单链表基本操作
10-05
单链表的各种操作，适合于初学，也适合于复习 单链表操作介绍 1. 创建头节点 2. 创建有数据节点 3. 判断链表是否为空 4. 遍历链表(有头节点链表) 5. 遍历链表(无头节点链表) 6. 头插、头删、尾插、尾删 7. 按照顺序...
数据结构单链表（C语言）
03-27
通过c语言实现单链表的建立、初始化、尾插法插入结点、头插法插入结点、数据的查找、删除、在指定位置插入结点、在指定位置删除结点、打印输出数据、统计单链表的长度等功能。
数据结构——单链表（C语言版）.zip
11-02
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储...
C语言 int 、unsigned int 区别
qq_19343801的博客
08-13 261
的基本用法和一些潜在的问题。在实际编程中，应该根据变量的实际用途和预期值范围来选择合适的类型。只能存储无符号的整数（即非负数）。在实际开发中，选择使用哪种类型应该基于对程序需求的理解和预期的数值范围。都是基本的数据类型，用于存储整数值。可以存储有符号的整数（即正数和负数），而。变量时，编译器可能会发出警告，因为负数。在这个混合示例中，将一个有符号的。被转换为了一个非常大的正数。，这可能导致未定义的行为。当然，以下是一些使用。此外，在进行比较时，
1. 数据结构——单链表的主要操作(考研专业课学习)
最新发布
m0_68536532的博客
08-14 148
单链表的初始化、求长、按位查找、按值查找、插入节点、删除节点、头插法和尾插法建立单链表，以及其部分时间复杂度的分析。
【数据结构-前缀哈希】力扣1124. 表现良好的最长时间段
sjsjs11的博客
08-14 189
表现良好的时间段”有两种情况，一种是当前的sum能在哈希表中匹配到sum - 1时（如果是匹配sum的话，这个子段是「劳累的天数」等于「不劳累的天数」。这一题前缀+哈希并不是空间最优，最优空间是使用贪心+栈的做法，虽然空间复杂度都是O(n)，但是实际的空间使用可能高于 O(n)，因为当哈希表需要扩展时，会预留更多的空间以减少哈希冲突。所谓「表现良好的时间段」，意味在这段时间内，「劳累的天数」是严格 大于「不劳累的天数」。输入：hours = [9,9,6,0,6,6,9]
排序算法3：归并排序与计数排序
2302_79964175的博客
08-08 624
Hello，小伙伴们，今天我们继续排序算法的学习，大家三连上车不迷路，我们现在开始今天的学习！！！
数据结构循环单链表C语言上机操作
06-13
循环单链表是链表的一种特殊形式，它的特点是链表中的最后一个节点的指针指向第一个节点，形成一个闭合的环。在C语言中，操作循环单链表通常涉及创建、插入、删除和遍历等基本操作。 以下是一些基本操作的C语言实现概览： 1. **创建循环链表**: - 定义节点结构体，包含数据域和指向下一个节点的指针（如果是在头结点的最后一个节点，指针会指向自身）。 - 创建链表时，可以初始化一个头节点，然后递归地添加新节点到链尾。 ```c struct Node { int data; struct Node* next; }; // 创建循环链表 void createCircularList(struct Node** head, int size, ...) { ... } ``` 2. **插入节点**: - 可以在链表的头部、尾部或指定位置插入节点。 - 在头部插入，更新头节点的next；在尾部插入，找到当前尾节点，然后更新其next指向新节点，并将新节点next指向头节点。 ```c void insertNode(struct Node** head, int data, insertionPosition) { struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->data = data; newNode->next = (insertionPosition == 1) ? head : (*(head)->next); // 如果在尾部插入，更新尾节点和头节点的next指针 if (insertionPosition == 0) { (*head)->next = newNode; } } ``` 3. **删除节点**: - 删除某个节点时，需要找到前一个节点，然后更新其next指针跳过要删除的节点。 - 在循环链表中删除特定位置的节点需要特别处理头节点的情况。 ```c void deleteNode(struct Node** head, int position) { if (position == 1) { // 删除头节点 struct Node* temp = head->next; *head = temp; free(head); } else { struct Node* current = *head, *previous = NULL; for (int i = 1; i < position && current != NULL; ++i) { previous = current; current = current->next; } if (current == NULL) return; // 未找到节点 previous->next = current->next; } } ``` 4. **遍历循环链表**: - 使用while循环，每次迭代都更新当前节点指向下一个节点，直到遇到第一个节点。 ```c void printList(struct Node* head) { struct Node* temp = head; do { printf("%d ", temp->data); temp = temp->next; } while (temp != head); } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值