链表（数据结构）

已于 2023-05-08 17:16:09 修改
阅读量1.3k 收藏 8
点赞数 14
文章标签： 数据结构 java
于 2023-05-04 16:02:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dd811923461/article/details/130201598
版权

目录

链表

链表的分类

1、单向或者双向

2、带头或者不带头

3、循环或者非循环

总结：

单链表

创建链式结构

创建新节点

尾插

尾删

头插

头删

查找节点

在pos位置后插入

删除pos位置后的节点

销毁

总代码

链表

概念：

链表是一种物理结构上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表结构中的指针链接起来的！前一个元素中存放着后一个元素的地址！

结构：

结构中存放着链表下一个元素的地址！用一个指针来存储！

一般情况下一个链表结构中存放的是元素的值以及下一个位置的指针！或者多个链接元素的指针！

链表的分类

1、单向或者双向

单向链表：

链表结构中只有一个指针，该指针是存放的是下一个元素的地址的指针变量！

看图理解：

双向链表：

结构中有两个指针，分别记录它的前一个元素和后一个元素的地址！

看图理解：

2、带头或者不带头

1、带哨兵位的头节点的单向链表：

2、带哨兵位头节点的双向链表：

3、循环或者非循环

1、单向循环链表

2、双向循环链表 

3、单向带头循环链表 

4、带头双向循环链表 

总结：

1、图形

以上图都是链表的逻辑结构，物理上也就是底层并非是这样指向的，而是每个指针里面都存储它所对应节点的地址！

2、种类

链表类型总共有八种，分别是按照以上的三大类来组合：

第一类：单向或双向

第二类：带头或不带头

第三类：循环或不循环

八种链表：

1、单向链表

2、双向链表

3、单向带头链表

4、双向带头链表

5、单向循环链表

6、双向循环链表

7、单向带头循环链表

8、双向带头循环链表

本篇博主只带大家写一种链表：单链表，因为只要会了一种链表，其它链表都是大同小异的！

单链表

概念：

单链表中的节点，后一个节点中存的是前一个节点的地址，最后一个节点的中的地址为空！

逻辑结构：

物理结构：

 

总结：

1、链式结构在逻辑上是连续的，但在物理结构上不一定连续。

2、现实中的节点一般是从堆上申请出来的

3、从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续！

下面我们用代码实现单链表！

创建链式结构

思路：

我们用一个结构体来封装链表节点的值以及该类型结构的地址，值是链表节点中要保存的值，结构体的的地址是用来存储前一个结构节点的地址，若该节点是最后一个则地址里面的值是NULL

代码：

//用typedef重命名，后续可以继续使用
typedef int SLDateType;

//创建链表结构
typedef struct SListNode
{
	SLDateType val;//节点值
	struct SListNode* next;//下一个节点的位置

}SLNode;

创建新节点

思路：

创建新节点，要将链表链起来，我们就得要创造新的节点进行链接，才能形成链接功能。该功能可供我们用于头插，尾插，等功能中！

代码：

//创建新节点
SLNode* CreateNode(SLDateType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	//判断是否开辟成功
	if (newnode == NULL)
	{
		perror("malloc fali:");
		return NULL;
	}
	//开始赋值
	newnode->val = x;
	newnode->next = NULL;

	//返回
	return newnode;
}

尾插

思路：

单链表进行尾插，先要找到单链表的尾节点，随后在创建一个要插入的节点，让找到的尾节点的指针指向要插入的新节点，也就是尾节点中的结构体指针变量中保存要插入的新节点的地址！

代码：

//尾插
void SListPushBank(SLNode** pphead, SLDateType x)
{
	//创建新节点
	SLNode* newnode = CreateNode(x);

	//判断是否是空链表，空链表直接进行尾插
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾
		SLNode* cur = *pphead;
		while (cur->next != NULL)
		{
			cur = cur->next;
		}
		
		//进行链接
		cur->next = newnode;
	}
}

尾删

思路：

单链表进行尾删，先进行循环找尾节点，同时用一个指针来记录尾节点的前一个节点的地址。找到尾节点之后，将尾节点的前一个节点中的指针置为NULL。再将尾节点的空间进行free释放！最后将尾节点结构中的指针置为NULL

代码：

//尾删
void SListPopBank(SLNode** pphead)
{
	//如果是NULL链表就不能再删
	assert(*pphead);

	//判断一个的情况
	if ((*pphead)->next == NULL)
	{
		free((*pphead)->next);
		*pphead= NULL;
	}
	else
	{
		//找尾
		SLNode* cur = *pphead;
		SLNode* tail = NULL;
		while (cur->next != NULL)
		{
			tail = cur;
			cur = cur->next;
		}

		//释放节点
		free(cur);
		cur = NULL;

		//将前一个节点置为NULL
		tail->next = NULL;
	}

}

头插

思路：

单链表头插，就是创建一个新节点，让这个新节点结构中的指针指向头节点，再让新节点成为头节点即可！

代码：

//头插
void SListPushFront(SLNode** pphead, SLDateType x)
{
	SLNode* newnode = CreateNode(x);

	SLNode* tail = *pphead;
	*pphead = newnode;
	newnode->next = tail;

}

头删

思路：

单链表头删，用一个指针指向头后面的节点，随后将头节点空间释放，再让后面的节点成为头即可！

代码：

//头删
void SListPopFront(SLNode** pphead)
{
	//如果是空链表就不进行删除
	assert(*pphead);

	SLNode* cur = (*pphead)->next;
	SLNode* tail = *pphead;
	free(tail);
	tail = NULL;
	*pphead = cur;
}

查找节点

思路：

循环遍历链表，找到我们要查找的节点，返回该节点的地址即可！若找不到返回NULL

代码：

//节点查找
SLNode* SListFind(SLNode* phead, SLDateType x)
{
	SLNode* cur = phead;
	while (cur)
	{
		if (cur->val == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

在pos位置后插入

思路：

用一个指针记录pos位置的下一个节点，随后让pos节点结构体的指针指向新插入的节点。再让新插入节点结构的指针指向pos位置的下一个节点完成链接！

代码：
 

// 在pos位置之后插入x
void SListInsertAfter(SLNode* pos, SLDateType x)
{
	//后面插入pos为NULL 不行
	assert(pos);

	SLNode* newnode = CreateNode(x);
	SLNode* cur = pos->next;
	pos->next = newnode;
	newnode->next = cur;
}

删除pos位置后的节点

思路：

用一个指针记录pos位置的下一个节点。再用一个指针记录pos位置的下下个节点，也就是pos位置的下一个节点的下一个节点，随后将pos位置的下一个节点空间释放。让pos位置节点结构中的指针指向pos位置的下下个节点即可！

代码：

// 删除pos位置之后的值
void SListEraseAfter(SLNode* pos)
{
	//pos为NULL 不可删后面的
	assert(pos);
	SLNode* cur = pos->next;

	if (cur == NULL)
	{
		free(cur);
		cur = NULL;
		pos->next = NULL;
	}
	else
	{
		SLNode* tail = cur->next;
		free(cur);
		pos->next = tail;
	}
}

销毁

思路：

循环遍历链表，用一个指针记录销毁节点的后一个节点，一个指针记录销毁节点，让两者都往后走，依次循环进行销毁（释放节点空间）！

代码：

// 销毁
void SListDestroy(SLNode* phead)
{
	SLNode* cur = phead;
	SLNode* tail = cur;
	while (cur)
	{
		tail = cur;
		cur = cur->next;
		free(tail);
	}
	tail = NULL;
	phead = NULL;
}

总代码

#define _CRT_SECURE_NO_WARNINGS 1


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

//用typedef重命名，后续可以继续使用
typedef int SLDateType;

//创建链表结构
typedef struct SListNode
{
	SLDateType val;//节点值
	struct SListNode* next;//下一个节点的位置

}SLNode;


//打印
void SListPrint(SLNode* phead)
{
	SLNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d ->", cur->val);
		cur = cur->next;
	}
	printf("NULL\n");
}

//创建新节点
SLNode* CreateNode(SLDateType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	//判断是否开辟成功
	if (newnode == NULL)
	{
		perror("malloc fali:");
		return NULL;
	}
	//开始赋值
	newnode->val = x;
	newnode->next = NULL;

	//返回
	return newnode;
}

//尾插
void SListPushBank(SLNode** pphead, SLDateType x)
{
	//创建新节点
	SLNode* newnode = CreateNode(x);

	//判断是否是空链表，空链表直接进行尾插
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾
		SLNode* cur = *pphead;
		while (cur->next != NULL)
		{
			cur = cur->next;
		}

		//进行链接
		cur->next = newnode;
	}
}

//尾删
void SListPopBank(SLNode** pphead)
{
	//如果是NULL链表就不能再删
	assert(*pphead);

	//判断一个的情况
	if ((*pphead)->next == NULL)
	{
		free((*pphead)->next);
		*pphead = NULL;
	}
	else
	{
		//找尾
		SLNode* cur = *pphead;
		SLNode* tail = NULL;
		while (cur->next != NULL)
		{
			tail = cur;
			cur = cur->next;
		}

		//释放节点
		free(cur);
		cur = NULL;

		//将前一个节点置为NULL
		tail->next = NULL;
	}

}

//头插
void SListPushFront(SLNode** pphead, SLDateType x)
{
	SLNode* newnode = CreateNode(x);

	SLNode* tail = *pphead;
	*pphead = newnode;
	newnode->next = tail;

	空链表直接插入
	//if ((*pphead) == NULL)
	//{
	//	*pphead = newnode;
	//}
	//else
	//{
	//	SLNode* cur = *pphead;
	//	*pphead = newnode;
	//	newnode->next = cur;
	//}
}

//头删
void SListPopFront(SLNode** pphead)
{
	//如果是空链表就不进行删除
	assert(*pphead);

	SLNode* cur = (*pphead)->next;
	SLNode* tail = *pphead;
	free(tail);
	tail = NULL;
	*pphead = cur;
}

//节点查找
SLNode* SListFind(SLNode* phead, SLDateType x)
{
	SLNode* cur = phead;
	while (cur)
	{
		if (cur->val == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

// 在pos位置之后插入x
void SListInsertAfter(SLNode* pos, SLDateType x)
{
	//后面插入pos为NULL 不行
	assert(pos);

	SLNode* newnode = CreateNode(x);
	SLNode* cur = pos->next;
	pos->next = newnode;
	newnode->next = cur;
}

// 删除pos位置之后的值
void SListEraseAfter(SLNode* pos)
{
	//pos为NULL 不可删后面的
	assert(pos);
	SLNode* cur = pos->next;

	if (cur == NULL)
	{
		free(cur);
		cur = NULL;
		pos->next = NULL;
	}
	else
	{
		SLNode* tail = cur->next;
		free(cur);
		pos->next = tail;
	}
}

// 销毁
void SListDestroy(SLNode* phead)
{
	SLNode* cur = phead;
	SLNode* tail = cur;
	while (cur)
	{
		tail = cur;
		cur = cur->next;
		free(tail);
	}
	tail = NULL;
	phead = NULL;
}


int main()
{
	SLNode* plist = NULL;

	//尾插
	printf("开始尾插：\n");
	SListPushBank(&plist, 1);
	SListPrint(plist);//打印

	SListPushBank(&plist, 2);
	SListPrint(plist);//打印

	SListPushBank(&plist, 3);
	SListPrint(plist);//打印

	SListPushBank(&plist, 4);
	SListPrint(plist);//打印

	SListPushBank(&plist, 5);
	SListPrint(plist);//打印

	//尾删
	printf("开始尾删：\n");
	SListPopBank(&plist);
	SListPrint(plist);//打印

	SListPopBank(&plist);
	SListPrint(plist);//打印

	SListPopBank(&plist);
	SListPrint(plist);//打印

	SListPopBank(&plist);
	SListPrint(plist);//打印

	SListPopBank(&plist);
	SListPrint(plist);//打印

	//头插
	printf("开始头插：\n");
	SListPushFront(&plist, 7);
	SListPrint(plist);//打印

	SListPushFront(&plist, 8);
	SListPrint(plist);//打印

	SListPushFront(&plist, 9);
	SListPrint(plist);//打印

	//头删
	printf("开始头删：\n");
	SListPopFront(&plist);
	SListPrint(plist);//打印

	//SListPopFront(&plist);
	//SListPrint(plist);//打印

	//SListPopFront(&plist);
	//SListPrint(plist);//打印

	printf("查找节点：\n");
	SLNode* cur = SListFind(plist, 8);
	if (cur != NULL)
	{
		printf("找到了：%d \n", cur->val);
	}
	else
	{
		printf("找不到\n");
	}

	printf("pos位置之后插入:\n");
	//pos位置之后插入
	SListInsertAfter(plist->next, 10);
	SListPrint(plist);//打印
	SListInsertAfter(plist, 6);
	SListPrint(plist);//打印

	printf("删除pos位置之后的值：\n");
	// 删除pos位置之后的值
	SListEraseAfter(plist);
	SListPrint(plist);//打印

	SListEraseAfter(plist);
	SListPrint(plist);//打印

	SListEraseAfter(plist);
	SListPrint(plist);//打印

	//销毁
	SListDestroy(plist);
	return 0;
}

青木！
关注
  • 14
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
链表-使用Python实现链表数据结构.zip
03-13
链表 链表_使用Python实现链表数据结构
链表
qq_41965731的博客
10-04 409
根据尚硅谷的韩顺平老师的数据结构视频总结的笔记 观看视频的网址 一、链表的介绍 链表是有序的列表，但是它在内存中是存储如下 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 二、单链表 1、单链表介绍 单链表（带头节点）逻辑结构如下图： 2、单链表的应用实例 使用带head头的单向链表实现 –水浒英雄排行榜管理 ..
【数据结构】链表
热门推荐
knous
03-13 6万+
链表
数据结构-链表（详解）
weixin_73142957的博客
05-11 1967
前言：内容包括：链表的分类，无头单向非循环链表的增删查改的实现，带头双向循环链表的增删查改的实现
数据结构---单向链表，双向链表，单向环形链表
root1994的博客
07-09 4854
链表介绍 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域:指向下一个节点. 如图:发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 修改节点功能 思路(1) 先找到该节点，通过遍历，(2) temp.name = newHeroNode.name ; temp.nickname= newHeroNode.n...
[数据结构] 链表(图文超详解讲解)
积跬步以至千里
09-30 2889
根据本文对链表的介绍后大家能对链表有更深的理解相信大家在过后时间能够保持求学的态度,我们一起加油!offer拿到手软!对博主感兴趣可以关注博主,我会继续更新博客,努力完善我的文章内容不会辜负大家的期待!
链表-使用JAVA语言实现链表数据结构.zip
最新发布
03-13
链表 链表_使用JAVA语言实现链表数据结构
链表数据结构
02-20
链表数据结构该软件包的描述。
C语言 链表数据结构 动态管理数据
06-20
底层C语言软件实现数据结构List.c及list/h文件，通过链表结构实现对数据的动态管理，但需要Malloc函数的配合。实际项目使用多年，数据稳定。
JavaScript实现的链表数据结构实例
10-24
主要介绍了JavaScript实现的链表数据结构实例,本文直接给出实现代码,需要的朋友可以参考下
06 | 链表（上）：如何实现LRU缓存淘汰算法?
ChinaDragon10的博客
11-01 364
今天我们来聊聊“链表（Linked list）”这个数据结构。学习链表有什么用呢？为了回答这个问题，我们先来讨论一个经典的链表应用场景，那就是 LRU 缓存淘汰算法。 缓存是一种提高数据读取性能的技术，在硬件设计、软件开发中都有着非常广泛的应用，比如常见的 CPU 缓存、数据库缓存、浏览器缓存等等。 缓存的大小有限，当缓存被用满时，哪些数据应该被清理出去，哪些数据应该被保留？这就需要缓存淘汰策略来决定。常见的策略有三种：先进先出策略 FIFO（First In，First Out）、最少使用策略 LFU（.
数据结构之——链表
xqx_999的博客
10-06 4108
链表的介绍，单链表和双向链表的接口实现。
数据结构之链表详解
m0_56440500的博客
08-20 2965
链表是一种常见的数据结构，它可以用来存储一组数据，并支持快速的插入和删除操作。相比于数组，链表的大小可以动态地增加或减小，因此在某些场景下更加灵活和高效。本文将详细介绍链表的定义、基本操作和应用场景，希望能够帮助读者深入理解链表的原理和实现。链表是一种线性数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表中的节点可以在内存中任意位置，因此它们不必按照顺序连续存储。链表的头节点是第一个节点，尾节点是最后一个节点，它们分别由指向第一个节点和最后一个节点的指针来表示。
[数据结构]——链表详解
m0_62023005的博客
09-19 3764
数据结构---链表详解
数据结构-链表篇
qq_16268979的博客
01-10 1万+
数据结构-链表篇
数据结构-链表
一个努力拼搏的人
11-13 1200
这里用typedef重新定义了int类型的名称，方便以后更换类型。这里用typedef重新定义了int类型的名称，方便以后更换类型。{}DL;
数据结构——链表
linzixi0220的博客
12-02 1226
链表是由多个地址不连续的存储结点连接而成的一种线性表，每个存储结构不仅包含元素本身的信息（数据域），而且包含表示元素之间的逻辑关系的信息，在c/c++中采样指针来实现，称为指针域，这个逻辑关系用指针来表示就是指向在线性表中与其相连的元素的地址。在线性表中，每个元素最多只有一个前驱结点和后继结点，采样链式存储时，每个结点需要包含前驱结点或者后继结点的地址信息，其中最简单也是最常用的方法是只存储每个结点的后继结点的地址，以这种方式构成的链表称为单链表。
sdut链表数据结构
09-19
sdut链表数据结构是一个循环链表的实现，具体实现过程如下: 1. 首先，在程序中定义了一个结构体node，其中包含了一个整型数据data和一个指向下一个结点的指针next。 2. 然后，通过函数str(int n)创建一个头结点head，并将head的next指针指向NULL，表示链表为空。 3. 接着，通过for循环从1到n遍历，创建新的结点p，并通过scanf函数读取用户输入的数据存入p的data中。 4. 然后，将p的next指针指向head的next指针所指向的结点，实现循环链表的连接。 5. 最后，将head作为函数str的返回值返回。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值