【代码随想录】链表-golang

最新推荐文章于 2024-10-16 18:55:04 发布
最新推荐文章于 2024-10-16 18:55:04 发布
阅读量900 收藏
点赞数
分类专栏： 代码随想录【练习】 文章标签： 链表 golang 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flowerxxxxx/article/details/128416309
版权

链表 from 代码随想录

移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

思路：设置一个新的节点，节点的下一个是链表的第一个节点

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeElements(head *ListNode, val int) *ListNode {
    ptr := &ListNode{Next:head}
    for vptr := ptr;vptr.Next != nil;{
        if vptr.Next.Val == val{
            vptr.Next = vptr.Next.Next
        }else{
            vptr = vptr.Next
        }
    }
    return ptr.Next
}

设计链表

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。
在链表类中实现这些功能：
get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

单向链表

设置一个头部的哨兵节点
在这里插入图片描述

type MyLinkedList struct {
	head *ListNode
	size int
}

type ListNode struct {
	Next *ListNode
	Val  int
}

func Constructor() MyLinkedList {
	return MyLinkedList{head:&ListNode{},size:0}
}


func (this *MyLinkedList) Get(index int) int {
	if index > this.size - 1 || index < 0 {
		return  -1
	}
	ptr := this.head
	for i:=0;i<=index;i++{
		ptr = ptr.Next
	}
	return ptr.Val
}


func (this *MyLinkedList) AddAtHead(val int)  {
	this.AddAtIndex(0,val)
}


func (this *MyLinkedList) AddAtTail(val int)  {
	this.AddAtIndex(this.size,val)
}


func (this *MyLinkedList) AddAtIndex(index int, val int)  {
	if index > this.size {
		return
	}
	index = max(index,0)
	this.size ++
	ptr := this.head
	for i:=0;i<index;i++{
		ptr = ptr.Next
	}
	adder := &ListNode{Val:val,Next:ptr.Next}
	ptr.Next = adder
}

func max(a,b int)int{
	if a > b {
		return a
	}
	return b
}

func (this *MyLinkedList) DeleteAtIndex(index int)  {
	if index > this.size - 1 || index < 0{
		return
	}
	this.size --
	ptr := this.head
	for i:=0;i<index;i++{
		ptr = ptr.Next
	}
	ptr.Next = ptr.Next.Next
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * obj := Constructor();
 * param_1 := obj.Get(index);
 * obj.AddAtHead(val);
 * obj.AddAtTail(val);
 * obj.AddAtIndex(index,val);
 * obj.DeleteAtIndex(index);
 */

双向链表

在两头各设置一个哨兵节点
在这里插入图片描述

type MyLinkedList struct {
    head,tail *node
    size int
}

type node struct{
    val int
    next,prev *node
}


func Constructor() MyLinkedList {
    head := &node{}
    tail := &node{}
    head.next = tail
    tail.prev = head
    return MyLinkedList{head:head,tail:tail,size:0}
}


func (this *MyLinkedList) Get(index int) int {
    if index >= this.size || index < 0 {
        return -1
    }
    if index+1 > this.size/2 {
        eptr := this.tail
        for i:=0;i <= this.size-index-1;i++{
            eptr = eptr.prev
        }
        return eptr.val
    }else{
        sptr := this.head
        for i:=0;i <= index;i++{
            sptr = sptr.next
        }
        return sptr.val
    }
}


func (this *MyLinkedList) AddAtHead(val int)  {
    this.AddAtIndex(0,val)
}


func (this *MyLinkedList) AddAtTail(val int)  {
    this.AddAtIndex(this.size,val)
}


func (this *MyLinkedList) AddAtIndex(index int, val int)  {
    if index > this.size {
        return 
    }
    this.size++
    index = max(index,0)
    if index+1 > this.size/2 {
        eptr := this.tail
        for i:=0;i < this.size-index-1;i++{
            eptr = eptr.prev
        }
        adder := &node{next:eptr,prev:eptr.prev,val:val}
        eptr.prev.next = adder
        eptr.prev = adder
    }else{
        sptr := this.head
        for i:=0;i < index;i++{
            sptr = sptr.next
        }
        adder := &node{next:sptr.next,prev:sptr,val:val}
        sptr.next.prev = adder
        sptr.next = adder
    }
}

func max (a,b int)int{
    if a > b {
        return a
    }
    return b
}

func (this *MyLinkedList) DeleteAtIndex(index int)  {
    if index >= this.size || index <0 {
        return
    }
    if index+1 > this.size/2 {
        eptr := this.tail
        for i:=0;i < this.size-index-1;i++{
            eptr = eptr.prev
        }
        if eptr.prev.prev != nil{
            eptr.prev.prev.next = eptr
        }
        eptr.prev = eptr.prev.prev
    }else {
        sptr := this.head
        for i:=0;i < index;i++{
            sptr = sptr.next
        }
        if sptr.next.next != nil{
            sptr.next.next.prev = sptr
        }
        sptr.next = sptr.next.next
    }
    this.size --
}


/**
 * Your MyLinkedList object will be instantiated and called as such:
 * obj := Constructor();
 * param_1 := obj.Get(index);
 * obj.AddAtHead(val);
 * obj.AddAtTail(val);
 * obj.AddAtIndex(index,val);
 * obj.DeleteAtIndex(index);
 */

翻转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

迭代

思路：双指针（ptr指向当前节点；prev指向ptr的上一个节点），创建next临时节点

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reverseList(head *ListNode) *ListNode {
   var prev *ListNode
   ptr := head
   for ptr != nil{
       next := ptr.Next
       ptr.Next = prev
       prev = ptr
       ptr = next
   }
   return prev
}

递归

注释来自leetcode评论区

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
 // 以链表1->2->3->4->5举例
func reverseList(head *ListNode) *ListNode {
   if head == nil || head.Next == nil{
               /*
                直到当前节点的下一个节点为空时返回当前节点
                由于5没有下一个节点了，所以此处返回节点5
             */
       return head
   }
   //递归传入下一个节点，目的是为了到达最后一个节点
   newHead := reverseList(head.Next)
                   /*
            第一轮出栈，head为5，head.next为空，返回5
            第二轮出栈，head为4，head.next为5，执行head.next.next=head也就是5.next=4，
                      把当前节点的子节点的子节点指向当前节点
                      此时链表为1->2->3->4<->5，由于4与5互相指向，所以此处要断开4.next=null
                      此时链表为1->2->3->4<-5
                      返回节点5
            第三轮出栈，head为3，head.next为4，执行head.next.next=head也就是4.next=3，
                      此时链表为1->2->3<->4<-5，由于3与4互相指向，所以此处要断开3.next=null
                      此时链表为1->2->3<-4<-5
                      返回节点5
            第四轮出栈，head为2，head.next为3，执行head.next.next=head也就是3.next=2，
                      此时链表为1->2<->3<-4<-5，由于2与3互相指向，所以此处要断开2.next=null
                      此时链表为1->2<-3<-4<-5
                      返回节点5
            第五轮出栈，head为1，head.next为2，执行head.next.next=head也就是2.next=1，
                      此时链表为1<->2<-3<-4<-5，由于1与2互相指向，所以此处要断开1.next=null
                      此时链表为1<-2<-3<-4<-5
                      返回节点5
            出栈完成，最终头节点5->4->3->2->1
         */
   head.Next.Next = head
   head.Next = nil
   return newHead
}

双指针递归

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reverseList(head *ListNode) *ListNode {
   return reverse(nil,head)
}

func reverse (prev,head *ListNode) *ListNode {
    if head == nil{
        return prev
    }
    tmp := head.Next
    head.Next = prev
    return reverse(head,tmp)
}

两两交换链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

迭代

思路：衔接虚拟头节点，通过上一个节点prev后两个节点
在这里插入图片描述

1 加上head
/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func swapPairs(head *ListNode) *ListNode {
    dummy := &ListNode{Next:head}
    prev := dummy
    for head != nil && head.Next != nil{
        prev.Next = head.Next
        next := head.Next.Next
        head.Next.Next = head
        head.Next = next
        prev = head
        head = next
    }
    return dummy.Next
}
不带head（推荐）
/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func swapPairs(head *ListNode) *ListNode {
    dummy := &ListNode{Next:head}
    prev := dummy
    for prev.Next != nil && prev.Next.Next != nil{
        node1 := prev.Next
        node2 := prev.Next.Next
        prev.Next = node2
        node1.Next = node2.Next
        node2.Next = node1
        prev = node1
    }
    return dummy.Next
}

递归

思路：
在这里插入图片描述
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func swapPairs(head *ListNode) *ListNode {
    if head == nil || head.Next == nil{
        return head
    }
    one := head
    two := one.Next
    three := two.Next
    two.Next = one
    one.Next = swapPairs(three)
    return two
}

删除链表的倒数第N个节点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

思路：快慢指针，慢指针为dummy，快指针为head，快指针先移动n次，然后移动慢指针，直到快指针为空
时间复杂度O(n),空间复杂度O(1)

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeNthFromEnd(head *ListNode, n int) *ListNode {
    dummy := &ListNode{Next:head}
    fp,sp := head,dummy
    for i:=0;i<n;i++{
        fp = fp.Next
    }
    for ;fp != nil;fp = fp.Next{
        sp = sp.Next
    }
    sp.Next = sp.Next.Next
    return dummy.Next
}

链表相交

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

哈希集合存储

思路：创建一个hashmap，先遍历headA存储全部元素，再去遍历b去尝试命中hashmap，命中返回节点，否则返回nil
空间复杂度O(m)m为headA的长度，时间复杂度为O(m+n) m，n为headA和headB的长度

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func getIntersectionNode(headA, headB *ListNode) *ListNode {
    vis := map[*ListNode]bool{}
    for tmp:=headA;tmp != nil;tmp = tmp.Next{
        vis[tmp] = true
    }
    for tmp:=headB;tmp != nil;tmp = tmp.Next{
        if vis[tmp]{
            return tmp
        }
    }
    return nil
}

双指针

思路：记住链表拼接
存在相同节点：ptrA遍历完a表再遍历b表，步数为a+(b-c),ptrB遍历完b表再遍历a表，步数为b+(a-c),
在这里插入图片描述
不存在相同节点：ptrA：a+b;ptrB:b+a

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func getIntersectionNode(headA, headB *ListNode) *ListNode {
    if headA == nil || headB == nil{
        return nil
    }
    ptrA,ptrB := headA,headB
    for ptrA != ptrB {
        if ptrA == nil{
            ptrA = headB
        }else {
            ptrA = ptrA.Next
        }
        if ptrB == nil{
            ptrB = headA
        }else{
            ptrB = ptrB.Next
        }
    }
    return ptrA
}

环形链表II

题意： 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
说明：不允许修改给定的链表。

哈希表-空间复杂度较高，不推荐

思路：遍历链表，先尝试命中map，如果没有就将元素存储在map里
时间复杂度O（n），空间复杂度O（n）

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func detectCycle(head *ListNode) *ListNode {
    gain := map[*ListNode]int{}
    pos := 0
    for head != nil {
        if _,ok := gain[head];ok {
            return head
        }
        gain[head] = pos
        pos ++
        head = head.Next
    }
    return nil
}

双指针

思路 ，这是快慢指针，快指针速度为2，慢指针速度为1
在这里插入图片描述>第一次相遇时：sp走了 x + y;fp走了x+y+n(z+y)，由此可推算出
2spLength = fpLength -> 2(x+y) = x+y+n(z+y) -> x+y = n(y+z)
-> x = n(y+z) - y -z + z -> x = (n-1)(y+z) + z
(此为简化抽象过程，n可以为随机大于等一1的数字)当n等于0时，x = z

第一次相遇后，将fp重定位到head，以速度为1前进直到再次与sp相遇得出胡那行链表的入口节点

自解版本

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func detectCycle(head *ListNode) *ListNode {
    fp,sp := head,head
    for fp != nil{
        if fp.Next == nil{
            return nil
        }
        fp = fp.Next.Next
        sp = sp.Next
        if fp == sp {
            break
        }
    }
    if fp == nil{
        return nil
    }
    fp = head
    for fp != sp{
        fp = fp.Next
        sp = sp.Next
    }
    return fp
}

标准版本

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func detectCycle(head *ListNode) *ListNode {
    fp,sp := head,head
    for fp != nil{
        if fp.Next == nil{
            return nil
        }
        fp = fp.Next.Next
        sp = sp.Next
        if fp == sp {
            fp = head
            for fp != sp {
                fp = fp.Next
                sp = sp.Next
            }
            return fp
        }
    }
    return nil
}
flowerxxxxx
关注
专栏目录
Golang中List的实现方法示例详解
12-26
前言 为了快速回顾Go基本的语法知识，打算用Go中的基本语法以及特性来实现一些常见的数据结构和排序算法，通过分析如何实现一些基本的数据结构，可以很快学习Go的语法特性。记忆更加深刻，掌握更加迅速。这是我认为学习一门新语言入门最好的方式。这也是方便自己以后需要用Go来写东西的一种前期准备，到时候就不用去翻一些教程了。系列博文的第一篇就从如何实现List开始。 需求 大家都知道基本链表得有以下特性：链表的初始化、链表的长度、节点的插入、删除、查找等一些常见的基本操作，最后写好之后，需要测试。关于测试，我之前写过Go的系列笔记中有叙述，不再重复。 实现 初始化 有语言基础的人都知道，链表是由节
代码随想录day9 KMP算法/golang实现strStr
weixin_42161901的博客
09-29 314
笔记
golang使用链表实现简单list
a1053904672的博客
06-04 663
package main import ( "fmt" ) type Node struct { element int next *Node } type List struct { len int head *Node tail *Node } func LinkList() *List { list:=new(List) tail:=new(Node) list....
golang 链表增加节点时的内存处理
万象博客
09-27 171
package main import "fmt" type chaocai struct{ se string wei string next *chaocai } var head *chaocai var tail *chaocai func test(){ if head!=nil{ // fmt.Println(head) test2:=new(chaocai) test2.se="绿色的" tes
golang常见数据结构之链表
SMILY12138的博客
04-10 344
链表是由若干个节点（Node）组成的数据结构，每个节点都包含了一个数据元素和指向下一个节点的指针。通过这些指针，我们可以在不需要连续内存的情况下将所有的节点链接起来，形成一个完整的链表。在每次循环中，我们打印出当前节点的值，并将指针移动到下一个节点。在Golang中，创建一个链表非常简单，只需要定义一个节点类型，并以此创建一个新的节点即可。这段代码就创建了一个名为head的链表，其中第一个节点的值为1，且其指针为空。这段代码就创建了一个新的值为2的节点，并将其挂载到链表的第二个位置上。
代码随想录刷题汇总
不思考会变草履虫哦
08-11 2985
网站：https://www.programmercarl.com/
【golang 必备算法】链表篇
weixin_45901764的博客
09-28 391
203.移除链表元素 力扣链接 创建一个虚拟头节点 func removeElements(head *ListNode, val int) *ListNode { p:=&ListNode{} p.Next=head q:=p for p!=nil&&p.Next!=nil{ if p.Next.Val==val{ p.Next=p.Next.Next }else{ p=p.Next } } return q.
经典算法-链表（golang）
weixin_34092370的博客
05-13 200
type ListNode struct { Val int Next *ListNode } // 83. Remove Duplicates from Sorted List 删除有序链表中的重复元素 // 解题思路：相同的只改变指针指向，不同的才会移动当前的cur指针，cur作为当前判断的指针 // Input: 1->1->2 Output: 1-...
跟着动画学习 GO 数据结构之 Go 链表
宇宙之一粟的技术漂泊之旅
01-08 282
介绍我们知道 Go 的数组和切片非常方便对数据进行访问，但是假如我们有一个长度为 5 的数组 ​​[1, 2, 3, 4, 5]​​，想要往其中 3 和 4 之间插入一个元素 6，就往往不是非常容易了。为啥呢？一般解决的方法是首先创建一个长度大于 5 的新数组，因为这个数组的长度首先要能存储旧数组的数组，同时能有多余的位置...
golang基础-结构体、结构体链表前后插入、节点添加删除
全干工程师
10-26 7820
结构体 struct 用来自定义复杂数据结构 struct里面可以包含多个字段（属性） struct类型可以定义方法，注意和函数的区分 struct类型是值类型 struct类型可以嵌套 Go语言没有class类型，只有struct类型
GO 语言协程知识点学习笔记
weixin_45582252的博客
10-12 715
Channel 是 Go 协程之间通信的通信管道，如同管道中的谁会从一端流到另一端，通过使用管道，就可以实现数据从管道的一个端口发送，在另外一个端口接收。
golang一个轻量级基于内存的kv存储或缓存
最新发布
yinjl123的博客
10-16 256
基于内存的特性决定了其不需要网络传输其内容，因此就不存在网络耗时。在使用时,一般都是将go-cache作为数据缓存来使用，而不是持久性的数据存储。对于停机后快速恢复的场景，go-cache支持将缓存数据保存到文件，恢复时从文件中load数据加载到内存。go-cache是一个轻量级的基于内存的key:value 储存组件，类似于memcached，适用于在单机上运行的应用程序。它在并发的时候，线程安全(读写锁) + map[string]interface{} + 过期时间 来作为go的本地化存储。
15分钟学Go 第2天：安装Go环境
weixin_40780178的博客
10-16 530
通过本节的学习，你已经成功在Windows 11上安装并配置了Go语言开发环境，包括Go语言本身、VS Code和必要的插件。同时，你还创建并运行了一个简单的Go程序，熟悉了工作流程。接下来，你可以开始深入学习Go语言的基本语法与编程概念。怎么样今天的内容还满意吗？
GO语言指针有那些限制
lisus2007的专栏
10-16 226
GO语言指针类型限制
Go 项目如何集成类似mybatisPlus插件呢？GORM走起!!
童龙辉的博客
10-16 701
Go 项目中，虽然没有像 MyBatis Plus 这样特定的 ORM 插件，但可以使用功能相似的 Go ORM 框架，比如 GORM，它支持链式查询、自动迁移、预加载等功能，与 MyBatis Plus 有相似之处。通过一些插件或扩展，可以实现更丰富的功能，比如软删除、分页查询等
Golang Slice扩容机制及注意事项
yuanlaile的博客
10-12 438
在 Go语言中，Slice（切片）是一种非常灵活且强大的数据结构，它是对数组的抽象，提供了动态数组的功能。Slice 的扩容机制是自动的，但了解其背后的原理对于编写高效、可预测的 Go 程序至关重要。
Go 项目配置的定制化和一体化打包方案
kevin_tech的博客，微信搜「网管叨bi叨」
10-15 556
config在项目中的实现形式多种多样，小成本项目把项目存放在项目自身单独的文件中，文件格式既可以是程序文件，也可以是JSON、YAML这样的静态文件。具有相当大访问量又需要配置能热更新的项目则会使用远程配置中心。本节我们来实现项目的配置的功能。这里我们需要用到一个Go语言写的开源库使用Viper，选用Viper主要原因是支持它支持从项目文件、远端ETCD和Consul中读取配置，兼容性更高一些。...
Go语言依赖注入方式
bocai_xiaodaidai的博客
10-16 171
在Go语言中，依赖注入（Dependency Injection，DI）是一种设计模式，允许你将对象的依赖关系在外部进行管理，而不是让对象自己创建或查找依赖。通俗来说就是把一个对象所需要的东西如方法或属性（统称依赖）从外面传递给它，而不是让这个对象自己去找或实现这些东西。这种模式可以帮助你构建更可维护、可测试的代码。Go语言本身没有像一些面向对象语言（如Java）那样内置的依赖注入框架，但你可以通过多种方式实现依赖注入。
Go语言中的通道 (Channel) 实践：Goroutine之间的通信
dc爱傲雪和技术
10-12 629
在 Go 语言中，通道（Channel）为我们提供了一种优雅的并发编程方式。相比于传统的锁机制，通道通过消息传递来解决多线程间的协作问题，避免了竞争条件和复杂的同步控制。它不仅让代码更易于理解和维护，还提高了程序的性能和可靠性。
Golang双链表实现详解及代码示例
本文档详细介绍了如何在Golang中实现双链表的数据结构。双链表是一种数据结构，其中每个节点包含两个指针，分别指向其前一个节点和后一个节点，这使得数据的插入、删除和遍历更加灵活。在Golang中，我们首先定义了一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值