算法训练营

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

题目链接: 24. 两两交换链表中的节点
文档讲解： 代码随想录
题目难度：中等

思路:递归法+链表的交换只需要交换链表的next指向
时间复杂度：O(log(n))；空间复杂度：O(1)
下面展示 代码：

class ListNode:
    def __init__(self, val, next=None) -> None:
        self.val = val
        self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        if head == None:
            return None
        else:
            root = ListNode(next=head)
            current = root
            while current.next:
                if current.next.val == val:
                    current.next = current.next.next
                else:
                    current = current.next
            return root.next

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

题目链接: 19.删除链表的倒数第N个节点
文档讲解： 代码随想录
题目难度：简单
思路:虚拟头结点+双指针思想，引入虚拟头结点后，难度减小很多。此外主要注意的是慢指针移动到待删除的前一个指针即可，因此最初的快指针的平移步数为n+1。
代码如下

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        if n < 0:
            return head
        elif head.next == None:
            return None
        else:
            # 双指针思想
            # 虚拟头结点
            root = ListNode()
            root.next = head
            fast, slow = root, root
            for i in range(n + 1):
                fast = fast.next
            # slow移动到倒数第n个元素
            while fast:
                fast = fast.next
                slow = slow.next
            slow.next = slow.next.next
            return root.next
            

面试题 02.07. 链表相交

题目链接: 160. 链表相交
文档讲解： 代码随想录
题目难度：简单
思路:1、计算链表A和B的长度，2、指针分别从A和B相同位置开始出发，找到相交的节点
时间复杂度：O(n+m)
acm模式代码如下

class ListNode:
    def __init__(self, val=0, next = None) -> None:
        self.val = val
        self.next = next
class ListNode:
    def __init__(self, val=0, next = None) -> None:
        self.val = val
        self.next = next
class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        # 找到A和B的长度
        if headA == None or headB == None:
            return None
        else:
            curA = headA
            curB = headB
            m, n = 0, 0
            while curA or curB:
                if curA:
                    m += 1
                    curA = curA.next
                if curB:
                    n += 1
                    curB = curB.next
            curA = headA
            curB = headB
            if m > n:
                # A比B长(m-n)
                for i in range(m- n):
                    curA = curA.next
            elif m < n:
                # B比A长(m-n)
                for i in range(n- m):
                    curB = curB.next
            while curA:
                if curA == curB:
                    return curA
                else:
                    curA = curA.next
                    curB = curB.next
            return None

142.环形链表II

题目链接: 142.环形链表II
文档讲解： 代码随想录
题目难度：中等
思路:双指针法，具体见理论推导。
代码步骤：快慢指针法slow和fast：fast每次走两步，slow每次走一步：1、判断是否有环：slow与fast是否相遇；
2、判断入环节点：slow与fast相遇的位置即为入环节点
代码如下

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

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        # 快慢指针法slow和fast：fast每次走两步，slow每次走一步
        # 1、判断是否有环：slow与fast是否相遇；
        # 2、判断入环节点：slow与fast相遇的位置即为入环节点
        if head == None or head.next == None:
            return None
        else:
            fast, slow = head, head
            while fast and fast.next:
                slow = slow.next
                fast = fast.next.next

                if fast == slow:
                    # 证明有环
                    # 利用x=z，将slow放回起点，和fast相遇的位置即为入环位置
                    slow = head
                    while fast != slow:
                        slow = slow.next
                        fast = fast.next
                    return slow
            return None