代码随想录Day4 | 链表四连击

两辆交换链表中的节点

初次写的算法是下面注释掉的部分，后来发现有链表的位置没改对，又增加了pre节点，事实证明，还是要把流程理清才能写好好的代码

func swapPairs(head *ListNode) *ListNode {
    if head == nil || head.Next == nil {
        return head
    }
    var temp, pre, next *ListNode
    temp = &ListNode{Next: head}
    pre = temp
    for head != nil && head.Next != nil {
        next = head.Next
        head.Next = next.Next
        pre.Next = next
        next.Next = head
        pre = head
        head = head.Next
    }
    return temp.Next
}

// for head != nil && head.Next != nil {
//     next = head.Next
//     head.Next = next.Next
//     next.Next = head
//     head = head.Next
// }

删除链表中倒数第n个节点

超简单的一道题，先往后移动一下就好了

func removeNthFromEnd(head *ListNode, n int) *ListNode {
    pre := &ListNode{Next: head}
    fast, slow := pre, pre
    for i := 0; i < n ; i++ {
        fast = fast.Next
    }
    for fast.Next != nil {
        fast = fast.Next
        slow = slow.Next
    }
    slow.Next = slow.Next.Next
    return pre.Next
}

链表相交

这种题还是用哈希比较快乐，不过做了好几次了，自己写了一下双指针交换移动的算法，感觉写的有点烂，但是这个方法真的很巧妙

func getIntersectionNode(headA, headB *ListNode) *ListNode {
    a, b := headA, headB
    for a != nil && b != nil {
        a, b = a.Next, b.Next
    }
    if a == nil {
        a = headB
    } else {
        b = headA
    }
    for a != nil && b != nil {
        a, b = a.Next, b.Next
    }
    if a == nil {
        a = headB
    } else {
        b = headA
    }
    for a != nil && b != nil {
        if a == b {
            return a
        }
        a, b = a.Next, b.Next
    }
    return nil
}

环形链表

这道题也是，用哈希不快乐吗，不过还是选择用了双指针，也写过好几次了，这个数学原理每理清，面试官如果问到，我可能要手推一下

func detectCycle(head *ListNode) *ListNode {
    if head == nil {
        return head
    }
    fast, slow := head, head
    for fast.Next != nil {
        slow = slow.Next
        fast = fast.Next
        if fast.Next != nil {
            fast = fast.Next
        }
        if slow == fast {
            break
        }
    }
    if fast.Next == nil {
        return nil
    }
    fast = head
    for fast != slow {
        fast, slow = fast.Next, slow.Next
    }
    return slow
}