单向链表与双向链表

最新推荐文章于 2023-07-11 14:48:16 发布
最新推荐文章于 2023-07-11 14:48:16 发布
阅读量134 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hbshhb/article/details/96472551
版权

线性表的链式存储

单向链表
链表的操作方法
  1. 创建链表 Create（数据集）
  2. 打印链表 Print（）
  3. 获取链表长度 （数据结点的个数，不包含头结点）Length() int
  4. 插入结点：头插法 InsertByHead(数据)
  5. 插入结点：尾插法 InsertByTail(数据)
  6. 按位置插入：InsertByIndex(数据，index)
  7. 按位置删除：DeleteByIndex（index）
  8. 按数据删除：DeleteByData(数据)
  9. 按数据查找：SearchByData(数据) index
  10. 销毁链表：Destroy（）
创建链表
// 定义链表的结点
type LinkNode struct {
	Data interface{} // 数据域
	Next *LinkNode   // 指针域  -- 8
}

// 创建链表 
func (node *LinkNode) Create(Data ...interface{}) {
	if node == nil || Data == nil {
		return
	}
	if len(Data) == 0 {
		return
	}
	// 创建头结点
	head := node

	// 循环遍历 Data 依次取出数据创建单向链表
	for _, v := range Data {
		// 创建新结点, 并且初始化
		newNode := new(LinkNode)
		newNode.Data = v
		newNode.Next = nil

		node.Next = newNode		// 将当前的下一结点 赋值为 新结点
		node = node.Next		// 更新 新结点为 当前结点.
	}
	// 将node 赋值为 头结点
	node = head
}
打印链表
// 打印链表 ----递归法
func (node *LinkNode) Print1() {

	if node == nil { // 容错, 也是递归出口
		return
	}
	if node.Data != nil {
		fmt.Print(node.Data, " ")
	}
	// 递归调用本函数,打印
	node.Next.Print1()
}

// 打印链表 ----循环法
func (node *LinkNode) Print2() {
	if node == nil {
		return
	}

	for node.Next != nil {
		node = node.Next //跳过头结点
		if node.Data != nil {
			fmt.Println(node.Data)
		}
	}
}
获取链表长度
// 获取链表的长度
func (node *LinkNode) Length() int {
	if node == nil {
		return -1
	}
	// 定义一个计数器
	i := 0
	// 循环统计数据结点个数
	for node.Next != nil {
		// 后移node 结点
		node = node.Next
		i++
	}
	return i
}
头插法
// 插入链表结点---头插
func (node *LinkNode) InsertByHead(Data interface{}) {
	if node == nil || Data == nil {
		return
	}
	// 创建新结点, 初始化
	newNode := new(LinkNode)
	newNode.Data = Data
	newNode.Next = nil

	// 将新结点的下一个结点,赋值为 原链表的 第一个结点(node.Next)
	newNode.Next = node.Next

	// 头结点的下一个结点赋值为 新结点
	node.Next = newNode
}
尾插法
// 插入链表结点---尾插
func (node *LinkNode) InsertByTail(Data interface{}) {
	if node == nil || Data == nil {
		return
	}
	// 创建新结点
	newNode := new(LinkNode)
	newNode.Data = Data
	newNode.Next = nil

	// 找到原链表的最后一个结点
	for node.Next != nil {
		node = node.Next
	}

	// 将新结点设置为 尾结点
	node.Next = newNode
}
按位置插入
// 插入链表结点---按位置插
func (node *LinkNode) InsertByIndex(Data interface{}, index int) {
	if node == nil || Data == nil {
		return
	}
	if index < 0 || index > node.Length() {
		return
	}
	// 创建新结点
	newNode := new(LinkNode)
	newNode.Data = Data
	newNode.Next = nil

	// 定义变量,记录插入结点的前一个结点
	preNode := node

	// 找寻待插入位置
	for i := 0; i < index; i++ {
		preNode = node
		node = node.Next
	}

	// 将新结点的下一结点,指向 node
	newNode.Next = node
	// 将 preNode 的下一结点赋值为 新结点
	preNode.Next = newNode

}
// 插入链表结点---按位置插 2
func (node *LinkNode) InsertByIndex2(Data interface{}, index int) {
	if node == nil || Data == nil {
		return
	}
	if index < 0 || index > node.Length() {
		return
	}
	// 如果插入位置在尾部.
	if index == node.Length() {
		node.InsertByTail(Data)
		return
	}

	// 创建新结点
	newNode := new(LinkNode)
	newNode.Data = Data
	newNode.Next = nil

	// 找寻待插入位置
	for i := 0; i < index-1; i++ {
		node = node.Next
	}
	newNode.Next = node.Next
	node.Next = newNode
}
按位置删除
// 按位置删除结点
func (node *LinkNode) DeleteByIndex(index int) {
	if node == nil {
		return
	}
	if index < 0 || index > node.Length() {
		return
	}
	// 定义index 指代结点的前一个结点
	preNode := node

	// 循环找到 index 对应结点,保存在 node 中
	for i := 0; i < index; i++ {
		preNode = node
		node = node.Next
	} // 当循环结束时, prenode 保存 index 的前一个结点, node 保存index 对应的结点

	// 将index 前一个结点的 next 指针,指向 index 后一个结点
	preNode.Next = node.Next

	// 将摘下的结点置空, 促使 GC 回收
	node.Data = nil
	node.Next = nil
	node = nil

}
按数据删除
// 按数据删除结点
func (node *LinkNode) DeleteByData(Data interface{}) {
	if node == nil || Data == nil {
		return
	}
	// 创建遍历,保存待删除结点的前一个结点
	preNode := node

	for node.Next != nil {
		preNode = node
		node = node.Next  // 循序后移
		// 比较数据/类型
		if reflect.TypeOf(node.Data)==reflect.TypeOf(Data) && reflect.DeepEqual(node.Data, Data) {

			preNode.Next = node.Next // 前一个结点,指向后一个结点
			// 置空 ,驱使 GC工作
			node.Data = nil
			node.Next = nil
			node = nil
			return
		}
	}
}
按数据查找结点
// 按数据查找结点
func (node *LinkNode) SearchByData(Data interface{}) int {
	if node == nil || Data == nil {
		return -1
	}
	// 定义计数器 i
	i := 0
	for node.Next != nil {
		i++
		node = node.Next
		if reflect.TypeOf(node.Data)==reflect.TypeOf(Data) && reflect.DeepEqual(node.Data, Data) {
			return i
		}
	}
	return -1
}
销毁链表
// 销毁链表
func (node *LinkNode) Destroy() {
	if node == nil {
		return
	}
	//递归 销毁链表结点
	node.Next.Destroy()

	// 置空结点,促使 GC 工作
	node.Data = nil
	node.Next = nil
	node = nil
}
比较顺序表与链式表
  • 顺序表（切片）：内存连续
    • 优点
      • 查找速度快
      • 内存空间占用小
    • 缺点
      • 增删效率低
    • 使用场景
      • 数据查询批量较高，可适当牺牲存储空间
  • 链式表（链表）：散乱存储
    • 优点
      • 增删效率高
    • 缺点
      • 查询效率低
      • 需要额外占用内存
    • 使用场景
      • 数据修改（增删）频繁

双向链表

结点数据结构

type LinkNode struct {
    Data interface{}
    Prev *LinkNode
    Next *LinkNode
}

在这里插入图片描述

双向链表方法：
  1. 创建链表 Create(数据)
  2. 打印链表 Print()
  3. 获取结点个数 Length() int
  4. 插入结点 Insert(index, 数据)
  5. 删除结点 Delete(index)
  6. 销毁链表 Destroy()
创建双向链表 Create()
  1. 容错
  2. 创建头结点 head = node
  3. 遍历 Data 参数列表，依次创建新结点。 初始化
    1. newNode.Prev = node
    2. node.Next = newNode
    3. node = node.Next
  4. 还原头结点
// 创建双向链表结点
type LinkNode struct {
	Data interface{} // 数据域
	Prev *LinkNode   // 前引指针域
	Next *LinkNode   // 后继指针域
}

// 创建双向链表
func (node *LinkNode) Create(Data ...interface{}) {
	if node == nil || Data == nil {
		return
	}
	if len(Data) == 0 {
		return
	}
	// 创建头结点
	head := node

	// 循环Data 创建数据结点
	for _, v := range Data {
		// 创建新结点,并初始化
		newNode := new(LinkNode)
		newNode.Data = v
		newNode.Prev = node
		newNode.Next = nil

		node.Next = newNode		// 当前结点的下一个结点 赋值为新结点
		node = node.Next		// 更新新结点为当前结点
	}
	// 还原头结点
	node = head
}
链表打印 Print()
正序打印 – 递归
  1. 容错，递归出口
  2. 判断 node.Data 不为空，打印数据
  3. 递归调用 本函数。
// 双向链表打印 --- 递归 --正向
func (node *LinkNode) Print1() {
	if node == nil { // 容错,递归出口
		return
	}
	if node.Data != nil {
		fmt.Print(node.Data, " ")
	}
	// 递归调用本函数
	node.Next.Print1()
}
倒序打印 – 循环
  1. 容错
  2. 找到链表尾结点，保存在 node 中
  3. 循环，从链表的尾结点开始，使用 prev ，依次向前打印
    1. 判断 node.Data 不为空，打印数据
// 双向链表打印 --- 循环 --反向
func (node *LinkNode) Print2() {
	if node == nil { // 容错
		return
	}
	// 找到链表的尾结点,保存在 node 中
	for node.Next != nil {
		node = node.Next
	}

	// 借助 prev 倒序 打印链表数据
	for node.Prev != nil {
		// 打印数据
		if node.Data != nil {
			fmt.Print(node.Data, " ")
		}
		// node依次前移
		node = node.Prev
	}
}
按位置插入结点 InsertByIndex()
  1. 容错
  2. 定义 preNode 用来保存 index 对应的前一个结点
  3. 循环 移动 node、preNode。 循环结束时， node 保存 index 对应结点。
  4. 创建新结点， 初始化
    1. 数据域初始化
    2. 新结点的 Prev， 是 preNode
    3. 新结点的 Next，是 node
  5. node 的Prev 指向 新结点
  6. preNode 的 Next 指向 新结点。
    在这里插入图片描述
// 按位置插入链表结点
func (node *LinkNode) InsertByIndex(index int, Data interface{}) {
	if node == nil || Data == nil {
		return
	}
	if index < 0 || index > node.Length() {
		return
	}
	// 定义preNode ,保存前一个结点
	preNode := node

	// 循环 找到 index 对应结点, 保存在 node 中
	for i := 0; i < index; i++ {
		preNode = node
		node = node.Next
	}	// 循环结束, node指向index 对应结点, prenode 指向前一个结点

	// 创建新结点
	newNode := new(LinkNode)
	newNode.Data = Data
	newNode.Prev = preNode
	newNode.Next = node

	// node 的 prev指向新结点
	node.Prev = newNode

	// preNode 的 next 是新结点
	preNode.Next = newNode
}
按位置删除结点 DeleteByIndex（）
  1. 容错
  2. 定义preNode ， 用来保存 index 对应的前一个结点
  3. 循环找到 node 、preNode
  4. 将 preNode 的 Next 指向 node 的 Next
  5. 将 node 的 下一个结点的 Prev 保存 preNode
  6. 置空 摘下的结点，促使GC工作
  7. 判断 如果 index 为 链表的 尾结点时
    1. 将 尾结点（node）的 前一个结点 （preNode）的Next 置空
    2. 将 尾结点 置空 。 促使GC工作

在这里插入图片描述

/ 按位置删除链表结点
func (node *LinkNode) DeleteByIndex(index int) {
	if node == nil  {
		return
	}
	if index < 0 || index > node.Length() {
		return
	}

	l := node.Length()	// 保存长度，防止后续node变化，无法获取链表完整长度。

	// 定义 preNode 记录 index 对应的前一个结点
	preNode := node

	// 循环 移动 preNode 和 node
	for i:=0; i<index; i++ {
		preNode = node
		node = node.Next
	}

	// 如果 index 是最后一个结点
	if index == l{
		preNode.Next = nil

		node.Data = nil
		node.Prev = nil
		node.Next = nil
		node = nil
		return
	} else {
		// 将 preNode 的 next 保存 node 的 下一个结点
		preNode.Next = node.Next

		// 将 node 的一下结点 的 prev 保存 preNode
		node.Next.Prev = preNode

		// 置空摘下的结点
		node.Data = nil
		node.Prev = nil
		node.Next = nil
		node = nil
	}
}
陽光微涼
关注
专栏目录
Python单向链表和双向链表原理与用法实例详解
09-20
双向链表的创建与单向链表类似，只是每个节点还需要一个prev指针，初始状态下，头节点的prev指针指向None，尾节点的next指针也指向None。 2. 插入节点： 在双向链表中插入节点，除了要更新下一个节点的引用，还要...
Intel的单向链表与双向链表,C语言源码
09-20
在Intel的实现中，单向链表和双向链表被广泛应用于内存管理、数据结构优化和其他系统级任务。这两种链表的主要区别在于节点之间的链接方式，这直接影响了它们的操作效率和用途。 **单向链表** 是一种线性数据结构，...
线性表（下）之链式存储之双向，单向循环列表
许我向你看丶的博客
04-16 257
线性表之链式存储（双向循环链表） //注意：该文件操作的链表为带头结点双向链表，头结点数据为-1 #include #include #include #define OK 1 #define ERROR 0 typedef int data_t; typedef struct DulNode { data_t data; struct DulNode *pri
单向链表与双向链表区别
大伟伟的博客
10-25 7924
单向链表： 由两部分组成：数据域和指针域,每个结点都有一个指针，每个节点指针的指向都是指向自身结点的下一个结点，最后一个结点的head指向为null,对单链表的操作只能从一端开始，如果需要查找链表中的某一个结点，则需要从头开始进行遍历。 双向链表： 对于双向链表来说，它的每个节点要指向“直接前驱”和“直接后继”，所以节点类需要含有两个指针域。指向直接前驱的指针使用pre表示，指向后继的指针使用next表示。双向链表是在单向链表基础上的一个改进，每个节点指向其直接前驱和直接后继节点。因此，从双向链表的任
单向链表与双向链表：Java实现
weixin_43854959的博客
07-11 270
链表是一种常见的数据结构，它由一系列的节点组成。每个节点包含一个数据元素和一个指向下一个节点的指针。根据指针的数量和方向，链表可以分为单向链表和双向链表。本文将详细介绍这两种链表的定义、特点和Java实现。
【数据结构与算法02】单向链表与双向链表
一个正在努力学习的iter
05-19 595
1. 单向链表 1.1 单向链表介绍 单向链表是链表的一种，它由多个结点组成，每个结点都由一个数据域和一个指针域组成，数据域用来存储数据，指针域用来指向其后继结点。链表的头结点的数据域不存储数据，指针域指向第一个真正存储数据的结点。 1.2 单向链表的API设计 1.3 单向链表的代码实现 import java.util.Iterator; public class LinkList<T> implements Iterable<T>{ //记录头结点 pri
队列之单向链表与双向链表的模拟实现
weixin_64308540的博客
01-20 376
队列之单向链表与双向链表的模拟实现
java 单向链表 双向链表_java 单向链表与双向链表的实现
weixin_31093677的博客
02-19 238
链表单向链表单向链表概念链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。这是一种物理结构，不是树那样的逻辑结构。链表和顺序表两种物理结构，说明的是数据元素在内存中是如何存储的。顺序表是连续顺序存储，例如数组。而链表是非连续非顺序的。基本API的java代码实现代码如下，实现基本的增查删改的功能。public class SinglyLinked...
Java 单向链表与双向链表之间的区别
weixin_52973261的博客
07-29 131
Java 单向链表与双向链表之间的区别 https://www.jianshu.com/p/e1f93a66a084
单向、双向链表
大树
12-08 2964
链表 一、介绍 1、介绍 ​ 链表是一种非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点（链表中每一个元素称为节点）组成，节点可以在运行时动态生成。每个节点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域 （1）单向链表(单链表)是链表的一种，它由节点组成，每个节点都包含下一个节点的指针 （2）双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据节点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链
结构与算法(03)：单向链表和双向链表
【积累】，是一个长期持续的过程。
09-18 539
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点组成，节点可以在运行时动态生成，节点包括两个部分一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。...
197号资源-源程序：（SCI论文+程序）ACES： 使用卡尔曼滤波的自适应时钟估计和同步-本人博客有解读
09-25
该资源详细解读可关注博主免费专栏《论文与完整程序》197号博文 跨网络的时钟同步对于包括有线网络在内的大量应用传感器网络中数据融合的测量。早些时候技术要么局限于令人不快的准确性，要么依赖于关于可能无用的特定硬件特性-可用于某些系统。在这项工作中，我们研究了资源受限网络中的时钟同步问题例如无线传感器网络，其中节点具有有限的能量和带宽，也缺乏高AC-精准振荡器或可编程网络接口以前的协议依赖于。本文推导出了一个新的概念--时钟偏移量和偏差的外设模型，并演示了其适用性。在此基础上设计了高效的算法在给定LIM的情况下实现高同步精度的模型有限的资源。这些算法将卡尔曼滤波应用于跟踪时钟偏移量和偏差，并自适应地调整同步间隔，以便所需的误差界都实现了。我们展示了性能优势我们的方案通过广泛的模拟来遵守真实的-世界的制约因素。
基于JavaScript的wxwobot微信多开运营自助工具设计源码
09-25
该项目是一款基于JavaScript开发的wxwobot微信多开运营自助工具设计源码，共包含160个文件，涉及78个Java源文件、24个JavaScript文件、14个CSS样式文件、13个HTML文件、5个Git忽略配置文件、4个XML文件、3个Shell脚本文件、3个PNG图片文件以及2个属性文件和2个文本文件。尽管项目已停止维护，但其在岁月安好的背景下仍具有实用价值。
基于Html和JavaScript的教师微社区设计源码
09-25
该项目是一款基于Html和JavaScript构建的教师微社区设计源码，共包含29个文件，涵盖了8个HTML文件、8个JavaScript文件、4个PNG图片文件、3个CSS样式表文件以及各类字体和图标资源。该系统旨在为教师提供一个便捷的在线交流平台。
关于爆破相关任务的文件
09-25
关于爆破相关任务的文件
基于JavaScript/TypeScript/微信小程序/Java的老年人体能测试小程序设计源码
09-25
本项目是一款针对老年人体能测试的小程序，采用JavaScript/TypeScript/微信小程序/Java等多语言开发，源码包含1480个文件，涵盖304个JavaScript文件、285个TypeScript文件、237个WXML文件、235个WXSS样式文件、233个JSON配置文件、135个WXS脚本文件、33个Java文件等，旨在提供全面、便捷的老年人体能测试服务。
2023年电赛国赛装置2代码
最新发布
09-25
2023年电赛国赛装置2代码， 主控为STM32F103RCT6
Python获取图片ARGB值并生成代码
09-25
实际代码文件和shell文件
JavaScript实现链表：单向链表与双向链表解析
"本文主要介绍了JavaScript中的数据结构与算法中的链表，包括链表的基本概念、单向链表和双向链表的实现。" 在计算机科学中，数据结构是组织和存储数据的方式，而算法是解决问题的具体步骤。链表作为一种重要的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值