力扣刷题（Python）--链表总结，包含源代码--相关心得与思路（24. 两两交换链表中的节点，19. 删除链表的倒数第 N 个结点，面试题 02.07. 链表相交，142. 环形链表 II））

力扣刷题（Python）–链表–相关心得与思路（24. 两两交换链表中的节点），包含源代码

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

思路：

按照图中所给题目要求大致如图所示，我们先用虚拟头结点连接整个链表，然后用temp和temp_1分别记录 点1 和 点3 位置，然后将虚拟头结点连接 点2 然后 点2 连接 点1 --> 点3 ，然后将当前指针（cur）往后移两个位置即可。

注意：
（1）指针遍历结束条件。
当链表长度为偶数时cur.next == None 时结束
当链表长度为奇数时cur.next.next == None 时结束

（2）记得用temp提前记录两边相邻的节点位置
（3）记得最后结果是返回虚拟头结点的next
（4）下边代码要特别注意遍历判断条件的顺序，如果颠倒就会报错

python代码如下：

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummyhead = ListNode()                    #虚拟头结点
        dummyhead.next = head                      
        cur = dummyhead                           #不对原始链表操作   
        while cur.next !=None and cur.next.next != None:    #终止条件
            temp = cur.next                        #记录第一个节点
            temp_1 = cur.next.next.next            #记录第三个节点
            cur.next = cur.next.next         #虚拟头结点连接第二个节点 
            cur.next.next = temp            
            temp.next = temp_1
            cur = cur.next.next              #当前指针移动两个位置
        return dummyhead.next           

（2） 力扣序号19. 删除链表的倒数第 N 个结点

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

思路：

双指针经典应用，如果要删除倒数第n个节点，让fast先移动n+1步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点即可。
步骤：
第一步：建立虚拟头结点
第二步：定义fast,slow指针
第三步：让fast首先走n + 1步 ，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作）
第四步：fast和slow同时移动，直到fast指向末尾
第五步：删除slow所对应的下一个节点即可

注意：
（1）fast要先走n+1步，方便对指定结点删除

Python代码如下：

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummyhead = ListNode(next = head)           #虚拟头结点
        fast,slow,i = dummyhead,dummyhead,0         #双指针赋值
        while i <n+1 and fast != None:              #让fast先走n+1步
            fast = fast.next
            i += 1
        while fast != None:                        #slow，fast一块走 
            fast = fast.next
            slow = slow.next
        slow.next = slow.next.next                 #删除制定结点
        return dummyhead.next

（3） 力扣面试题 02.07. 链表相交

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

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

思路：

第一步：先遍历两个链表，求出两个链表的长度
第二步：将最长的链表设为A链表（curA）
第三步：求出两个链表长度的差值gap，让curA移动gap步，让curA移动到，和curB 末尾对齐的位置
第四步：在遍历链表A的同时，curA和curB同时移动，直到curA==curB，即找到交点，return curA，否则return None

注意：
（1）指针存的地址，指针一样，指向一个位置，本题要比较的是结点指针不是结点的值
（2）不要把值和节点的概念混淆起来 节点是一个实例 占用一块空间 值只是它的成员变量 值怎样和节点本身没有任何关系 一个实例只由它的地址唯一确定!

Python代码如下：

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        lenA,lenB = 0,0
        cur = headA
        while cur != None:               #链表A的长度
            cur = cur.next
            lenA += 1
        cur = headB
        while cur != None:               #链表B的长度
            cur = cur.next
            lenB += 1
        curA,curB = headA,headB
        if lenB > lenA:                  #将最长的链表设为A
            curA,curB = curB,curA
            lenA,lenB = lenB,lenA
        gap = lenA - lenB
        while gap:                       #两个链表走到同一起始点
            curA = curA.next
            gap -= 1
        while curA!=None:                #遍历curA，直到指针相交
            if curA == curB:
                return curA
            curA = curA.next
            curB = curB.next
        return None

（4） 142. 环形链表 II—这个题相对难理解

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

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

不允许修改 链表。

思路：

第一步：首先判断是否链表有环
方法：双指针法，fast指针每次移动两个结点，slow指针每次移动一个结点，如果两个指针相遇说明链表有环。
注：fast 比 slow 快一个结点，也就是说如果有环的情况下，fast指针是以一个结点的速度去接近slow指针，所以必定相遇。

第二步：确定环的入口（这里是难点）

slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。

因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：

(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,
再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。
先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。
这个公式说明从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点
也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。
让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。

注意：
（1）判断条件一定是两个空，否则会报错

Python代码如下：

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        fast = head
        slow = head
        while (fast != None and fast.next != None):     #判断是否有环
            slow = slow.next
            fast = fast.next.next
            if fast== slow:                             #判断相遇
                index_1 = fast                          #记录相遇节点
                index_2 = head                          
                while index_1 != index_2:               #遍历直到相遇
                    index_1 = index_1.next
                    index_2 = index_2.next
                return index_1
        return None

链表总结：