Leetcode刷题Day5 Python

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

难度中等1533收藏分享切换为英文接收动态反馈

给你一个链表，删除链表的倒数第 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

当要判断一个链表节点是不是空指针的时候，直接while 节点:   这样写就好了

然后删除也很简单，单链表i.next = i.next.next这样i的下一个节点就没了

当然i = i.next这样i就没了这样似乎更快

我写的代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        #采用快慢指针，快慢之间距离为n+1，这样当快指针达到NULL的时候，慢指针指向的是被删除节点的前面一个
        # 这样在删除的时候就直接 慢.next=慢.next.next即可
        # 难点在于如果遇到的是删除头部的指针怎么办，这个需要考虑
        # 先进行初始化，慢指针指向头部不动，快指针前进n+1步，如果在前进n位的时候NULL就是删除头部
        # 如果在n+1位的时候遇到了NULL相当于开始就做完了,可以归并到之后等速移动的过程之中进行
        i = j = head
        count = 0
        while j and count<n:
            j = j.next
            count +=1
        if j:
            j = j.next
        else:
            return head.next
        while j:
            i = i.next
            j = j.next
        i.next = i.next.next
        return head

众所周知，先考虑清楚，写好注释，之后再写代码，是个好习惯

其他官方和评论区解法：

在对链表进行操作时，一种常用的技巧是添加一个哑节点（dummy node），它的 \textit{next}next 指针指向链表的头节点。这样一来，我们就不需要对头节点进行特殊的判断了。

官方解法：

那个往后走n个的，之前写的太傻了！！！还是range(n)方便

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        dummy = ListNode(0, head)
        first = head
        second = dummy
        for i in range(n):
            first = first.next

        while first:
            first = first.next
            second = second.next
        
        second.next = second.next.next
        return dummy.next

然后就是

方法二：栈
思路与算法

我们也可以在遍历链表的同时将所有节点依次入栈。根据栈「先进后出」的原则，我们弹出栈的第 nn 个节点就是需要删除的节点，并且目前栈顶的节点就是待删除节点的前驱节点。这样一来，删除操作就变得十分方便了。

#倒着去数数的时候栈是一种方便的结构！可以学一学！

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        dummy = ListNode(0, head)
        stack = list()
        cur = dummy
        while cur:
            stack.append(cur)
            cur = cur.next
        
        for i in range(n):
            stack.pop()

        prev = stack[-1]
        prev.next = prev.next.next
        return dummy.next

复杂度分析

时间复杂度：O(L)，其中 L 是链表的长度。

其实感觉如果n比较小的时候，远小于L的时候，栈也是挺快的哈哈哈。

空间复杂度：O(L，其中 L 是链表的长度。主要为栈的开销。