代码随想录算法训练营第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

你可能感兴趣的:(Leetcode,代码随想录(Python),算法,链表,python)