golang实现双链表

Golang 双链表(Doubly Linked List) 双向链表的每个数据节点包含三个元素:数据、前驱节点的指针、后继节点的指针。头部节点 单向循环链表和单向链表相似,每个数据节点包含数据和后继节点的指针,区别在于最后一个节点的后继节点指针为链表的头部节点,形成一个环。 双向链表的每个数据节点包含三个元素:数据、前驱节点的指针、后继节点的指针。头部节点的前驱指针为NULL, 尾部节点的后继指针为NULL 2.2.2 尾部追加数据 2.2.4 index查找节点数据 2.2.5 从任意位置插入 2.2.6 从头部 阅读详情



package main

import (
	"fmt"
	"time"
)


type Element interface {}


var header *entry  //链表表头
var size int  //链表长度

type entry struct {
	previous *entry
	next     *entry
	element  Element
}

func newEntry(prev,next *entry,e Element) *entry {
	return  &entry{prev,next,e}
}

//初始化header  表头
func NewLinkedList() *entry {
	header = newEntry(nil,nil,nil)
	header.previous =header
	header.next = header
	return header
}

type LinkedList interface {
	add(e  Element)
	addFirst(e  Element)
	addLast(e Element)
	get(location int) Element
	getFirst() Element
	getLast() Element
	remove(location int) Element
	removeFirst()  Element
	removeLast() Element
	size() int
	removeAll() bool
	getAll() []Element
}

//将元素添加到链表的末尾
func (e *entry) add(element Element)  {
	addBefore(header,element)
}

func (e *entry)addFirst(element Element)  {
	addBefore(header.next,element)
}

func (e *entry) addLast(element Element)  {
	addBefore(header,element)
}

func (e *entry) get(location int) Element {
	entry := getEntryByIndex(location)
	if entry != nil {
		return entry.element
	}
	return nil
}

func (e *entry) getFirst() Element {
	if size == 0 {
		fmt.Println("chian is empty!")
		return nil
	}
	return header.next.element
}

func (e *entry) getLast() Element {
	if size == 0 {
		fmt.Println("chain is empty!")
		return nil
	}
	return header.previous.element
}

func (e *entry) remove(location int) Element {
	if location < 0 || location >= size {
		fmt.Println("check index error")
		return nil
	}
	rmEntry := getEntryByIndex(location)
	element := rmEntry.element
	rmEntry.previous.next = rmEntry.next
	rmEntry.next.previous = rmEntry.previous
	rmEntry = nil
	size--
	return element
}

func (e *entry) removeFirst()  Element{
	return e.remove(0)
}

func (e *entry) removeLast() Element {
	return e.remove(size-1)
}

func (e *entry) size() int {
	return size
}

func (e *entry)removeAll() bool {
	entry := header.next
	for entry != header {
		next := entry.next
		entry.next = nil
		entry.previous = nil
		entry.element = nil
		entry = next
	}
	header.next = header
	header.previous = header
	size = 0
	return true
}

func (e *entry)getAll() []Element {
	resultList := make([]Element,0,size)
	entry := header
	for i:= 0 ; i < size ;i++ {
		resultList = append(resultList,entry.next.element)
		entry = entry.next
	}
	return resultList
}

//在entry节点之前添加
func addBefore(e *entry,element Element) Element{
	newEntry := newEntry(e.previous,e,element)
	newEntry.previous.next = newEntry
	newEntry.next.previous = newEntry
	size++
	return newEntry
}

func getEntryByIndex(index int) *entry {
	if index < 0 || index >= size {
		fmt.Println("check index error")
		return nil
	}
	e := header

	if index < (size >> 1) {
		for i:=0 ; i <= index ;i++ {
			e = e.next
		}
	}else {
		for i:= size ; i > index; i-- {
			e = e.previous
		}
	}
	return e

}

func main() {
	linkedList := NewLinkedList()
	for i:=0 ;i<50;i++ {
		linkedList.add(i)
	}
	fmt.Println(size)
	fmt.Println(linkedList.get(40))
	fmt.Println(len(linkedList.getAll()),linkedList.getAll())
	linkedList.addFirst(100)
	fmt.Println(len(linkedList.getAll()),linkedList.getAll())
	linkedList.addLast(200)
	fmt.Println(len(linkedList.getAll()),linkedList.getAll())
	linkedList.add(1000)
	fmt.Println(len(linkedList.getAll()),linkedList.getAll())
	fmt.Println(linkedList.get(50))
	fmt.Println(linkedList.getFirst())
	fmt.Println(linkedList.getLast())

	fmt.Println(linkedList.removeFirst())
	fmt.Println(len(linkedList.getAll()),linkedList.getAll())
	fmt.Println(linkedList.removeLast())
	fmt.Println(len(linkedList.getAll()),linkedList.getAll())
	fmt.Println(linkedList.remove(50))
	fmt.Println(len(linkedList.getAll()),linkedList.getAll())
	fmt.Println(linkedList.removeAll())
	fmt.Println(len(linkedList.getAll()),linkedList.getAll())

	t := time.Now()
	for i:=0;i<400000;i++ {
		linkedList.add(i)
	}
	fmt.Println(time.Since(t))
	fmt.Println(linkedList.size())

	t = time.Now()
	fmt.Println(linkedList.get(200000))
}


Go:DoublyLinkedList双链表(附完整源码) 阅读详情

相关推荐

RK3588 Linux启动优化至亚秒级全链路剖析

本文深入探讨RK3588平台Linux系统启动加速技术,涵盖从BL1/ATF安全固件、U-Boot剪裁到内核精简化等全链路优化方案,实现从上电到用户脚本800ms内完成的实战经验。​​文末提供完整解决方案获取方式​​。由于在 ARMv6 之后引入了 TrustZone 模块, 目前市面上 ARMv7 和 ARMv8 之后的系统都会包含了该模块, 这个模块由 BL1 启动, 且在 ATF(ARM Trust Firmware) 固件中, 既安全世界中引导到 BL33 (UBOOT)的系统。

韩若明溪 1779

Go中的链表

一般来说,为了比较好的对单链表进行增删改查的操作,我们会定义一个头节点,头节点的作用主要是来标识链表头,本身这个节点不存放数据示意图no int//判断是不是添加第一只猫head.next = head //构成一个环形return//定义一个临时变量,帮忙,找到最后的结点for {break//加入到链表中// 显示这个环形的链表fmt.Println("环形链表情况如下")fmt.Println("空空如也")returnfor {break// 删除一只猫。

z3551906947的博客 895

jenkins安装、打包、部署

一个可以让小白部署发布项目的软件;git 配置 一定要配置git的命令路径jenkins启动命令,一定要加这一段 -Dhudson.util.ProcessTree.disable=true一定要配置jenkins的节点,BUILD_ID和DONTKILLME 否则会导致打包后,会将运行的java程序进程也杀死创建任务SSH中执行服务器B的命令的时候,cd /opt;一定要cd 打开那个目录,否则文件无法传输过去。

学海无涯,我用JAVA 5221

Go数据结构------链表

映射起来的内置语法结构,数据和数据之间是挨着,存放在一个连续的内存区域,每一个固定大小(8字节)的内存片段都有一个虚拟的地址编号。另一个是我们定义的数据结构,通过一个数据节点,可以定位到另一个数据节点,不要求连续的内存空间。有些书籍,把链表做了很细的划分,比如单链表,双链表,循环单链表,循环双链表,其实没有必要强行分类,链表就是从一个数据指向另外一个数据,一种将数据和数据关联起来的结构而已。问题是,有时候需要做删除,移动等各种操作,而数组的大小是固定的,需要大量空间移动,所以某些情况下,数组的效率很低。

zhangzhongyanting的博客 888

微信小程序网关逆向分析:从协议、签名到会话管理的安全架构剖析

在现代Web与移动应用开发中,API网关作为客户端与后端服务之间的关键通信枢纽,承担着协议转换、流量调度、安全防护与性能优化等核心职责。其工作原理通常涉及统一的请求路由、身份认证、参数校验与响应聚合。从技术价值看,深入理解网关机制不仅能帮助开发者构建更健壮、可扩展的微服务架构,还能为安全评估、性能调优与故障排查提供基础。在移动生态如微信小程序中,网关设计尤为关键,它需要处理微信特有的登录态、数据加密与防重放攻击等安全需求。本文聚焦于微信小程序网关的逆向分析方法,通过结合网络抓包与代码反编译技术,深入解析其通

weixin_29323493的博客 443

YOLOv5改进 | 注意力篇 | iRMB倒置残差块注意力机制(轻量化注意力机制,附二次创新)

本文给家大家带来的改进机制是iRMB,其是在论文Rethinking Mobile Block for Efficient Attention-based Models种提出,论文提出了一个新的主干网络EMO(后面我也会教大家如何使用该主干,本文先教大家使用该文中提出的注意力机制)。其主要思想是将轻量级的CNN架构与基于注意力的模型结构相结合(有点类似ACmix)我将iRMB和C2f结合,然后也将其用在了检测头种进行尝试三种结果进行对比,针对的作用也不相同,但是无论那种实验均有一定涨点效果。

Snu77的博客 2571

golang数据结构——链表

golang链表详解

lp15929801907的博客 1878

基于matlab目标雷达横截面建模(附源码)

雷达系统依靠目标反射或散射来检测和识别目标。目标反射越强,雷达接收器返回的回波就越大,从而获得更高的信噪比(SNR)和更高的检测可能性。在雷达系统中,从目标反射的能量由雷达横截面(RCS)决定,定义为sigma代表RCS,R是雷达与目标之间的距离,Es是从目标反射的信号的场强,以及Ei是入射到目标上的信号的场强。通常,目标向各个方向散射能量,RCS是入射角,散射角和信号频率的函数。RCS 取决于目标的形状和构建目标的材料。用于RCS的常用单位包括平方米或dBsm。

珞瑜的博客 3086

go 实现双向链表

一说明 使用带head头的双向链表实现——水浒英雄排行榜管理。 单向链表的缺点分析。 1单向链表,查找的方向只能是一个方向,而双向链表可以向前或者向后查找。 2单向链表不能自我删除,需要靠辅助节点,而双向链表,则可以自我删除,单链表删除时,总要找到temp的下一个节点来删除。 二图解 三代码 package main import ( "fmt" ) // HeroNode type HeroNode struct { no int n...

实践求真知 409

在鸿蒙中使用AVPlayer完成视频的播放【坚果派】

播放的全流程包含:创建AVPlayer,设置播放资源和窗口,设置播放参数(音量/倍速/缩放模式),播放控制(播放/暂停/跳转/停止),重置,销毁资源。5.准备播放:调用prepare(),AVPlayer进入prepared状态,此时可以获取duration,设置缩放模式、音量等。8.退出播放:调用release()销毁实例,AVPlayer进入released状态,退出播放。6.视频播控:播放play(),暂停pause(),跳转seek(),停止stop() 等操作。今天我们来看一下视频如何正常播放。

坚果的博客 4058

【Arduino 动手做】六舵机自平衡 Rotary Stewart 平台

《Arduino六舵机自平衡Rotary Stewart平台项目》 该项目展示了一个基于Arduino的六自由度Rotary Stewart平台,通过六个舵机实现动态平衡控制。设计采用激光切割框架和TAMIYA 70171套件,提供详细组装指南和开源固件(GitHub可获取)。开发者丹·罗耶分享了3D打印文件、视频演示及运动学优化需求,强调该平台可扩展应用于游戏控制(如Kerbal Space Program)或教育领域。项目链接包含完整资源包,鼓励用户参与改进并分享创作成果。该案例体现了Arduino在机

雕爷学编程 1096

Golang——实现双链表

双链表(Doubly Linked List)是一种链表数据结构,它的每个节点都有两个链接:一个指向前一个节点(如果有的话),另一个指向下一个节点(如果有的话)。这使得双链表在遍历、插入和删除节点时都具有一定的灵活性。双链表和单链表的基本操作有很多相似的。。

qq_61453210的博客 923

Arduino I2C for TCA9548A应答扫描程序

Arduino I2C for TCA9548A应答扫描程序

perseverance51博客 1122

golang实现单/双链表

使用go语言实现一个单链表(保存内容为int),该链表提供以下方法 1).创建链表 2).在链表头部插入一个节点 3).返回链表元素个数 4).打印链表所有的元素 type Node struct { Data int Next *Node } type List struct { headNode *Node } func NewList() *List ...

仅做个人笔记 178

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

Go实现双链表

直接通过root就可以看首位节点// Front 返回双链表的第一个元素地址return nil// Back 返回双链表的做后一个元素地址return nil。

qq_29647593的博客 760

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

golang实现双链表增删改查

双向链表 循环单链表的出现,虽然能够实现从任一结点出发沿着链能找到其前驱结点,但时间耗费是O(n)。如果希望从表中快速确定某一个结点的前驱,另一个解决方法就是在单链表的每个结点里再增加一个指向其前驱的指针域prior。这样形成的链表中就有两条方向不同的链,我们可称之为双(向)链表(Double Linked List) 双向链表示意图: golang双链表案例代码(增删改查): package ...

疯狂的鸭血 474

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

【Golang】单指针实现双链表

如何用单指针实现双链表?要解决这个问题,我们需要一些思维的铺垫,下面分三个步骤,由浅入深地带你实现! 正常:实现一个单链表 网上单链表的实现非常多,考虑到实用性,设计也不尽相同。下面选一个最直白简单的。 show me the code https://gist.github.com/RBowind/1561ac542b0c33bbf1da20d47640d80f //Element 单链表每一个节点 type Element struct { next *Element //索引下一个节点 V.

purecoolr的博客 198

go语言实现双链表

package main import "fmt" type DNode struct { data int next *DNode prev *DNode } type DoubleLinkList struct { length int head *DNode tail *DNode } func CreateDNode(data int) *DNode{ return...

u012967763的专栏 245

基础数据结构---双链表go语言的代码实现

本文件:带头结点双链表的各种操作 1.创建双链表 2.头插 3.尾插 4.显示双链表 5.按位查询 6.按位插入 7.按位删除 8.按值插入 package main /* 本文件:带头结点双链表的各种操作 1.创建双链表 2.头插 3.尾插 4.显示双链表 5.按位查询 6.按位插入 7.按位删除 8.按值插入 */ import ( "errors" "fmt" ) type Node struct { key int value string pre *Node next *No.

QQ845264718 209

golang之单链表和双链表实现

实现单链表、双向链表,增删操作 单链表实现 package linkedList import "fmt" /** * * 实现单链表(可以完成增,删,查) * 增加分为:在指定的节点前增加,在指定的节点后增加,在链表的尾部/头部插入节点; * 删除分为:删除指定的节点; * Author: sxy */ // ps: 对于循环单链表而言,只需要将尾节点指向首节点即可。 type Node struct { next *Node val int } type LinkedList struc

weixin_34593133的博客 344

go--双链表的实现(增删改查)

前些时间写了关于单链表的的基本实现,这些天看到一些关于双链表的问题,就决定再写一篇关于双链表的基本操作,其实与单链表的实现没有本质上的区别,只是增加了一个前继指针,下面看一下具体实现; package main import ( "fmt" ) type Node struct { //节点的定义 data int Pro *Node Next ...

LYue123的博客 402

go--双链表的实现(增删改查)改进版

之前就写过双链表的实现,但是今天看的时候发现了一个问题,就是在查询元素的时候并没有好好利用双链表的特性,所以今天又重新编辑了一下,大家看看区别 代码: package main import "fmt" type Node struct { data int pre *Node Next *Node } type DoubleList struct { Head *Node leng...

LYue123的博客 312

基础数据结构----不带头结点的循环双链表go语言的实现

/* 不带头结点的循环双链表 */ package main import ( "errors" "fmt" ) //链表的结构体 type Node struct { key int value string pre *Node next *Node } //创建一个链表 func newList(key int, value string) (list *Node) { list = & Node{ key:key, value: value, } list.p

QQ845264718 290

手把手用Golang实现LFU缓存:从零设计支持频率统计的双链表

本文详细介绍了如何使用Golang从零开始实现一个高效的LFU缓存。通过设计基于频率桶的双层链表数据结构,解决了传统LFU算法中的频率统计与热点突增问题,并对比了LFU与LRU在不同场景下的性能表现,为高并发系统缓存优化提供了工程实践参考。

weixin_29258297的博客 84

java双链表实现lru算法_golang LRU实现(使用双向链表实现)

LRU(Least recently used,最近最少使用)算法根据数据的历史访问记录来进行淘汰数据,其核心思想是“如果数据最近被访问过,那么将来被访问的几率也更高”。lru.gotype Key interface{}type entry struct {key Keyvalue interface{}}type Cache Struct {MaxEntries intOnEvicted...

weixin_39724469的博客 229
上一篇: golang实现单链表
下一篇: golang实现栈操作
思维的深度
博客等级 码龄11年 2万+粉丝 391原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值