1.移除链表元素

203. 移除链表元素

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

示例1

输入： head = [1,2,6,3,4,5,6], val = 6
输出： [1,2,3,4,5]

示例2

输入： head = [], val = 1
输出： []

解法

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeElements(head *ListNode, val int) *ListNode {
    newNode:=&ListNode{} // 添加头结点，是为了把当前的头结点做统一处理
    newNode.Next=head
    p:=newNode
    for p!=nil  && p.Next!=nil {
        if p.Next.Val==val{
            p.Next=p.Next.Next // 删除目标节点，p指向目标节点的前一个节点
        }else{
            p=p.Next
        }
    }
    return newNode.Next
}

2.翻转链表

206. 反转链表

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

示例1

输入： head = [1,2,3,4,5]
输出： [5,4,3,2,1]

示例2

输入： head = [1,2]
输出： [2,1]

解法一

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reverseList(head *ListNode) *ListNode {
    var pre *ListNode
    cur:=head
    for cur!=nil{
        next:=cur.Next // 记忆cur节点的下一个节点，因为下述改变cur指向会丢失剩余链表
        cur.Next=pre // 改变cur节点的next指向
        pre=cur // 指针移动
        cur=next 
    }
    return pre
}

解法二

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reverseList(head *ListNode) *ListNode {
    var pre *ListNode
    return reverse(pre,head) // 使用递归
}

func reverse(pre *ListNode, cur *ListNode) *ListNode{
    if cur==nil{
        return pre
    }
    next:=cur.Next
    cur.Next=pre
    return reverse(cur,next) // 更换pre和cur节点
}

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

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

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

示例1

输入： head = [1,2,3,4]
输出： [2,1,4,3]

示例2

输入： head = []
输出： []

解法

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func swapPairs(head *ListNode) *ListNode {
    dummy:=&ListNode{} // 添加头结点，使得当前头结点做统一处理
    dummy.Next=head
    cur:=dummy
    for cur.Next!=nil && cur.Next.Next!=nil{
        temp1:=cur.Next // 暂存节点，防止丢失
        temp2:=cur.Next.Next.Next // 暂存节点，防止丢失
        cur.Next=cur.Next.Next
        cur.Next.Next=temp1
        cur.Next.Next.Next=temp2
        cur=cur.Next.Next
    }
    return dummy.Next
}

4.删除链表的倒数第 N 个结点

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

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

示例1

输入： head = [1,2,3,4,5], n = 2
输出： [1,2,3,5]

示例2

输入： head = [1], n = 1
输出： []

解法

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeNthFromEnd(head *ListNode, n int) *ListNode {
    if head==nil{
        return nil
    }
    dummy:=&ListNode{}
    dummy.Next=head
    fast:=dummy
    for i:=0;i<=n;i++{ // 使得slow指向目标节点的前一个节点
        fast=fast.Next 
    }
    slow:=dummy
    for fast!=nil{
        slow=slow.Next
        fast=fast.Next
    }
    slow.Next=slow.Next.Next
    return dummy.Next
}

5.链表相交

面试题 02.07. 链表相交

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

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

示例1

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例2

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

解法

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func getIntersectionNode(headA, headB *ListNode) *ListNode {
    lenA,lenB:=0,0
    p1,p2:=headA,headB
    for p1!=nil {
        p1=p1.Next
        lenA++
    }
    for p2!=nil{
        p2=p2.Next
        lenB++
    }
    p1,p2=headA,headB
    if lenA>lenB{
        dis:=lenA-lenB
        for i:=0;i<dis;i++{
            p1=p1.Next
        }
    }else{
        dis:=lenB-lenA
        for i:=0;i<dis;i++{
            p2=p2.Next
        }
    }
    for p1!=nil && p2!=nil{
        if p1==p2{
            return p1
        }else{
            p1=p1.Next
            p2=p2.Next
        }
    }
    return nil
}

6.环形链表

142. 环形链表 II

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例1

输入： head = [3,2,0,-4], pos = 1
输出： 返回索引为 1 的链表节点
解释： 链表中有一个环，其尾部连接到第二个节点。

示例2

输入： head = [1,2], pos = 0
输出： 返回索引为 0 的链表节点
解释： 链表中有一个环，其尾部连接到第一个节点。

解法一

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func detectCycle(head *ListNode) *ListNode {
    nodeMap:=make(map[*ListNode]struct{}) // 有环说明有重复，因此考虑map结构
    p:=head
    for p!=nil {
        if _,ok:=nodeMap[p];ok{
            return p
        }else{
            nodeMap[p]=struct{}{}
            p=p.Next
        }
    }
    return nil
}

解法二

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func detectCycle(head *ListNode) *ListNode {
    fast,slow:=head,head
    for fast!=nil && fast.Next!=nil {
        fast=fast.Next.Next
        slow=slow.Next
        if slow==fast{
            p1:=head
            p2:=fast
            for p1!=p2{
                p1=p1.Next
                p2=p2.Next
            }
            return p1
        }
    }
    return nil
}