算法训练营第四天

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

---

算法思想和注意点
1.设置dummyHead，
2.pre, cur, post三个指针设置，
3.pre = pre.next.next
当cur指向的节点被删除时，此时的pre指针是不需要移动的，近需要移动cur指针

---

TODO
无

---

代码

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        res = ListNode(next=head)
        pre = res

        while pre.next and pre.next.next:
            cur = pre.next
            post = pre.next.next

            cur.next = post.next
            pre.next = post
            post.next = cur

            pre = pre.next.next
        
        return res.next

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

---

算法思想和注意点
1.如果倒数第N个节点恰好是头节点怎么办呢？设置了dummyHead之后就不需要考虑这个问题了。
2. fast，slow 两个指针，fast要先走n+1步，这个相当于扩大fast和slow之间的距离，这样fast就相当于是倒数第n+1个节点，也就是要删除节点的前一个节点，这样才能把倒数第n个节点删除掉。

---

TODO
无

---

代码

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummyHead = ListNode(next=head)
        
        fast, slow = dummyHead, dummyHead

        for _ in range(n + 1):
            fast = fast.next
        
        while fast:
            fast = fast.next
            slow = slow.next

        slow.next = slow.next.next
        return dummyHead.next

面试题 02.07. 链表相交

---

审题读后感

---

算法思想和注意点
1.在计算完两个链表的长度之后，两个链表的头指针要指向两个链表的head

---

TODO
无

---

代码

# 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:
        sizeA, sizeB = 0, 0
        curA, curB = headA, headB

        while curA:
            curA = curA.next
            sizeA += 1
        while curB:
            curB = curB.next
            sizeB += 1

        curA, curB = headA, headB
        if sizeA > sizeB:
            curA, curB = curB, curA
            sizeA, sizeB = sizeB, sizeA
        
        for _ in range(sizeB - sizeA):
            curB = curB.next
        
        while curA:
            if curA == curB:
                return curA
            else:
                curA = curA.next
                curB = curB.next
        
        return None