代码随想录算法训练营第四天 | 24. 两两交换链表中的节点、19.删除链表的倒数第N个节点、面试题 02.07. 链表相交、142.环形链表II

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

类型： #链表
难度：中等
题目：给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
思路：图源代码随想录，初始 dHead 指向虚拟头节点，分三步操作

之后链表如下

然后更新一下 pre 和 head 对应位置

实现：

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func swapPairs(head *ListNode) *ListNode {
    dHead := &ListNode{
        Next: head,
    }
    pre := dHead
    for head != nil && head.Next != nil{
        pre.Next = head.Next
        temp := head.Next.Next
        head.Next.Next = head
        head.Next = temp

        pre = head
        head = temp
    }
    return dHead.Next
}

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

类型： #链表
难度：中等
题目：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
思路：用双指针。快慢初始指向虚拟节点，然后快先走 n+1，然后慢再开始走。等到快走完了，慢指向的刚好是倒 n 个节点的前一个节点，直接跳过就好了。

代码随想录图如下：

实现：

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeNthFromEnd(head *ListNode, n int) *ListNode {
    dHead := &ListNode{}
    dHead.Next = head
    cur := dHead
    pre := dHead
    i := 0
    for cur != nil{
        cur = cur.Next
        if i > n{
            pre = pre.Next
        }
        i++
    }
    pre.Next = pre.Next.Next
    return dHead.Next
}

面试题 02.07. 链表相交

类型： #链表
难度：简单
题目：给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
思路：先求出各自长度 lenA 和 lenB，以计算出长度差 step。同时分别定义长链表和短链表指向头节点的指针 long 和 short，并让 long 先走 step 步，以让两个指针尾端对齐。之后去找是否有相交节点并返回就好。

代码随想录图片：

实现：

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func getIntersectionNode(headA, headB *ListNode) *ListNode {
    curA := headA
    curB := headB
    lenA, lenB := 0, 0
    for curA != nil{
        curA = curA.Next
        lenA++
    }
    for curB != nil{
        curB = curB.Next
        lenB++
    }

    var step int
    var long, short *ListNode
    if lenA > lenB{
        long = headA
        short = headB
        step = lenA - lenB
    }else{
        long = headB
        short = headA
        step = lenB - lenA
    }

    for i := 0; i < step; i++{
        long = long.Next
    }

    for long != short{
        long = long.Next
        short = short.Next
    }

    return long
}

142.环形链表II

类型： #链表
难度：中等
题目：给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 _如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。
思路：快指针走两步，慢指针走一步。当快慢指针相遇时，慢指针和头指针一起走，当慢指针与头指针相遇时，返回头节点

实现：

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