2.给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。示例1：输入：head=[1,2，3,4，5],n=2，输出：[1,2,3，5]示例2：输入：head=[1].n=1，输出：0示例3：输入：head=[1,2],n=1，输出：[1]。有java写出来

Java代码如下：

public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode slow = dummy, fast = dummy;
    for (int i = 0; i <= n; i++) {
        fast = fast.next;
    }
    while (fast != null) {
        slow = slow.next;
        fast = fast.next;
    }
    slow.next = slow.next.next;
    return dummy.next;
}

这个方法使用快慢指针来找到链表的倒数第n个结点。快指针比慢指针先移动n个节点。当快指针到达链表的末尾时，慢指针正好指向倒数第n个结点的前一个结点。然后，我们可以通过修改慢指针的下一个指针来删除倒数第n个节点。

注意：在删除节点之前，我们还需要添加一个虚拟节点，以防止头结点被删除时出现问题。

相关问题

2.给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。示例1：输入：head=[1,2，3,4，5],n=2，输出：[1,2,3，5]示例2：输入：head=[1].n=1，输出：0示例3：输入：head=[1,2],n=1，输出：[1]

好的，针对您的问题，我可以给出下面的代码实现：

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

def removeNthFromEnd(head: ListNode, n: int) -> ListNode:
    dummy = ListNode(0)
    dummy.next = head
    fast = slow = dummy
    for i in range(n+1):
        fast = fast.next
    while fast:
        fast = fast.next
        slow = slow.next
    slow.next = slow.next.next
    return dummy.next

上述代码中，我们使用快慢指针的思路来实现，其中 `dummy` 为一个虚拟节点，以便在删除第一个节点时进行处理。首先让 `fast` 指针向前移动 `n+1` 个节点，然后 `fast` 和 `slow` 同时向前移动，直到 `fast` 到达链表的末尾。此时，`slow` 指向的就是要删除的倒数第 `n` 个节点的前一个节点，我们只需要修改该节点的 `next` 指针即可实现删除操作。

因为题目所给的是一个数组，我们需要先将其转换成一个链表来进行处理，不然会报错。具体转换的代码如下：

head = ListNode(head[0])
curr = head
for i in range(1, len(head)):
    curr.next = ListNode(head[i])
    curr = curr.next

祝您学习愉快！

用kotlin解决这个问题：19. 删除链表的倒数第 N 个结点 给你一个链表，删除链表的倒数第 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

好的，我可以用 Kotlin 为您编写一个解决该问题的函数，如下所示：

class ListNode(var `val`: Int) {
    var next: ListNode? = null
}

fun removeNthFromEnd(head: ListNode?, n: Int): ListNode? {
    val dummy = ListNode(0)
    dummy.next = head
    var first: ListNode? = dummy
    var second: ListNode? = dummy

    for (i in 1..n+1) {
        first = first?.next
    }

    while (first != null) {
        first = first.next
        second = second?.next
    }

    second?.next = second?.next?.next
    return dummy.next
}

这个函数使用了双指针的方法，时间复杂度为 O(n)，空间复杂度为 O(1)。您可以将该函数直接复制到 Kotlin 代码中并运行，如下所示：

fun main() {
    val head = ListNode(1)
    head.next = ListNode(2)
    head.next?.next = ListNode(3)
    head.next?.next?.next = ListNode(4)
    head.next?.next?.next?.next = ListNode(5)

    val n = 2

    var current = removeNthFromEnd(head, n)
    while (current != null) {
        print("${current.`val`} ")
        current = current.next
    }
}

您可以将上面的代码复制到 Kotlin 的 REPL 环境中并运行，将会输出 `[1, 2, 3, 5]`。