[Python-链表刷题]删除链表的倒数第 N 个结点、链表相交

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 链表中结点的数目为 sz

• 1 <= sz <= 30

• 0 <= Node.val <= 100

• 1 <= n <= sz

解题思路

        做这个题之前我们不妨先想想之前删除节点是怎么做的，之前删除某个位置的节点时，我们是通过计数的方式找到删除节点的位置，然后跳过节点实现的。这道题其实本质上也一样，需要一个遍历的指针，当这个指针到了某个位置时跳过需要删除的节点即可。只不过删除的位置这次不是顺序的，而是倒序的了。

        该如何解决呢？题目只告诉了我们要删除倒数第n个节点，那么我们是不是可以新建一个节点单纯用来遍历链表呀，当这个节点指到None时链表结束，这时候只需要找到距离这个节点为n的那个位置然后跳过是不是就可以了。因此，我们可以设置两个节点，一个cur节点，单纯用于遍历完链表；一个pre节点，需要进行计数，当pre节点与cur节点的距离为n时，pre节点也开始遍历，这样cur指向None的时候，pre节点正好指向需要删除的节点的前一个位置。

        具体思路如下图所示，以删除倒数第二个节点为例：

        先是将pre指针设置在虚拟头节点的位置，cur指针设置在头节点的位置，当两者的距离大于n时，pre也开始遍历，此时当cur指向None，pre就指到了需要删除节点的前一个位置，只需要跳过该节点即可完成。

        当然，这种方法并不能考虑到所有情况，当需要删除链表的第一个元素时，pre就已经落在了第一个元素上，因此这个特殊情况我们特殊处理，可以在遍历过程中检测cur落到None时的cnt是否等于n，如果是，就说明需要删除第一个节点，直接返回虚拟头节点的next的next即可；而当要删除倒数第一个节点时，没法跳过怎么办，直接另pre的next等于None即可。

        因此，代码如下：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head, n):
        dummy = ListNode() #虚拟头节点
        dummy.next = head
        #特殊情况
        if not head.next:
            return None
​
        cnt = 0 #计数器，用于判断什么时候出现pre指针，pre指针用于删除节点
        cur_Node = head #用作遍历的指针
        pre_Node = dummy #pre节点一开始也指向头节点，只不过先不移动
        #把cur为空作为循环终止的条件
        while cur_Node:
            cnt += 1
            cur_Node = cur_Node.next
            if cnt > n:
                pre_Node = pre_Node.next
            if cnt <= n and not cur_Node:
                return dummy.next.next
​
        if pre_Node.next:
            pre_Node.next = pre_Node.next.next
        else:
            pre_Node.next = None
​
        return dummy.next

面试题 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 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

提示：

• listA 中节点数目为 m

• listB 中节点数目为 n

• 0 <= m, n <= 3 * 104

• 1 <= Node.val <= 105

• 0 <= skipA <= m

• 0 <= skipB <= n

• 如果 listA 和 listB 没有交点，intersectVal 为 0

• 如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]

解题思路

        这个题也很有意思，给我们两个链表，需要找到两个链表中相同的一个节点，这个节点就是两链表交汇的地方。

        我们可以这样考虑，由于两个链表的长度不一定一致，而且较长的链表多出来的那部分肯定不会有与较短链表相同的节点的，因为都是从头开始遍历。所以我们可以将两个链表的尾部对齐，找到两个链表开始长度相同的位置，从这个位置开始同步遍历，指到找到相同节点为止，如下图：

        这里假设两链表在节点3的位置交汇。

        而两个链表没有交汇的节点时，就是遍历的指针指向空都没有相等的节点的情况。由以上思路可得代码如下：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
​
class Solution:
    def getIntersectionNode(self, headA, headB):
        #两个指针指向两个链表的头节点
        cur_A = headA 
        cur_B = headB
        len_A = 0
        len_B = 0
        cnt = 0 #计数器
        #求两链表的长度
        while cur_A :
            len_A += 1
            cur_A = cur_A.next
        while cur_B :
            len_B += 1
            cur_B = cur_B.next
        #复位
        cur_A = headA 
        cur_B = headB
        #找到两链表尾部对齐时的位置
        if len_A > len_B:
            while len_A - len_B:
                len_A -= 1
                cur_A = cur_A.next
        else:
            while len_B - len_A:
                len_B -= 1
                cur_B = cur_B.next
        #同步遍历，找到相同的节点即为相交处
        while cur_A and cur_B:
            if cur_A == cur_B:
                return cur_A
            else:
                cur_A = cur_A.next
                cur_B = cur_B.next
​
        return None

        代码中，先对两个链表求长度，然后分情况找到尾部对齐，两链表长度开始相等的位置。随后设置两个节点同步开始遍历，如果遇到节点相同的情况直接返回节点即可，反之返回None。

        至此，关于链表的刷题就告一段落了，之后有时间再多做做其他类型的链表题目，下面准备开始有关字符串操作的学习。