python 链表中倒数第k个节点

｜ 返回链表中倒数第K个节点

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。

示例：

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.

｜题解

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

class Solution:
    """
    提供三种解题思路:
    解题思路一: 
    1.先翻转整个链表
    2.遍历翻转后的链表,用count来记录位置, 然后用头插法继续翻转即可
    解题思路二:
    1.找规律可得,倒数第k个元素就是正数n-k+1个元素
    2.先遍历计算链表的长度，再遍历到第n-k+1的位置即可
    解题思路三:
    1.快慢指针解法，先让fast指针走k步
    2.当fast指针走k步后，fast指针和slow指针同步向后走，fast为None，slow就是倒数第k个位置
    """
    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
        # 解法一
        cur = head
        # 反转初始链表
        new_head = self.reserves(cur)

        new_head2 = None
        count = 0
        while new_head:
            if count == k:
                break
            else:
                # 用头插法反转部分链表
                pre = new_head.next
                new_head.next = new_head2
                new_head2 = new_head
                new_head = pre
            count += 1

        return new_head2
        
    def reserves(self, head):
        new_head = None
        cur = head
        while cur:
            per = cur.next
            cur.next = new_head
            new_head = cur
            cur = per
        return new_head

        # 解法二

        # 定义头指针，添加虚拟头节点
        new_head = None
        node = ListNode()
        new_head = node
        tail = node

        # 计算链表的长度
        count = 0
        cur = head
        while cur:
            count += 1
            cur = cur.next
        
        # s 为正向链表的位置
        s = count - k + 1

        count_1 = 0
        while head:
            if count_1 == s:
                break
            else:
                tail.next = head
                head = head.next
            count_1 += 1

        return new_head.next

		 #解法三
        fast = head
        slow = head
        count = 0

        cur = head
        while fast:
            if count >= k:
                slow = slow.next

            fast = fast.next
            count += 1

        return slow