22年33周

目录

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

二. 删除链表中的第N个节点

三：链表相交

---

---

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

题目链接：两两交换链表中的节点

思路：这道题有两个思路，一个是按部就班的利用遍历链表的方式进行，另外一个思路就是利用递归方式实现，具体代码如下所示：

//普通模式
/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func swapPairs(head *ListNode) *ListNode {
    if head == nil {//空节点
        return nil
    }

    if head.Next == nil {//只有一个节点
        return head
    }

    pre := head
    pre = nil
    mid := head
    rear := head.Next

    result := rear//新链表的头节点
    for rear != nil {//只要rear不等于空，就说明构成了偶数个节点
        mid.Next = rear.Next
        rear.Next = mid

        if pre != nil {
            pre.Next = rear
        }
        pre = mid

        if mid.Next != nil && mid.Next.Next != nil {
            mid = mid.Next
            rear = mid.Next
        }else {
            return result
        }
    }

    return result
}

// 递归版本
func swapPairs(head *ListNode) *ListNode {
    if head == nil || head.Next == nil {
        return head
    }
    next := head.Next
    head.Next = swapPairs(next.Next)
    next.Next = head
    return next
}

二. 删除链表中的第N个节点

题目链接：删除链表的倒数第N个节点
 

思路：典型的快慢指针解法。

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeNthFromEnd(head *ListNode, n int) *ListNode {

    fast := head
    slow := head
    for n > 0 {
        n--
        fast = fast.Next
    }

    if fast == nil {//防止删除的是第一个节点
        return head.Next
    }
    for fast.Next != nil {
        fast = fast.Next
        slow = slow.Next
    }
    slow.Next = slow.Next.Next
    return head
}

三：链表相交

题目链接：链表相交

思路：还是快慢指针法

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func getIntersectionNode(headA, headB *ListNode) *ListNode {
    sizeA, sizeB := 0,0
    ptrA,ptrB := headA,headB

    for ptrA != nil {
        ptrA = ptrA.Next 
        sizeA++
    }

    for ptrB != nil {
        ptrB = ptrB.Next 
        sizeB++
    }
    fast,slow := headA,headB
    gap := sizeA - sizeB
    
    if gap < 0 {
        gap = -gap
        fast = headB
        slow = headA
    }

    for gap > 0 {
        fast = fast.Next
        gap--
    }

    for fast != nil && slow != nil {
        if fast == slow {
            return fast
        }
        fast = fast.Next
        slow = slow.Next
    }
    return nil
}