LeetCode 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

进阶：你能尝试使用一趟扫描实现吗？

法一：双指针法，第一个指针先往前走n步，然后两个指针一起向尾部移动，直到第二个指针指向尾指针：

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeNthFromEnd(head *ListNode, n int) *ListNode {
    ret := head

    aheadNode := head
    for i := 0; i < n; i ++ {
        aheadNode = aheadNode.Next
    }

    // 如果要删除头节点，特殊处理一下
    if aheadNode == nil {
        return ret.Next
    }

    for aheadNode.Next != nil {
        head = head.Next
        aheadNode = aheadNode.Next
    }

    // 删除结点
    head.Next = head.Next.Next

    return ret
}

如果链表有n个结点，此算法时间复杂度为O(n)，空间复杂度为O(1)，且只遍历了一次链表。

法二：将链表中所有结点入栈，然后一个一个出栈，直到出栈n个结点，即找到了要删除的结点：

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeNthFromEnd(head *ListNode, n int) *ListNode {
    stack := []*ListNode{}
    curNode := head
    for curNode != nil {
        stack = append(stack, curNode)
        curNode = curNode.Next
    }

    if len(stack) == n {
        return head.Next
    } else {
        stack[len(stack)-n-1].Next = stack[len(stack)-n-1].Next.Next
    }
    return head
}

如果链表有n个结点，此算法时间复杂度为O(n)，空间复杂度为O(n)。