刷题日记(5/60)

24

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

class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class Solution(object):
    def swapPairs(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        dummynode = ListNode(val=0,next=head)
        temp = dummynode
        while temp.next and temp.next.next:
            cur1 = temp.next
            cur2 = temp.next.next
            temp.next = cur2
            cur1.next = cur2.next
            cur2.next = cur1
            temp = cur1
        return dummynode.next

具体思路：
主要就是弄清楚步骤问题

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

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

class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class Solution(object):
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        dummynode = ListNode(0,head)
        fast = head
        slow  = dummynode
        for i in range(n):#0到(n-1)
            fast = fast.next
        while fast:
            fast = fast.next
            slow = slow.next
        slow.next = slow.next.next
        return dummynode.next

总结：主要是要给滑动窗口的概念，想得到倒数第n个，那么取一个长度为n的窗口，从头滑到末尾，当窗口尾巴触碰到链表末尾的时候，窗口头部即为倒数第n个结点

相交链表

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

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        len_a = 0
        len_b = 0
        node = headA
        while node:
            node = node.next
            len_a += 1
        node = headB
        while node:
            node = node.next
            len_b += 1
        node1 = headA
        node2 = headB
        if len_a > len_b:
            node1,node2 = node2,node1
            len_a,len_b = len_b,len_a
        for _ in range (len_b-len_a):
            node2 = node2.next
        while node1:
            if node1 == node2:
                return node1
            else:
                node1 = node1.next
                node2 = node2.next
        return None

总结：先找到链表a和链表b之间的长度差，然后将长的链表退长度差个结点，然后再进行寻找相交节点

142环形链表

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

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

class Solution(object):
    def detectCycle(self,head):
        fast = slow = head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                slow = head
                while slow != fast:
                    slow = slow.next
                    fast = fast.next
                return fast
        return None

总结：代码不难，主要在于数学运算：（真没想出来）
具体思路可见：环形链表数学思路