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

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

题目链接：link

1、题目描述

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

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

2、思路

• 交换节点的步骤

• 里面的细节分析

💡创建虚拟头结点dummyhead，目的是让头节点也变成一般节点

💡如果要交换节点1和节点2，创建的cur指针指向节点1的前一个节点（原因是单向链表只指向下一个节点）

💡循环的终止条件：两种情况

1. 节点为偶数：cur.next == null
2. 节点为奇数：cur.next.next == null

​ 💗在终止语句里面一定要先写cur.next == null，因为如果cur.next == null，cur.next就不存在，也就没有next指针，会出现报错

💡创建临时变量：

1. 在步骤一之前，要使用临时指针保存cur指向1的路径，因为在步骤二需要使用1
2. 在步骤一之前，也要使用临时指针保存2指向3的路径，因为在步骤三要使用3

3、code

# 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]:
        # 创建一个虚拟头结点，为了让处理头节点的方法和处理中间节点的方法保持一致
        dummy = ListNode()
        dummy.next = head
        cur = dummy # 要让cur指向被操作的节点的前一个节点（因为单向链表只指向后一个链表）
        while cur.next != None and cur.next.next != None:
            # 首先要记录第一个节点和，第三个节点
            temp1 = cur.next
            temp2 = cur.next.next.next
            # 将当前节点指向第二个节点
            cur.next = cur.next.next
            # 将第二个节点指向第一个节点
            cur.next.next = temp1
            # 将第一个节点指向第三个
            temp1.next = temp2
            # 移动cur到第二个节点上
            cur = cur.next.next
        return dummy.next

4、复杂度分析

时间复杂度: O(n)
空间复杂度: O(1)

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

题目链接：link

1、题目描述

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

2、思路

❣️快慢指针❣️

动图：

• 里面的细节分析

💡创建虚拟头结点dummyhead，目的是让头节点也变成一般节点

💡快慢指针的含义：

​ 慢指针：就是要指向被删除的节点的前一个

​ 快指针：要保证删除的是倒数第二个节点，就需要有一个指针去前面“探路”，比慢指针要快走（n+1）步

3、code

# 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()
        dummyhead.next = head
        # 创建快慢指针
        slow = dummyhead
        fast = dummyhead
        # 先让快指针跑（n+1）步
        for _ in range(1,n+2):
            fast = fast.next
        # 当快指针跑到null时结束
        while fast != None:
            slow = slow.next
            fast = fast.next
        # 此时slow指向要被删除的节点的前一个
        slow.next = slow.next.next
        return dummyhead.next

4、复杂度分析

• 时间复杂度: O(n)
• 空间复杂度: O(1)

面试题 02.07. 链表相交

题目链接：link

1、题目描述

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

2、思路

计算出两个链表的长度，求出差值n
指针分别指向头结点
让长的链表对应cur指针先移动差值n步
之后两个cur指针一起移动，判断有没有一样的节点

3、code

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

class Solution:
    def getlen(self,head):
        cur = head
        res = 0
        while cur is not None:
            res += 1
            cur = cur.next
        return res
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        lenA = self.getlen(headA)
        lenB = self.getlen(headB)
        # 如果A比B长
        curA = headA
        curB = headB
        if lenA > lenB:
            n = lenA - lenB
            while n:
                curA = curA.next
                n -= 1
        else:
            n = lenB - lenA
            while n:
                curB = curB.next
                n -= 1
        while curA is not None and curB is not None:
            if curA == curB:
                return curA
            curA = curA.next
            curB = curB.next
        return None

        

4、复杂度分析

时间复杂度：O(n + m)
空间复杂度：O(1)

141. 环形链表

题目链接：link

1、题目描述

2、思路

使用快慢指针特性：每轮移动之后两者的距离会加一。
当一个链表有环时，快慢指针都会陷入环中进行无限次移动，然后变成了追及问题。想象一下在操场跑步的场景，只要一直跑下去，快的总会追上慢的。

💥 如果存在环，如何判断环的长度呢？
快慢指针相遇后继续移动，直到第二次相遇。两次相遇间的移动次数即为环的长度。

3、code

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        # 快慢指针
        # time complexity = O(N)
        # space complexity = O(1)
        slow = head
        fast = head
        # 注意判断条件：fast, fast.next都不为None，才能循环
        # fast.next不为 None，也是为了使 fast.next.next 能够被定义
        while (fast is not None and fast.next is not None):
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                return True
        return False   

4、复杂度分析

142. 环形链表 II

题目链接：link

1、题目描述

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
和LC141区别： 不仅要判断是否有环，还需要返回入环节点

2、思路

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

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

3、code

# 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]:
        # 定义快慢指针
        fast = head
        slow = head
        # 开始循环
        while fast != None and fast.next != None:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                index1 = head
                index2 = fast
                while index1 != index2:
                    index1 = index1.next
                    index2 = index2.next
                return index1
        return None   

4、复杂度分析

1️⃣ 时间复杂度：O(N)
2️⃣ 空间复杂度：O(1)