golang 必备算法链表篇

Posted 2021-09-29 CJ-cooper

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.Next

}

206.反转链表

力扣链接

func reverseList(head *ListNode) *ListNode {

k:=&ListNode{}     //创建一个虚拟头节点
k.Next=nil          //指向nil

for head!=nil{
    p:=head
    head=head.Next  //这步必须要在后面两步，不然链表结构会发生改变
    p.Next=k.Next
    k.Next=p
}

return k.Next

}

24. 两两交换链表中的节点

力扣链接

func swapPairs(head *ListNode) *ListNode {

p:=new(ListNode)
q:=p
for head!=nil&&head.Next!=nil{
    a:=head
    b:=head.Next
    head=b.Next
    a.Next=nil
    b.Next=a
    p.Next=b
    p=a
}
if head!=nil{
    p.Next=head
}
return q.Next
}

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

力扣链接

同样还是用了虚拟节点

func removeNthFromEnd(head *ListNode, n int) *ListNode {

p:=&ListNode{}
p.Next=head
q:=p
t:=p
for i:=0;i<n;i++{
    q=q.Next
}

for q.Next!=nil{
    q=q.Next
    p=p.Next
}
p.Next=p.Next.Next

return t.Next
}

面试题 02.07. 链表相交

力扣链接

• 使用哈希表，将其中一个链表的节点不断添加进去
• 遍历第二个链表，如果在哈希表中找到了节点，则返回节点的数据值

func getIntersectionNode(headA, headB *ListNode) *ListNode {
    
    h:=make(map[*ListNode]int,0)

    for headA!=nil{
        h[headA]++
        headA=headA.Next
    }

    for headB!=nil{
        if h[headB]>0{
            return headB
        }else{
            headB=headB.Next
        }
    }

    return nil

}

142.环形链表II

力扣链接

​ 快慢指针，fast 与 slow。它们起始都位于链表的头部。随后，slow 指针每次向后移动一个位置，而 fast 指针向后移动两个位置。如果链表中存在环，则fast 指针最终将再次与 slow 指针在环中相遇。

可以看出 (a+b)*2 = a+n(b+c)+b

​ a=c+(n-1)(b+c)

因此，当发现 slow 与 fast 相遇时，我们再额外使用一个指针ptr。起始，它指向链表头部；随后，它和 slow 每次向后移动一个位置。最终，它们会在入环点相遇。

func detectCycle(head *ListNode) *ListNode {

    p,q:=head,head
    for q!=nil && q.Next!=nil{
        p=p.Next
        q=q.Next.Next
        if p==q{
            for head!=q{
                head=head.Next
                q=q.Next
                }
            return head
      }   
    }
return nil
}