数据结构----单链表

最新推荐文章于 2024-10-16 19:08:56 发布
最新推荐文章于 2024-10-16 19:08:56 发布
阅读量502 收藏 7
点赞数 14
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80253651/article/details/142005490
版权

1.单链表

1.1概念

单链表：是一种数据结构，用于存储线性表中的数据元素，通过一组地址任意的存储单元来存放数据。每个数据元素在链表中以结点的形式存在，每个结点包含两个部分：数据域和指针域。数据域用于存储实际的数据，而指针域存储指向链表中下一个节点的地址。这种结构使得单链表不需要连续的存储空间，数据元素的逻辑顺序通过链表中的指针链接次序实现。

1.2组成 

  • ‌数据域‌：用于存储实际的数据。
  • ‌指针域‌：存储指向链表中下一个节点的地址。
  • ‌头节点‌：链表的第一个节点，通常被称为“头节点”或“首节点”。
  • ‌终端节点‌：链表的最后一个节点，其指针域通常为空（NULL），表明链表的结束。

2.单链表的书写 

我们以单向不带头链表为例进行书写

2.1 单链表的创建

typedef int SListData;
typedef struct SListNote {
	SListData data;//存储的数据类型
	struct SListNote* next;//指向下一个节点的指针
}Note;

 利用结构体指针来牵引下一个节点。

2.2 初始

若不带头一般将头结点初始为NULL;

int main{
Note* list = NULL;
return 0;
}

2.3 开辟空间 

每次存储一个数据，我们需要开辟一块空间进行存储，因为为链式结构，我们可以使用malloc进行空间开辟，利用结构体指针进行连接。

Note* SListBuyData(SListData x) {
	Note* newnode = (Note*)malloc(sizeof(Note));
    //判断是否开辟成功
	if (newnode == NULL) {
		perror("malloc fail!");
		exit(1);
	}
//开辟成功
	newnode->data = x;
	newnode->next = NULL;
//返回开辟成功的结构体指针
	return newnode;
}

2.4插入

2.4.1尾部插入

将数据插入已有单链表数据的尾部

注意：如果不带头的话，第一个数据将直接插入头结点中

我们原本创建的头结点

给新数据申请的空间 

图示如下 

代码如下 

void SListpushback(Note**pphead,SListData x) {
	assert(pphead);
	Note* newnode = SListBuyData(x);
	//判断是否头为空//
	if (*pphead == NULL) {
		*pphead = newnode;
		return;
	}
//不为空，创建新结构体指针保存头部//
	Note* ptail = *pphead;
	//找节点尾部//
	while (ptail->next) {
		ptail = ptail->next;
	}
	ptail->next = newnode;
}

2.4.2头部插入

将数据插入原头结点前面

图示

代码实现 

//头插//
void SListpushfront(Note** pphead, SListData x) {
	assert(pphead);
	Note* newnode = SListBuyData(x);
	newnode->next = *pphead;//将原本的头后移一个节点
	*pphead = newnode;//新数据作为头//
}

2.5尾部删除 

2.5.1尾部删除

删除尾部的数据，使尾部的前一个节点的next指针指向NULL

图示

代码 

void SListpopback(Note** pphead) {
	assert(pphead);
	//链表不为空
	assert(*pphead);
	//链表内容不为空
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}
	Note* ptail = *pphead;
	Note* prev = NULL;//记录最后节点的前一个//
	while (ptail->next) {
		prev = ptail;
		ptail = ptail->next;
	}
	prev->next = NULL;
}

2.5.2头部删除 

将头结点删除，头结点的下一个节点作为头

图示

代码 

//头删//
void SListpopfront(Note** pphead) {
	assert(pphead);
	assert(*pphead);
	//把第二个节点成为头
	//释放原头
	Note*next= (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

2.6 查找 

查找需要查找的元素，遍历一遍现有链表，如存在，则返回其所在地址，不存在返回NULL

代码 如下

//查找
Note* SListFind(Note** pphead, SListData x) {
	assert(pphead);
	assert(*pphead);
//保存头结点
	Note* ptail = *pphead;
	while (ptail) {
		if (ptail->data == x) {
			return ptail;
		}
		ptail = ptail->next;
	}
	return NULL;
}

3. 任意位置 

3.1指定位置插入

1.指定位置之前

首先要调用查找函数返回的地址，然后遍历找到该地址的前一个节点。然后使该位置前节点的next指针指向新来辟的节点，新节点的next指针指向指定位置的节点

函数声明

//指定位置之前插入//
void SListInsert(Note** pphead, Note* pos, SListData x);//pos代表插入位置的地址
//查找//
Note* SListFind(Note** pphead, SListData x);

图示

代码如下 

void SListInsert(Note** pphead, Note* pos, SListData x) {
	assert(pphead);
	assert(pos);
	assert(*pphead);
	Note* newnode = SListBuyData(x);
	if (pos == *pphead) {
		SListpushfront(pphead, x);
		return;
	}
	Note* prev = *pphead;
	while (prev->next!=pos) {
		prev = prev->next;
	}
	prev->next = newnode;
	newnode->next = pos;

}

2.指定位置之后

首先要调用查找函数返回的地址，然后遍历找到该地址。新节点的next指针指向指定位置的next指针节点然后使该位置的next指针指向新来辟的节点。

函数声明 

//指定位置之后//
void SListInsertAfter(Note* pos, SListData x);

//查找//
Note* SListFind(Note** pphead, SListData x);

 图示

代码 

//指定位置之后插入
void SListInsertAfter(Note* pos, SListData x) {
	assert(pos);
	Note* newnode = SListBuyData(x);
	newnode->next = pos->next;
	pos->next = newnode;
 }

3.2指定位置删除 

1.该位置删除

    找到该位置的前一个节点，让其next指针指向该节点的下一个节点，如果为头节点可直接调用头删。

函数声明

//删除指定位置节点
void SListpopInsert(Note** pphead, Note* pos);
//查找//
Note* SListFind(Note** pphead, SListData x);

图示： 

 

代码如下 

//删除指定位置节点
void SListpopInsert(Note** pphead, Note* pos) {
	assert(pphead);
	assert(pos);
	assert(*pphead);
	if (pos == *pphead) {
		SListpopfront(pphead);
		return;
	}
	Note* prut = *pphead;
//找指定位置的前一个节点
	while (prut->next != pos) {
		prut = prut->next;
	}
	prut->next = pos->next;
}

2.指定位置之后 

找到该位置，使该位置的next指针指向该位置的下下个节点。

图示：

代码 

//删除指定位置之后//
void SListpopInsertAfter(Note* pos) {
	assert(pos);
	assert(pos->next);
	Note* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

4.打印 

 将单链表中存储的数据打印出来

代码：

//打印//
void SListPrint(Note* pphead) {
	assert(pphead);
	Note* pcur = pphead;
	while (pcur) {
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

5.销毁

将创建的链表空间进行销毁，将内存给释放出来，如果释放会导致内存泄漏，导致程序崩溃。

代码

void SListDestroy(Note** pphead) {
	assert(pphead);
	assert(*pphead);
	Note* pcur = *pphead;
	while (pcur) {
//将下一个节点保存，释放当前节点
		Note* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

6. 总代码

头文件

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int SListData;
typedef struct SListNote {
	SListData data;
	struct SListNote* next;
}Note;
//尾插//
void SListpushback(Note**pphead,SListData x);
//头插//
void SListpushfront(Note**pphead,SListData x);
//尾删//
void SListpopback(Note** pphead);
//头删//
void SListpopfront(Note** pphead);
//查找//
Note* SListFind(Note** pphead, SListData x);
//指定位置之前插入//
void SListInsert(Note** pphead, Note* pos, SListData x);
//指定位置之后//
void SListInsertAfter(Note* pos, SListData x);
//删除指定位置节点
void SListpopInsert(Note** pphead, Note* pos);
//删除指定位置之后//
void SListpopInsertAfter(Note* pos);
//销毁//
void SListDestroy(Note** pphead);
//打印//
void SListPrint(Note* pphead);

源文件 

#include"SListData.h"
//开辟空间//
Note* SListBuyData(SListData x) {
	Note* newnode = (Note*)malloc(sizeof(Note));
	if (newnode == NULL) {
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
//尾插//
void SListpushback(Note**pphead,SListData x) {
	assert(pphead);
	Note* newnode = SListBuyData(x);
	//判断是否头为空//
	if (*pphead == NULL) {
		*pphead = newnode;
		return;
	}
//不为空，创建新结构体指针保存头部//
	Note* ptail = *pphead;
	//找节点尾部//
	while (ptail->next) {
		ptail = ptail->next;
	}
	ptail->next = newnode;
}
//头插//
void SListpushfront(Note** pphead, SListData x) {
	assert(pphead);
	Note* newnode = SListBuyData(x);
	newnode->next = *pphead;//将原本的头后移一个节点
	*pphead = newnode;//新数据作为头//
}
//尾删//
void SListpopback(Note** pphead) {
	assert(pphead);
	//链表不为空
	assert(*pphead);
	//链表内容不为空
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}
	Note* ptail = *pphead;
	Note* prev = NULL;//记录最后节点的前一个//
	while (ptail->next) {
		prev = ptail;
		ptail = ptail->next;
	}
	prev->next = NULL;
}
//头删//
void SListpopfront(Note** pphead) {
	assert(pphead);
	assert(*pphead);
	//把第二个节点成为头
	//释放原头
	Note*next= (*pphead)->next;
	free(*pphead);
	*pphead = next;
}
//查找
Note* SListFind(Note** pphead, SListData x) {
	assert(pphead);
	assert(*pphead);
	Note* ptail = *pphead;
	while (ptail) {
		if (ptail->data == x) {
			return ptail;
		}
		ptail = ptail->next;
	}
	return NULL;
}
//指定位置之前插入
void SListInsert(Note** pphead, Note* pos, SListData x) {
	assert(pphead);
	assert(pos);
	assert(*pphead);
	Note* newnode = SListBuyData(x);
	if (pos == *pphead) {
		SListpushfront(pphead, x);
		return;
	}
	Note* prev = *pphead;
	while (prev->next!=pos) {
		prev = prev->next;
	}
	prev->next = newnode;
	newnode->next = pos;

}
//指定位置之后插入
void SListInsertAfter(Note* pos, SListData x) {
	assert(pos);
	Note* newnode = SListBuyData(x);
	newnode->next = pos->next;
	pos->next = newnode;
 }
//删除指定位置节点
void SListpopInsert(Note** pphead, Note* pos) {
	assert(pphead);
	assert(pos);
	assert(*pphead);
	if (pos == *pphead) {
		SListpopfront(pphead);
		return;
	}
	Note* prut = *pphead;
	while (prut->next != pos) {
		prut = prut->next;
	}
	prut->next = pos->next;
}
//删除指定位置之后//
void SListpopInsertAfter(Note* pos) {
	assert(pos);
	assert(pos->next);
	Note* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}
//销毁//
void SListDestroy(Note** pphead) {
	assert(pphead);
	assert(*pphead);
	Note* pcur = *pphead;
	while (pcur) {
		Note* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}
//打印//
void SListPrint(Note* pphead) {
	assert(pphead);
	Note* pcur = pphead;
	while (pcur) {
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

测试文件 

#include"SListData.h"
int main() {
	Note* list = NULL;
	//尾插//
	SListpushback(&list, 1);
	SListpushback(&list, 2);
	SListpushback(&list, 3);
	SListpushback(&list, 4);
	SListPrint(list);
	//头插//
	SListpushfront(&list, 2);
	SListPrint(list);
	//尾删//
	SListpopback(&list);
	SListPrint(list);
	//头删//
	SListpopfront(&list);
	SListPrint(list);
	Note* FindRet = SListFind(&list, 1);
	/*if (FindRet) {
		printf("找到啦！");
	}
	else {
		printf("没找到！");
	}*/
	/*SListInsert(&list, FindRet, 100);
	SListPrint(list);*/
	SListInsertAfter(FindRet, 5);
	SListPrint(list);
	SListpopInsert(&list, FindRet);
	SListPrint(list);
	SListDestroy(&list);
}

7.总结 

单链表的优缺点

  • ‌优点‌：不要求大片连续空间，改变容量方便。

  • ‌缺点‌：不可随机存取，要耗费一定空间存放指针。

销声匿迹001
关注
数据结构-单链表的操作
06-28
数据结构-单链表的操作
数据结构-C语言实现单链表-数据结构学习
05-26
C语言实现的数据结构中的单链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对链表边界的判定 实现了以下功能： 创建单链表 向顺序表中插入元素(头插法，尾插...
数据结构--单链表操作实验报告
04-12
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序单链表，将该链表输出显示。 2.再从键盘输入顺序任意的5个整数，按有序插入的要求生成第二个有序单链表，将该链表输出显示。 3.将这两个有序单链表...
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（1）掌握线性表的顺序存储结构； （2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； ...
数据结构学习笔记-单链表
02-16
在所有数据结构中，链表是一种基础且重要的类型，尤其是单链表。本学习笔记将聚焦于单链表的概念、操作以及在VS2022环境下如何实现。 单链表是一种线性数据结构，其元素（节点）不是在内存中连续存储的，而是通过...
数据结构与算法：高级数据结构与实际应用
weidl001的博客
10-16 737
本章介绍了跳表、Trie树、B树与 B+树等高级数据结构，以及它们在实际系统中的应用。这些数据结构在提高查找效率、优化存储和加速特定任务方面具有不可替代的作用。通过深入理解这些结构及其特性，我们能够选择最合适的数据结构来应对复杂的实际问题。在下一章中，我们将深入讨论并查集与线段树的高级应用，以及它们在图论和范围查询中的重要作用。
数据结构常考基础代码题-顺序表有序插入
qq_52291558的博客
10-16 377
根据题目中的“顺序表递增有序”，我们需要定义一个顺序表结构体，用于存储元素和顺序表的相关信息。
《C++中栈的实现：探索高效数据结构》
xy520521的博客
10-13 523
当向栈中添加元素时，创建一个新的节点，将其数据设置为要添加的元素，并将其指向下一个节点设置为当前的栈顶节点，然后将栈顶指针指向新节点。当从栈中删除元素时，将栈顶指针指向当前栈顶节点的下一个节点，并释放原来栈顶节点的内存。首先，数组的大小是固定的，一旦栈的大小超过了数组的容量，就需要进行复杂的扩容操作。其次，数组实现的栈在内存中的分配是连续的，可能会导致内存碎片的问题。此外，链表实现的栈在内存中的分配是不连续的，不会产生内存碎片。但是，链表实现的栈在进行插入和删除操作时需要进行指针的操作，相对来说比较复杂。
数据结构编程实践20讲(Python版)—09B树
AnFany
10-12 1142
数据结构编程实践20讲(Python版)—09B树
数据结构（排序）
m0_74859128的博客
10-10 782
一、定义排序是将一组数据元素按照某个关键字的值递增或递减的次序重新排列的过程。这个关键字是数据元素中的某个数据项，通过比较关键字的大小来确定数据元素的先后顺序。二、目的便于查找例如在一个有序数组中查找某个元素，使用二分查找等算法效率更高。如果数据是无序的，可能只能进行顺序查找，时间复杂度较高。数据呈现的有序性在很多应用场景中，如成绩排名、文件按时间顺序排列等，需要数据以有序的形式展示，以便于人们理解和分析。三、分类内部排序和外部排序内部排序指待排序的数据元素全部存放在计算机内存中的排序算法。
数据结构常考基础代码题-数组倒置
最新发布
qq_52291558的博客
10-16 327
根据题目中的“将数组中的元素顺序反转”，我们需要实现一个函数Reverse，用于反转数组中从start到end的元素。// 函数用于反转数组A中从start到end的元素int temp;// 使用while循环进行元素交换，直到start和end相遇或交叉// 保存A[start]的值// 将A[end]的值赋给A[start]// 将temp（原A[start]的值）赋给A[end]start++;// 移动start指针end--;// 移动end指针。
嵌入式数据结构中树与查找方法实现
嵌入式技术开发
10-13 179
Tree）是nn≥0）个节点的有限集合T，它满足两个条件有且仅有一个特定的称为根Root的节点其余的节点可以分为mm≥0）个互不相交的有限集合T1T2……Tm，其中每一个集合又是一棵树，并称为其根的子树（Subtree一个节点的子树的个数称为该节点的度数一棵树的度数是指该树中节点的最大度数。度数为零的节点称为树叶或终端节点，度数不为零的节点称为分支节点，除根节点外的分支节点称为内部节点。一个节点的子树之根节点称为该节点的子节点。
【数据结构】顺序表应用---删除偶数
2301_79982543的博客
10-10 354
如果两个偶数是连在一起的，那移动过后第i位依旧是偶数，所以需要i--检查再次检查第i位的情况 ，如图所示。你的任务是创建一个顺序表，输入多个整数存入表中，删除其中的偶数，然后输出表中的所有数据。今天的分享就到这里啦~~希望对您有所帮助！下次再见啦~~ヾ(￣▽￣)Bye~Bye~样例输入： 10 34 23 9 10 10 17 31 32 1 15。采用顺序表存储一批整数，去掉其中所有的偶数。第2行：顺序表中的数据，每个整数用空格隔开。第1行：顺序表中数据个数。第2行：输入n个整数。
常见几大排序算法
2301_79562326的博客
10-13 979
O(n²) 的算法：冒泡排序、选择排序、插入排序——这些算法适合小规模数据集。O(n log n) 的算法：归并排序、快速排序、堆排序——适合大规模数据集，其中快速排序通常表现最好，但最坏情况为 O(n²)。
数据结构----链表
m0_74057742的博客
10-13 184
【代码】数据结构----链表。
【Redis原理】数据结构(上)
2301_78320637的博客
10-10 1230
Dict。
数据结构：用栈实现队列（OJ232）
2303_81073778的博客
10-14 200
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（
[数据结构]栈的实现与应用
2301_79450966的博客
10-13 926
栈，作为一种基础且重要的数据结构，在计算机科学领域中有着广泛的应用。它不仅为函数调用提供了必要的支持，还在算法设计和问题解决中发挥着关键作用。本文将对栈的基本概念、实现方式以及函数栈帧进行详细的介绍和分析。
【数据结构】：破译排序算法--数字世界的秩序密码（一）
2301_82347435的博客
10-13 1362
排序算法是计算机科学中非常重要的一部分，它们的主要目的是将一个数据集合（如数组或列表）中的元素按照一定的顺序（如升序或降序）重新排列。排序算法的应用非常广泛，从简单的数据整理到复杂的数据库管理系统，都离不开排序算法的支持。定义：排序算法是指将一组数据按照特定的顺序进行排列的算法。目的：使得数据在逻辑上或物理上按照一定的顺序进行排列，以便于后续的数据查找、处理和分析等操作。本篇文章主要讲述了插入排序，希尔排序，选择排序和堆排序，剩下的冒泡排序，快速排序，归并排序和计数排序我将会放在下一篇文章中。！！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值