算法打卡Day04

今日任务：

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

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

3）面试题 02.07. 链表相交

4）142.环形链表II

24两两交换列表中的节点

题目链接：24. 两两交换链表中的节点 - 力扣（LeetCode）

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

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

文章讲解：代码随想录 (programmercarl.com)

视频讲解：帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点_哔哩哔哩_bilibili

思路：

1）首先要明白，指针是指向一对交换节点的前一位的

2）交换节点

3）移动指针，重复2）直至指针的下一位或指针的下下一位为空

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def swapPairs(head: [ListNode]) -> [ListNode]:
    # 定义一个哨兵节点,这里值定义多少都可以，不为空即可，与后面的循环有关
    dummy_head = ListNode(0,head)

    # 指针指向需要交换的两个节点的前一位，初始就是从哨兵节点开始
    cur = dummy_head

    while cur.next and cur.next.next:  # 因为指针最初指向哨兵节点，这里的cur不能为空
        # 第一步：cur-->交换2节点，重新指向之前，交换节点1先用临时节点存储
        tmp1 = cur.next
        cur.next = cur.next.next

        # 第二步：交换2节点-->交换1节点，重新指向之前，节点3先用临时节点存储
        tmp3 = cur.next.next  # 注意这里cur.next不再是交换节点1，变成了交换节点2，所以cur.next.next就是节点3
        cur.next.next = tmp1

        # 第三步：交换节点1-->节点
        tmp1.next = tmp3

        # 第四步指针移动,移动到下一对交换节点前
        cur = cur.next.next

    return dummy_head.next

感想：

这题比较巧妙。有几个注意的点，一个是指针是指向交换节点的前一位的；二个是在做交换时，重新赋值时，要先把这个值先保存，不然链就断了

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

题目链接：19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

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

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

文章讲解：代码随想录 (programmercarl.com)

视频讲解：链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点哔哩哔哩bilibili

思路：

1）定义快慢指针，快指针比慢指针快n+1

2）当快指针为空时，慢指针则正好到要删除指针的前一位

3）重新链接即可

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def removeNthFromEnd(head: [ListNode], n: int) -> [ListNode]:
    # 添加一个哨兵节点
    dummy_head= ListNode(next=head)

    # 双指针指向哨兵节点
    fast = dummy_head
    slow = dummy_head

    # 快指针先前进n+1步
    for _ in range(n+1):
        fast = fast.next

    # 快慢指针同时移动，当快指针为空时，慢指针刚好到要删除节点的前一步
    while fast:
        slow = slow.next
        fast = fast.next

    # 通过更新第 (n-1) 个节点的 next 指针删除第 n 个节点
    slow.next = slow.next.next

    return dummy_head.next

感想：

这题巧的点在于删除倒数第n个节点问题，转换成采用快慢指针，快指针比慢指针快n+1轻松解决

为啥是n+1呢，因为我们要删除某个节点时，指针一点是指向这个节点的前一位的。而快指针为空时，慢指针也就到我们要找的倒数第n个节点的前一位。

面试题 02.07. 链表相交

题目链接：面试题 02.07. 链表相交 - 力扣（LeetCode）

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

示例1：
listA = [0,9,1,2,4]
listB = [3,2,4]
输出：2

文章讲解：代码随想录 (programmercarl.com)

思路：

1）处理链表，末端对齐

      A)求出两个链表的长度

      B)移动长链表指针，使两链表尾部对齐

2）同时移动两个指针，直到它们相等则相交

class ListNode:
    def __init__(self, val, next=None):
        self.val = val
        self.next = next


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

        # todo 1.求出两个链表的长度
        lenA = self.getLength(headA)
        lenB = self.getLength(headB)

        # todo 2.移动长链表指针，使两链表尾部对齐
        steps = lenA - lenB

        if steps > 0:
            headA = self.moveForward(headA,steps)
        else:
            headB = self.moveForward(headB,-steps)
         

        # todo 3.同时移动两个指针，直到它们相交
        while headA and headB:
            if headA == headB:
                return headA
            headA = headA.next
            headB = headB.next

        return None


    # 定义一个求长度的函数
    def getLength(self, head: ListNode) -> int:
        size = 0
        while head:
            head = head.next
            size += 1
        return size

    # 定义一个移除长链表头部的函数
    def moveForward(self, head: [ListNode], steps: int) -> ListNode:
        for _ in range(steps):
            head = head.next
        return head

感想：

这题关键点在于，先要将链表对齐，是尾端对齐，所以先要对链表进行处理

142.环形链表II

题目链接：142. 环形链表 II - 力扣（LeetCode）

文章讲解：代码随想录 (programmercarl.com)

视频讲解：把环形链表讲清楚！ 如何判断环形链表？如何找到环形链表的入口？ LeetCode：142.环形链表II哔哩哔哩bilibili

方法一：快慢指针

1）先判断是否有环

2）若有环，则找到环入口

class ListNode():
    def __init__(self, val, next=None):
        self.val = val
        self.next = next


class Solution:
    # 双指针法
    def detectCycle(self, head: ListNode) -> ListNode:

        # todo 1.确定是否有环
        slow, fast = head, head

        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next

            # 两指针相遇-->有环;
            if fast == slow:

                # todo 2.找环的入口
                index1 = fast
                index2 = head

                while index1 != index2:
                    index1 = index1.next
                    index2 = index2.next

                return index1

        # 如果没环，会遇到fast指针为空的时候
        return None

方法二：集合法

遍历链表，用一个集合去收集链表的结果，当出现重复值时，则有环，为环入口

class ListNode():
    def __init__(self, val, next=None):
        self.val = val
        self.next = next


    def detectCycle(self, head: ListNode) -> ListNode:
        visited = set()

        while head:
            if head in visited:
                return head
            visited.add(head)
            head = head.next

        return None

感想：

这题也很巧妙，只要思路理清楚，代码写起来并不难

这题难点在于想通如何确定有环，如何确定环入口

1）如何确定有环

        我们定义快慢指针，快指针比慢指针快一步（即快指针速度是慢指针速度的2倍）。如果有环，那么快慢指针一定会在环中相遇，而且是慢指针进入环后的第一圈，所以当快慢指针相等时，则确定有环

2）如何确定环入口

        可以明确的是，当快慢指针相遇时，快指针路程 - 慢指针路程 = n * (环周长)，同时还有快指针速度是慢指针速度的两倍，也就是快指针路程是慢指针路程的两倍

 慢指针路程 = x+y

快指针路程 - 慢指针路程 = n * (环周长) -->    x+y=n(z+y)  --> x = (n-1)(z+y) +z

所以我们重新定义两个指针，一个从head开始，一个从相遇点开始，两者速度一致移动，当相遇时，即是环入口