代码随想录算法训练营第四天--两两交换链表中的节点、删除链表的倒数第N个节点、链表相交、环形链表II

两两交换链表中的节点

力扣题目链接(opens new window)

题目描述：

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

举例：

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

思路：虚拟头节点

（1）定义虚拟头结点pre_node，指向head，对元素1和元素2做处理，让curr = pre_node指向元素2，元素2指向元素1，元素1指向元素3，这样的话，元素2和元素3的指向会断开，元素1和元素2之间的指向发生变化，因此在操作之前，先用临时变量存储断开的那两部分链表，具体操作如下：

a. 通过temp1存储元素1，temp1= curr.next
b. 通过temp3 存储元素3，temp3 = curr.next.next.next
c. 使curr指向元素2，curr.next = curr.next.next
d. 此时curr指向了元素2，让元素2指向元素1，curr.next.next = temp1
e. 此时curr.next.next指向了元素1，让元素1指向元素3，curr.next.next.next = temp3

（2）循环步骤1，curr移动两个节点，curr = curr.next.next

注意：curr永远停留在两两元素的上一个，然后对两两元素进行处理，因此循环终止条件：curr是最后的一个奇数位尾节点，也就是curr.next 为空，或者偶数位长度，curr.next.next为空

# 给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
def swapPairs(head: Optional[ListNode]) -> Optional[ListNode]:
    pre_node = ListNode()
    pre_node.next = head
    curr = pre_node
    while curr.next and curr.next.next:
        temp1= curr.next
        temp3 = curr.next.next.next
        curr.next = curr.next.next
        curr.next.next = temp1
        curr.next.next.next = temp3
        curr = curr.next.next
    return pre_node.next

# 打印
def printList(res):
    while res:
        print(res.val, end='->' if res.next else '')
        res = res.next
 # 调用
res = swapPairs(ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5))))))
printList(res)

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

力扣题目链接(opens new window)

题目描述：

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

举例：

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

输出：[1,2,3,5]

思路：怎么找到倒数第N个结点？--双指针

（1）快指针比慢指针快N+1个结点，然后快慢指针一起移动

（2）当快指针移动到链表末尾时，再循环一次，快指针变成None，慢指针走到倒数第N个结点的上一个结点

（3）删除倒数第N个结点

# 删除链表的倒数第 N 个结点
# 给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
# 输入：head = [1,2,3,4,5], n = 2
# 输出：[1,2,3,5]
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def removeNthFromEnd(head: Optional[ListNode], n: int) -> Optional[ListNode]:
    pre_node = ListNode()
    pre_node.next = head
    fast_node = pre_node
    slow_node = pre_node
    n += 1
    while fast_node and n > 0:
        fast_node = fast_node.next
        n -= 1
    while fast_node:
        slow_node = slow_node.next
        fast_node = fast_node.next
    slow_node.next = slow_node.next.next
    return pre_node.next

# 打印
def printList(res):
    while res:
        print(res.val, end='->' if res.next else '')
        res = res.next

# 调用
res = removeNthFromEnd(ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5))))),2)
printList(res)

链表相交

力扣题目链接(opens new window)

题目描述：

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

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

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

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

思路：双指针

（1）获取两个链表的长度，通过让长链表的指针移动到和短链表一样的长度的位置

（2）此时，长短链表的剩余未遍历长度相等，同时进行遍历，当结点相等的时候，链表相交，返回结点

# 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
class ListNode:
    def __init__(self,val=0,next=None):
        self.val = val
        self.next = next


def getIntersectionNode(headA: ListNode, headB: ListNode) -> ListNode:
    def getListLength(head):
        length = 0
        while head:
            head = head.next
            length += 1
        return length

    lengthA = getListLength(headA)
    lengthB = getListLength(headB)
    n = abs(lengthA - lengthB)
    if lengthA >= lengthB:
        while n:
            headA = headA.next
            n -= 1
        while headA:
            if headA == headB:
                return headA
            headA = headA.next
            headB = headB.next
        return None
    else:
        while n:
            headB = headB.next
            n -= 1
        while headA:
            if headA == headB:
                return headA
            headA = headA.next
            headB = headB.next
        return None

环形链表II

力扣题目链接(opens new window)

题意：

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

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

举例：

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

思路：双指针+判断环的首结点的算法

（1）通过快指针每次移动2个，慢指针每次移动1个，直到快指针等于慢指针，说明相遇，是环链表，记录此时的结点为index1

（2）注意：通过算法分析，相遇后的结点，到环首结点的距离（z）==链表首结点到环首结点的距离(x)，head结点和index1结点同时移动，直到二者相等，说明相遇，此时的结点是环的首结点。

为什么相遇后的结点，到环首结点的距离==链表首结点到环首结点的距离？ 

假设环首结点到相遇结点的距离是y，相遇结点到环首结点的距离是z，链表首结点到环首结点的距离是x，slow指针进环之后，slow指针必然在一圈内被快指针追上相遇

slow走过的距离是：x+y

quick走过的距离是：x+n（y+z）+y ，n代表快指针在圈内转圈的次数

2*(x+y) = x+n（y+z）+y

移项后，x = (n-1)(y+z) +z , 其中y+z是一个环的长度

说明，相遇之时，快指针经历了n圈后，到达相遇点之时，x=z，以此条件来确定环首结点的位置

# 给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
def detectCycle(head: Optional[ListNode]) -> Optional[ListNode]:
    slow_node = head
    quick_node = head
    # 判断是否是环链表,快指针在前，终止条件判断快指针即可
    while quick_node and quick_node.next:
        slow_node = slow_node.next
        quick_node = quick_node.next.next
        # slow == quick ,说明快慢指针相遇，是环链表
        if slow_node == quick_node:
            index1 = quick_node
            index2 = head
            while index1 != index2:
                index1 = index1.next
                index2 = index2.next
            # 找到环的开始节点
            return index1
    return None