算法打卡第四天

题目1：两两交换链表的结点

题目：

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

示例 1：

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

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

提示：

• 链表中节点的数目在范围 [0, 100] 内
• 0 <= Node.val <= 100

解析：我们需要明白：由于我们不能改变节点内部的值，所以我们只能进行节点交换，我们不难看出，如果想要交换相邻两个节点，需要有一个辅助节点来帮助我们进行转换

代码如下：

class Solution(object):
    def swapPairs(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        dummy_head = ListNode(next=head)
        pre = dummy_head
        while pre.next and pre.next.next:
            first = pre.next.next
            next = pre.next
            next.next = first.next
            first.next = next
            pre.next = first

            pre = pre.next.next
        return dummy_head.next    

题目2：删除链表结点

题目：

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

提示：

• 链表中结点的数目为 sz
• 1 <= sz <= 30
• 0 <= Node.val <= 100
• 1 <= n <= sz

我们依然在题目中使用虚拟头结点，因为这样我们在处理潜在的删除头结点时就不用分开讨论，做题更加方便。

除此之外，倒数第几个元素什么的，肯定就涉及到链表中的遍历，说起遍历，使用双指针法无疑效率更高。

当然，我们需要通过画图来确定快慢指针该怎么遍历。

那么对于快指针来说，他需要先领先slow指针n步，所以先让fast走n步，然后两个指针再一同移动。

解决了这个问题，问题就迎刃而解了。

代码如下：

class Solution(object):
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        dummy_head = ListNode(next=head)
        fast = dummy_head
        slow = dummy_head
        
        while n > 0 and fast:
            # 让快指针先走n步
            fast = fast.next
            n -= 1
            
        while fast.next:
            fast = fast.next
            slow = slow.next
        
        slow.next = slow.next.next
        
        return dummy_head.next

          



        

题目3：链表相交

题目：

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

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

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

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

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

提示：

• listA 中节点数目为 m
• listB 中节点数目为 n
• 0 <= m, n <= 3 * 104
• 1 <= Node.val <= 105
• 0 <= skipA <= m
• 0 <= skipB <= n
• 如果 listA 和 listB 没有交点，intersectVal 为 0
• 如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]

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

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        curA = headA
        curB = headB
        lenA = 0
        lenB = 0
        #先求出A,B两条链表的长度，再决定哪一条链先进行遍历
        while curA:
            curA = curA.next
            lenA+=1
        
        while curB:
            curB = curB.next
            lenB+=1
        
        curA = headA
        curB = headB
        if lenB > lenA: 
            lenA,lenB = lenB,lenA
            curA,curB = curB,curA
        
        
        gap = lenA-lenB
        while gap:
            curA = curA.next
            gap-=1

        
        while curA:
            if curA==curB:
                return curA
            
            curA = curA.next
            curB = curB.next
        
        return None
        

题目4：环形链表

题目：

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

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

提示：

• 链表中节点的数目范围在范围 [0, 104] 内
• -105 <= Node.val <= 105
• pos 的值为 -1 或者链表中的一个有效索引

在题目中，我们依然使用双指针的方法来判定该链表是否是环形，如果该链表能够一直遍历下去，说明该链表为环形，反之则为线性链表

其次，我们使用一快一慢的双指针来判定环的入口，首先，我们设置快指针每次走两个结点，慢指针每一次走一个结点，那么当两个指针相遇的时候，快指针所走的路程恰好就是慢指针的两倍，所以则有：2（x+y） = x+y+n(y+z)

所以化简得x+y = n(y+z)->x = n (y + z) - y

而且我们也知道，在慢指针在环里走完一圈之前，两个指针就已经相遇了。因为慢指针走完一圈，相当与快指针已经走了两圈，所以在这个过程中一定会有相遇。

那么，我们怎么确定快指针在环中走了几圈呢？其实走多少圈效果都是一样的，无论快指针提前走了多少圈，当慢指针进入环形的时候，快指针都会在同一个位置开始对慢指针进行追逐，两个相遇的地方都是一样的，所以我们不妨让n=1，这是就会有x=z。

代码如下：

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

class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
    
        """

        fast = head
        slow = head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if fast==slow:
                index1 = fast
                index2 = head
                while index1!=index2:
                    index1 = index1.next
                    index2 = index2.next
                return index2

        return None