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

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

题目链接/文章讲解/视频讲解： https://programmercarl.com/0024.%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B9.html

• 考点
  • 虚拟头节点
  • 三节点交换（需要两个临时变量）
• 我的思路
  • 无思路
• 视频讲解关键点总结
  • 首先定义虚拟头节点，并设置cur变量指向虚拟头节点，因为想要交换后两个节点需要有后两个节点的前一个节点
  • 进行循环遍历，循环判断条件分为链表为奇或为偶的情况分别讨论，当链表为偶的时候，移动到最后一轮结束时cur的next应该为None；当链表为奇的时候，移动到最后一轮结束时cur的next的next应该为None；因此，设定判断条件为两个条件均不满足时才继续循环
  • 循环体内，进行三变量交换（需要两个临时变量））
  • 首先改变cur节点的next指向为cur.next.next，因此在此之前，要用临时变量temp储存cur节点的next，再修改其指向为cur.next.next
  • 之后改变cur.next的next指向为temp，在此之前，要先用临时变量temp1存储cur.next.next，再修改cur.next.next为temp
  • 再让temp指向temp1，交换结束
  • 最后把cur向后移动两位为temp，循环结束
• 我的思路的问题
  • 遇到新的问题，先找到一个一般情况，之后具体分析
  • 遇到新的问题不敢尝试，其实想到了虚拟头节点和三变量交换需要两个临时变量
• 代码书写问题
  • 无
• 可执行代码

class Solution(object):
    def swapPairs(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        dummy_head = ListNode(next=head)
        cur = dummy_head
        while cur.next is not None and cur.next.next is not None:
            temp = cur.next
            cur.next = cur.next.next
            temp1 = cur.next.next
            cur.next.next = temp
            temp.next = temp1
            cur = temp
        return dummy_head.next

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

题目链接/文章讲解/视频讲解：https://programmercarl.com/0019.%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E7%9A%84%E5%80%92%E6%95%B0%E7%AC%ACN%E4%B8%AA%E8%8A%82%E7%82%B9.html

• 考点
  • 双指针
• 我的思路
  • 由于删除一个节点，首先需要找到它的上一个节点，因此先设定dummy_node来使得head节点和后续节点操作一致
  • 首先要找到链表的最后一个节点，因此需要一个变量last来进行链表遍历（初始化为dummy_node）
  • 但是单向链表走不了回头路，因此找到最后一个节点之后没办法向回走n步来删除节点，因此需要另一个变量last_n（初始化为dummy_node），该变量和last保持n的距离，用来删除倒数第N个节点
  • 之后开始循环，循环的判断条件是last.next是否为None，保证last遍历到最后一个节点
    • 循环内兵分两路，由于last_n和last应该保持n的距离，所以在last走完n步之前，last_n应该不动
    • 因此用一个if判断n是否为0，不为0，只把last = last.next，而不动last_n，且n -= 1
    • 当n减完，开始同步动last和last_n直到last走到最后一个节点，此时last_n刚好走到倒数第N个节点的前一个节点
  • 循环结束，开始执行删除操作，由于初始链表可能为空，因此这里用一个last_n.next = last_n.next.next if last_n.next is not None else None来保证正确性
  • 最后返回dummy_node.next头节点
• 视频讲解关键点总结
  • 和我的思路相同
• 我的思路的问题
  • 无
• 代码书写问题
  • 无
• 可执行代码

class Solution(object):
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        dummy_node = ListNode(next=head)
        last = dummy_node
        last_n = dummy_node
        while last.next is not None:
            if n != 0:
                n -= 1
                last = last.next
                continue
            last_n = last_n.next
            last = last.next
        last_n.next = last_n.next.next if last_n.next is not None else None
        return dummy_node.next

面试题 02.07. 链表相交（对应力扣160题）

题目链接/文章讲解：https://programmercarl.com/%E9%9D%A2%E8%AF%95%E9%A2%9802.07.%E9%93%BE%E8%A1%A8%E7%9B%B8%E4%BA%A4.html

• 考点
  • 重点在于审准题意
  • 题目考察的是链表相交，也就是后续两个链表完全相同
  • 意味着交点之后的两个链表长度一定相同
• 我的思路
  • 我审题没审好，错误判断成了两个节点数值相同
  • 两层循环，外层循环遍历链表1，内存循环遍历链表2
  • 相当于穷举出所有的两两组合，之后判断二者值是否相等，相等则返回当前节点
• 视频讲解关键点总结
  • 无视频，只有文字版
  • 重点在于，链表相交代表的是交点指针相同（内存地址相同）且后续两个链表完全相同
  • 因此，交点后两个链表一定等长
  • 首先，遍历统计两个链表的长度
  • 之后，找到更长的链表，定义cur节点变量指向头节点，将其向后移动二者长度的差值，使得两个链表的cur指针后的节点数相同
  • 之后依次比较两个链表的cur指针，如果相同则返回，否则一直同步遍历到两个链表的末尾
• 我的思路的问题
  • 没审好题意
• 代码书写问题
  • 无
• 可执行代码

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        cur_a = headA
        cur_b = headB
        a = 0
        b = 0
        while cur_a is not None:
            a += 1
            cur_a = cur_a.next
        while cur_b is not None:
            b += 1
            cur_b = cur_b.next
        cur_a = headA
        cur_b = headB
        if a > b:
            diff = a - b
            while diff:
                cur_a = cur_a.next
                diff -= 1
            while cur_a is not None:
                if cur_a == cur_b:
                    return cur_a
                cur_a = cur_a.next
                cur_b = cur_b.next
        else:
            diff = b - a
            while diff:
                cur_b = cur_b.next
                diff -= 1
            while cur_a is not None:
                if cur_a == cur_b:
                    return cur_a
                cur_a = cur_a.next
                cur_b = cur_b.next
        return None

*142.环形链表II

题目链接/文章讲解/视频讲解：https://programmercarl.com/0142.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8II.html

• 考点
  • 环形链表
  • 链表是否有环（双指针）
  • 有环的话，怎么找环的起点
• 我的思路
  • 无思路
• 视频讲解关键点总结
  • 是否有环
    • 双指针
    • 快指针每次向后走两个节点
    • 慢指针每次向后走一个节点
    • 这样保证快指针每次相对慢指针走一个节点，也就不会出现跳过慢指针的情况
    • 如果有环，二者在遍历过程一定会相等，相等时则代表有环
  • 有环，如何判断环的第一个节点
    • 法一，数学逻辑法，几个关键点：
      • 一、快慢节点一定在环内相遇
      • 二、快慢节点第一次相遇时，快节点一定比慢节点至少多走了一遍环。因此可以列出来等式，2倍的慢节点走过的路程（2 * （第一个环节点前的节点数x+环里走过的节点数y））等于快节点走过的路程（第一个环节点前的节点数x+多走的n环里总共的节点数n*z+第n+1圈在环里走过的节点数y），约分后得到，x = （z-y） + nz，其中z-y代表快慢指针第一次相遇时环里还剩的节点数
      • 定义两个指针，指针1指向头节点，指针2指向当前相遇位置的节点；让指针1走过x个节点，即达到环的第一个节点；同时让指针2走过（z-y） + nz个节点，即先走完当前环到达环的第一个节点，之后再走n圈；由于上面推得x = （z-y） + nz，因此二者实际上遍历了相同的轮次，此时当二者同时遍历完后，它们将相交于环的第一个节点，此时直接返回当前节点即为所求
    • 法二，暴力哈希表（集合）法
      • 这道题如果用法一实在想不明白，可以用暴力解法，即把遍历过的节点都加入一个集合，之后如果发现二次遍历到了该节点，则有环，且当前节点为环的第一个节点
      • 这种解法之所以要使用集合，是因为集合这种哈希表式的结构在查询元素时的时间复杂度为O（1），可以很好地压缩整体算法的执行时间，保证满足力扣的运行时间要求
• 我的思路的问题
  • 第一次接触，没有思路
• 代码书写问题
  • 无
• 可执行代码

class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head == None:
            return None
        cur_fast = head
        cur_slow = head
        while cur_fast.next is not None and cur_fast.next.next is not None:
            cur_fast = cur_fast.next.next
            cur_slow = cur_slow.next
            if cur_slow == cur_fast:
                cur = head
                while cur != cur_slow:
                    cur = cur.next
                    cur_slow = cur_slow.next
                return cur
        return None