如何在不使用双指针的情况下从链表中删除最后一个节点

Question

Althought it is much easier to solve the problem with double pointers, is it possible to remove the last node from a singly linked list without using double pointer? I am working on an easy question 203. Remove Linked List Elements , following is my answer, but it failed to remove the last node. I do not understand why it failed. COuld you please explain why? But a similar method used here seems to work well.

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: ListNode, val: int) -> ListNode:
        if not head:
            return head
        res = head 
        while head:
            if head.val == val and head.next:
                head.val = head.next.val
                head.next= head.next.next 
            elif head.val == val and not head.next:
                head = None
            else:
                head = head.next 
        return res 

input:
[1,2,6,3,4,5,6]
6
output: 
[1,2,3,4,5,6]

Answer 1

Try to use a dummy head.
Linked-list looks like this: [Dummy_head->1->2->3->4->5->6] 6.next = None
We are going to find a node which next points to the node which is going to be removed.

prev = dummy_head
for i in range(index):    # this 'index' should be the index of the last element. 
    prev = dummy_head.next
ret_node = prev.next
prev.next = ret_node.next
ret_node.next_node = None # do something here to remove the element.

I tried to solve Leetcode question 203.
I solved it with java.

public  ListNode removeElement(ListNode head, int val)
{
        
    ListNode dummyHead = new ListNode(-1);
    dummyHead.next = head;
    LinkedNode prev = dummyHead;
    while(prev.next != null)
    {
        if(prev.next.val == val)
            prev.next = prev.next.next;
        else:
            prev = prev.next;
    }
    return dummyHead.next; // "DummyHead" process shields the user.
}

You can think of this as a pseudo-code.

Answer 2

You need to handle leaf node specially. the below code works:

def remove_element(head, val):
    if None == head:
        return None

    start = head
    while val == start.val:
        start = start.next

    cur = start
    while None != cur.next:
        if val == cur.next.val:
            if None != cur.next.next:
                cur.next = cur.next.next
            else:
                cur.next = None
                break
        cur = cur.next
    return head

Answer 3

Just like the other answer says, it'd be best to use a sentinel node:

class Solution:
    def removeElements(self, head, val):
        dummy = ListNode(-1)
        dummy.next, curr = head, dummy
        while curr.next:
            if curr.next.val == val:
                curr.next = curr.next.next
            else:
                curr = curr.next
        return dummy.next

Here is also a very similar LeetCode's solution:

class Solution:
    def removeElements(self, head: ListNode, val: int) -> ListNode:
        sentinel = ListNode(0)
        sentinel.next = head
        
        prev, curr = sentinel, head
        while curr:
            if curr.val == val:
                prev.next = curr.next
            else:
                prev = curr
            curr = curr.next
        
        return sentinel.next

---

References

• For additional details, you can see the Discussion Board . There are plenty of accepted solutions with a variety of languages and explanations, efficient algorithms, as well as asymptotic time / space complexity analysis ^{1 , 2} in there.