数据结构---链表(Linked List)---单链表（Singly Linked List）

已于 2024-09-08 17:40:23 修改
阅读量990 收藏 11
点赞数 14
文章标签： 数据结构
于 2024-09-08 15:12:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MIKASA31/article/details/141999355
版权

简介

特点：节点由数据和指向下一个节点的指针组成，内存不连续。

时间复杂度：访问元素为O(n)，插入/删除元素为O(1)（只需更改指针）。

应用场景：频繁插入和删除操作，数据动态变化。

实现单链表

创建SList.h,   SList.c,   test.c三个文件

初始化单链表

数据data+指向下一结点指针*next

//定义链表（结点）的结构

typedef int SLTDataType;

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

新增结点

​
//申请新结点
SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	node->data = x;
	node->next = NULL;

	return node;
}

​

创建单链表

1.申请空间

2.node->data=x;

3.node->next=node(+1)

#include"SList.h"
//创建一个链表，并打印链表

void createSList()
{
	//链表是由一个一个的结点组成
	SLTNode* node1 = (SLTNode*)malloc(sizeof(SLTNode));
	node1->data = 1;

	SLTNode* node2 = (SLTNode*)malloc(sizeof(SLTNode));
	node2->data = 2;

	SLTNode* node3 = (SLTNode*)malloc(sizeof(SLTNode));
	node3->data = 3;

	SLTNode* node4 = (SLTNode*)malloc(sizeof(SLTNode));
	node4->data = 4;

	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = NULL;

	//第一个结点的地址作为参数传递过去
	SLTNode* plist = node1;
	SLTPrint(plist);
}

void SListTest01()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);//1->2->3->4->NULL

	//SLTPushBack(NULL, 3);
	//SLTPushFront(&plist, 1);
	//SLTPushFront(&plist, 2);
	//SLTPushFront(&plist, 3);
	//SLTPushFront(&plist, 4);
	//SLTPrint(plist); //4->3->2->1->NULL
	
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);

	//SLTNode* find = SLTFind(plist, 4);
	//if (find == NULL)
	//{
	//	printf("未找到！\n");
	//}
	//else
	//{
	//	printf("找到了！\n");
	//}
	//SLTInsert(&plist, find, 11);//4->3->2->11->1->NULL
	//SLTInsertAfter(find, 11);
	//SLTPrint(plist);1->11->2->3->4->NULL

	//SLTErase(&plist, find);// 1->2->3->NULL
	//SLTEraseAfter(find);

	//SLTPrint(plist);
	SListDestroy(&plist);
	SLTPrint(plist);
}

 struct ListNode {
     int val;
     struct ListNode *next;
};
 
typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val) {
	//创建新链表
	ListNode* newHead, * newTail;
	newHead = newTail = NULL;
	//遍历原链表
	ListNode* pcur = head;
	while (pcur)
	{
		//找值不为val的节点，往新链表中进行尾插
		if (pcur->val != val)
		{
			//链表为空
			if (newHead == NULL)
			{
				newHead = newTail = pcur;
			}
			else
			{
				//链表不为空
				newTail->next = pcur;
				newTail = newTail->next;
			}
		}
		pcur = pcur->next;
	}
	return newHead;
}

void test01()
{
	ListNode* n1 = (ListNode*)malloc(sizeof(ListNode));
	n1->val = 1;
	ListNode* n2 = (ListNode*)malloc(sizeof(ListNode));
	n2->val = 6;
	ListNode* n3 = (ListNode*)malloc(sizeof(ListNode));
	n3->val = 1;
	ListNode* n4 = (ListNode*)malloc(sizeof(ListNode));
	n4->val = 6;

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = NULL;
	//1->6->1->6

	ListNode* plist = n1;
	//构造一个链表
	removeElements(plist, 6);
	//1->1
}

int main()
{
	//createSList();
	//SListTest01();
	test01();
	return 0;
}

打印单链表

用指针从头到尾遍历打印,pcur->next=NULL时停止

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

插入

         尾插

创建pcur指针从头遍历单链表到尾,若pcur->next=NULL,则为尾结点,然后插入,pcur ->   next=newnode

void SLTPushBack(SLTNode* phead, SLTDataType x);//尾插
//尾插
void SLTPushBack(SLTNode* phead, SLTDataType x)
{
	//申请新节点
	SLTNode* newnode = SLTBuyNode(x);
	if (phead == NULL)
	{
		phead = newnode;
	}
	else
	{
		//找尾结点
		SLTNode* pcur = phead;
		while (pcur->next)
		{
			pcur = pcur->next;
		}
		//pcur  newnode
		pcur->next = newnode;
	}
}

头插

    回顾  指针
  • 一级指针：用于访问或修改指针指向的变量的值。
  • void modifyValue(int *p) {
    *p = 20;  // 改变一级指针p指向的变量的值
}

int main() {
    int a = 10;
    modifyValue(&a);  // 传递变量a的地址
    printf("%d", a);  // 输出20，表示a的值被修改
    return 0;
}

  • 二级指针：用于修改一级指针的指向，让它指向不同的内存位置。
  • void modifyPointer(int **pp) {
    static int b = 30;
    *pp = &b;  // 改变一级指针pp指向b的地址
}

int main() {
    int a = 10;
    int *p = &a;  // p指向a
    modifyPointer(&p);  // 传递p的地址
    printf("%d", *p);  // 输出30，表示p现在指向了b
    return 0;
}

 一级指针指向某个变量的内存地址，允许通过指针访问或修改这个变量的值。

二级指针是指向一级指针的指针。通过二级指针，你可以修改一级指针本身的值，也就是让一级指针指向不同的内存地址。

想要改变头结点指针的指向,传二级指针,一级指针改变数据的值,二级指针改变一级指针的指向

void SLTPushFront(SLTNode** pphead, SLTDataType x);

 *pphead前插入newnode

*pphead指向newnode

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = SLTBuyNode(x);
	//newnode *pphead
	newnode->next = *pphead;
	*pphead = newnode;
}

在指定位置之前插⼊数据

在头前插入,会改变头指针,传二级指针

//在指定位置之前插⼊数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

 设置prev指针从头遍历,在pos之前插入

也就是说newnode->next=pos  , prev->next=newnode

              newnode

prev------------------------->pos            prev---------------->newnode------------------>pos

           prev->next                                       prev->next                     new->next

//在指定位置之前插⼊数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);

	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* newnode = SLTBuyNode(x);
		//找prev :pos的前一个结点
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//prev newnode --> pos
		newnode->next = pos;
		prev->next = newnode;
	}
}

在指定位置之后插⼊数据

void SLTInsertAfter(SLTNode* pos, SLTDataType x);
//在指定位置之后插⼊数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	//pos newnode --> pos->next
	newnode->next = pos->next;
	pos->next = newnode;
}

删除

        尾删

void SLTPopBack(SLTNode** pphead);
//尾删
void SLTPopBack(SLTNode** pphead)
{
	//链表为空：不可以删除
	assert(pphead && *pphead);
	//处理只有一个结点的情况:要删除的就是头结点	
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//找 prev ptail
		SLTNode* ptail = *pphead;
		SLTNode* prev = NULL;
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		prev->next = NULL;
		free(ptail);
		ptail = NULL;
	}

        头删

void SLTPopFront(SLTNode** pphead);
//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);

	SLTNode* next = (*pphead)->next;
	//*pphead --> next
	free(*pphead);
	*pphead = next;
}

删除指定的pos结点

void SLTErase(SLTNode * *pphead, SLTNode * pos);

//删除pos结点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);
	assert(pos);

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

删除pos之后的结点

void SLTEraseAfter(SLTNode * pos);
//删除pos之后的结点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);

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

查找

SLTNode* SLTFind(SLTNode* phead, SLTDataType x);
//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	assert(phead);
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}

销毁单链表

//销毁链表
void SListDestroy(SLTNode * *pphead);
//销毁链表
void SListDestroy(SLTNode** pphead)
{
	assert(pphead && *pphead);

	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

MIKASA_ZERO
关注
go-singly-linked-list:Go 中的单向链表
07-11
在编程领域，数据结构是构建高效算法的基础，而链表作为一种基本的数据结构，被广泛应用于各种场景。本文将深入探讨Go语言中的单向链表，包括其定义、结构、操作以及实际应用。 单向链表，顾名思义，是一种线性数据...
陈越、何钦铭-数据结构作业6：Reversing Linked List链表翻转
03-26
Given a constant K and a singly linked list L, you are supposed to reverse the links of every K elements on L. For example, given L being 1→2→3→4→5→6, if K=3, then you must output 3→2→1→6→5→...
数据结构:单向链表(Linked List)
weixin_30419799的博客
08-10 331
本文来源： Linked List | Set 1 (Introduction) Linked List | Set 2 (Inserting a node) Linked List | Set 3 (Deleting a node) Find Length of a Linked List (Iterative and Recursive)（todo:在结构中保持节点数信息...
【数据结构】单链表--List
热门推荐
Z1tai的博客
05-12 1万+
概念：链表是一种物理存储结构上非连续非顺序的存储结构，但链表在逻辑上是连续的，顺序的，而数据元素的逻辑顺序是通过链表中的指针连接次序实现的。
数据结构-线性表-了解循环链表
yandadzf的博客
08-18 300
单循环链表适合需要单向遍历的场景，结构简单，内存占用较少。双循环链表则提供了双向遍历的能力，适合需要频繁前后移动的场景，但内存占用相对较高。数据结构-线性表-单链表。
手撕数据结构---------顺序表和链表
2301_80863610的博客
07-25 4555
定义之前已经知道数组大小的数组定义之前不知道数组大小的数组---动态内存管理int *arr---定义一个指针sequence:流畅的 List:表那么对顺序表的定义1.已知顺序表的大小:静态顺序表：int size;//顺序表中有效数据的个数如果我们一开始不知道顺序表的大小的话，在后面代码生成的时候申请了大小，这就是动态顺序表对于顺序表，我们不一定是整型数组，可能是字符数组，那么这个时候我们就要用到typedef了，将数据类型重命名，因为这样会很方便的，如果一个个改的话就很麻烦。
2-链表-21-设计链表-LeetCode707
weixin_43873121的博客
05-28 1113
算法：链表-设计链表-LeetCode707
C语言常用数据结构-单链表的详解与实现
qq_42037383的博客
06-25 850
int data;// 节点数据域// 指向下一个节点的指针} Node;每个节点包含一个整型数据data和一个指向下一个节点的指针next。最后一个节点的next指针通常指向NULL，表示链表的结束。int data;} Node;Node* head;// 头指针，指向头结点int size;// 链表大小（节点数量）// 创建链表// 销毁链表// 头部插入节点// 尾部插入节点// 指定位置插入节点// 删除头部节点// 删除尾部节点// 删除指定位置节点。
数据结构-------链表（递归）操作
weixin_51578598的博客
09-23 3110
数据结构中的链表估计很多人会觉得简单，我也是怕记不住所以就尝试整理一下笔记吧 1.创建链表（初始化） struct ListNode { //链表结点类 int data; //数据域，当然int类型可以改为自定义类型T等等 ListNode * next; //主要讨论单链表 }; typedef ListNod
【数据结构 - 链表3】合并单链表
weixin_60125979的博客
04-15 1244
1.思路 和合并两个数组的思路差不多 只要有一个为空，立马跳出循环去处理第二个 2.易错点 一进来，两个头结点为空，返回null结束函数，后面代码不执行 考虑没进入循环的情况 - > 一开始就有1个头结点为空 -> 根本就没有进入循环 处理正常跳出 -> 有一个为null / 有两个为null -> 必须是2个if，不能是if-else 若一开始就有一个人为空，循环没进去，则newhead和cur都为空，cur不能.next 3.代码 /** ...
2-链表-31-反转链表-LeetCode206
weixin_43873121的博客
05-28 968
算法：链表-反转链表-LeetCode206
数据结构-链表-第二天
qq_33867768的博客
08-21 1811
链表（linked list）是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，通过它可以从当前节点访问到下一个节点。int val;// 数据域，存储节点的值// 指针域，指向下一个节点SinglyListNode(int x) : val(x), next(NULL) {} // 构造函数，初始化节点单链表的定义和构造函数的设计是为了方便创建和操作链表。
基于Java实现reorder-list(链表重排序)【100012113】
05-15
Given a singly linked list$ L: L_0→L_1→…→L{n-1}→L_n$, reorder it to: $L_0→L_n →L_1→L_{n-1}→L_2→L_{n-2}→…$ You must do this in-place without altering the nodes' values. For example, Given...
Quick-search-singly-linked.zip_Quick
09-23
单向链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。在链表中进行搜索操作时，通常需要从头节点开始，按顺序逐个检查直到找到目标节点或者遍历完整个链表。然而，如果链表...
数据结构：树的定义及其性质
pranaa的博客
09-24 708
树是一种重要的非线性数据结构，树作为一种逻辑结构，同时也是一种分层结构。具有以下两个特点：1.树的根结点没有前驱，除根结点意外的节点只有一个前驱2.树中所有结点都可以有0个或多个后继树结构在多个领域都有广泛应用，如表示文件系统的结构、数据库的索引、层次数据关系等。具体来说，树是由n（n≥0）个节点组成的有限集合。当n=0时，称为空树；当n>0时，为非空树。
数据结构之——栈
m0_71974552的博客
09-24 1186
栈：数据结构的基石
matlab的‌基础语法和数据类型
weixin_45710581的博客
09-25 582
MATLAB中的函数用于封装可重复使用的代码块。
数据结构：详解搜索二叉树
最新发布
Another_Shi的博客
09-28 777
搜索二叉树的结构跟二叉树差不多——两个指针来指向左右子树，一个对象来存放数据。
数据结构：树、森林
pranaa的博客
09-24 1005
此外，访问子节点和父节点的索引计算也会变得复杂，因为需要额外的数据结构（如指针或索引数组）来跟踪每个节点的子节点位置。在转换为二叉树时，我们可以将节点的第一个孩子视为二叉树的左孩子，将节点的下一个兄弟视为二叉树的右孩子。这种转换在处理树形结构的问题时非常有用，因为二叉树具有一些特殊的性质（如左子树和右子树的明确区分）和高效的算法（如二叉搜索树、堆等）。二叉树和树的顺序存储结构在本质上是相似的，但由于二叉树结构的特殊性，它在顺序存储中更加高效和直接。二叉树转换为树的过程是上述转换的逆过程。
definition for singly-linked list.
04-10
单向链表是一种数据结构，其中每个节点都包括一个指向下一个节点的指针，以便在遍历时可以沿着链表移动。它可以用来保存一系列元素，每个元素都包括一个值和指向下一个元素的指针。在单向链表中，可以从头节点开始...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值