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

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

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

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

由于今天赶时间，第一眼看完题目没思路就直接看文字解析了，但还是复述一下看完之后自己的理解/想法/思路。

这一题感觉对自己来说还算比较难，虽然知道过程，但是在具体实现的时候，需要多少个变量存储节点感觉非常的混乱，即使先看了一边解析，现在要闭卷实现代码感觉也有点吃力，个人感觉递归的思路倒是更加好理解。

首先排除特殊的情况，无节点和单节点链表直接返回即可。

然后是正常情况，都是大于等于2的节点个数的链表，所以可以将每两个节点抽象合并成一个大节点来看，每个大节点其实就是一次递归，递归需要一个参数head，在大节点中的操作就是令pre=head（head指传入函数的这个节点），递归过程就是：

①与前面的判断条件一致，其实大节点内应该也需要排除特殊情况，无节点和单节点链表直接返回，不进入以下过程。

②首先记录【该大节点之后】的【小节点】（这个小节点有可能为空，如果不为空不意味着他是真正被指向的节点，只是用来给tem存放位置的，便于递归调用函数的时候作为参数传入，因为递归函数应该是从【大节点内的前节点pre】开始进行操作的）；

③然后大节点内的两个节点指向交换位置，即cur.next=pre, pre.next=【tem】（这里的tem用【】标识是因为这个tem只是记录了位置，实际被指的节点应该是递归返回的节点，即下一个【大节点】执行递归之后返回的节点；

④完成了以上过程后递归函数的返回值是cur，因为cur与pre进行了交换，所以返回的头节点应该是cur。

尽可能用自己的语言复述了一遍，加深了自己的理解，如果有坚持看到这但是没看懂的同学还是建议直接代码随想录看卡哥！https://www.bilibili.com/video/BV1YT411g7br

代码实现：（根据以上过程一步一步写，一次过，两分钟速通，递归nb）

# Definition for singly-linked list.

# class ListNode:

#     def __init__(self, val=0, next=None):

#         self.val = val

#         self.next = next

class Solution:

    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:

        if not head or not head.next:

            return head                                # ①

        tem = head.next.next                           # ②

        pre = head

        cur = head.next



        cur.next = pre                                 # ③

        pre.next = self.swapPairs(tem)



        return cur                                     # ④

但看了视频，正经的思路的递归的思路其实是殊途同归的，只不过递归是反着来，正经思路是正着进行循环判断，我自己个人是先理解了递归再来理解循环感觉更好理解一点，今天时间不多就不自己实现了，附上规范代码供日后学习：

# Definition for singly-linked list.# class ListNode:#     def __init__(self, val=0, next=None):#         self.val = val#         self.next = next

class Solution:

    def swapPairs(self, head: ListNode) -> ListNode:

        dummy_head = ListNode(next=head)

        current = dummy_head

       

        # 必须有cur的下一个和下下个才能交换，否则说明已经交换结束了

        while current.next and current.next.next:

            temp = current.next # 防止节点修改

            temp1 = current.next.next.next

           

            current.next = current.next.next

            current.next.next = temp

            temp.next = temp1

            current = current.next.next

        return dummy_head.next

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

给你一个链表，删除链表的倒数第 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]

这个思路非常巧妙，第一眼没想到，但是第二眼看到文字解析一点就通，思路为快慢双指针，令这两个指针距离n步，并且以同速度往前平移（相对距离一直为n），这样的话在快指针到达尾部时，慢指针刚好就距离尾部n步，也就达到了倒数第n个目的。由于为了便于做删除操作，设置一个虚头部节点，所以实际在实现的时候，慢指针应该从虚头部节点开始，实际与快指针距离（n+1）步，在删除操作的时候执行删除慢指针的下一个节点。

实现如下：

# 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: Optional[ListNode], n: int) -> Optional[ListNode]:
       dummyhead = ListNode(next=head)
       slow, fast = dummyhead, dummyhead
       for i in range(n + 1):  # 间隔步长为n+1
           fast = fast.next
       # while fast.next:       # 实例为[1]的时候，空节点没有next属性
       while fast:
           slow = slow.next
           fast = fast.next
       slow.next = slow.next.next

       # return head            # 实例为[1]的时候 head可能被删除，这个head无法返回
       return dummyhead.next

02.07. 链表相交

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

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

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

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

示例 1：

示例 2：

示例 3：

由于有前面快慢指针的提示，这一题的思路也就呼之欲出了，主要思路就是让长的链表和短的链表【作差】，作差的目的是算出长短链表之间的差，令在长链表的指针先走这个差值的距离，在短链表的指针从头开始出发，这样就能确保两者与交点的距离是相等的，只要两指针同速度往前平移，当指针相等时即在交点上。

代码实现如下：

# Definition for singly-linked list.

# class ListNode:

#     def __init__(self, x):

#         self.val = x

#         self.next = None



class Solution:

    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:

        lenA = lenB = 0

        # temA = ListNode(next=headA)

        # temB = ListNode(next=headB)

        temA = headA

        temB = headB

        # while temA.next:

        while temA:

            lenA += 1

            temA = temA.next

        # while temB.next:

        while temB:

            lenB += 1

            temB = temB.next

        curA = headA

        curB = headB

        if lenA > lenB:

            for i in range(lenA - lenB):

                curA = curA.next

        else:

            for i in range(lenB - lenA):

                curB = curB.next

        while curA:

            if curA == curB:

                return curA

            else:

                curA = curA.next

                curB = curB.next



        return None

一开始还是习惯性建立了虚头部节点，感觉还是用的生硬了，遇到这类题目下意识就用了虚部头节点，恰恰这一题其实完全没必要，后面改回了直接令cur=head。

这一题由于过于自信，直接敲没有debug，在计算长度的时候忘记令cur=cur.next，运行代码时一直报超出时间限制，我就非常不服，一直以为是自己代码哪里写的不好，没想到是直接有bug。。这也是需要反思的，还是老老实实IDE运行过一次再提交吧，思路和规范代码一致，不贴出来了，题解里还有很多巧思妙解，二刷的时候再看其他方法吧！

142.环形链表II

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

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

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

想了一会儿想不出来，不折磨自己了，看了文字解析果然是有点难度，但是理解了后非常有收获，解法思路看懂后十分清晰，对于本题画图理解十分重要，应该多动手画画图。

这里自己的思考部分并不多，直接将精华提出来，然后自己实现代码：

如果有环，如何找到这个环的入口

此时已经可以判断链表是否有环了，那么接下来要找这个环的入口了。

假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。 如图所示：

那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。

因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：

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

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,

再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

这个公式说明什么呢？

先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

当 n为1的时候，公式就化解为 x = z，

这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。

让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。

那么 n如果大于1是什么情况呢，就是fast指针在环形转n圈之后才遇到 slow指针。

其实这种情况和n为1的时候 效果是一样的，一样可以通过这个方法找到 环形的入口节点，只不过，index1 指针在环里 多转了(n-1)圈，然后再遇到index2，相遇点依然是环形的入口节点。

代码如下：

# Definition for singly-linked list.

# class ListNode:

#     def __init__(self, x):

#         self.val = x

#         self.next = None



class Solution:

    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:

        # 核心是x = (n - 1) (y + z) + z

        # 即首次相遇节点和头部同时出发，必在入口相遇

        fast = slow = head

        while fast and fast.next:

            fast = fast.next.next

            slow = slow.next

            if fast == slow:

                cur1 = head

                cur2 = fast

                while cur1 != cur2:

                    cur1 = cur1.next

                    cur2 = cur2.next

                return cur1

       

        return None

另外python的集合法非常有用和简单，特此记录以下：

在Python中，集合（`set`）是基于哈希表实现的。检查一个元素是否存在于集合中的时间复杂度是O(1)，即常数时间复杂度。这意味着无论集合中有多少个元素，检查元素是否存在的操作通常都能在非常短的时间内完成。

这种高效的查找性能是集合的一个重要特点，也是它在需要快速成员检查的场景下被广泛使用的原因之一。相比之下，列表（`list`）的查找操作需要O(n)的时间复杂度，因为它需要遍历列表中的每个元素来查找目标值。

代码如下：

# Definition for singly-linked list.

# class ListNode:

#     def __init__(self, x):

#         self.val = x

#         self.next = None



class Solution:

    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:

        visited = set()

        cur = head

        while cur:

            if cur in visited:

                return cur              # 第二次经过同个节点会返回

            visited.add(cur)

            cur = cur.next

        return None

Python的set()真是非常好用。。记录一下以后可以多用