Python：如何在O（1）时间内删除单链接列表中的ONLY节点

Question

I have read the posts below but they do not answer my issue.

Post 1

Post 2

Post 3

This post comes close to explaining. The top voted answer by @Rishikesh Raje, says that deleting the last node in a singly-linked list is

[...] is generally not possible.

Why is it generally not possible and not just "it's impossible"? My questions is both in the theory itself and how that applies to Python? The question was meant for C.

Moreover, my other question is for the case where the linked list only has one node which also makes it the last node.

Background: I am solving this problem on LeetCode. Although it doesn't ask for the case of deleting the last case, I tried it but can't seem to get it because of some feature I can't pinpoint. Some direction here would be much appreciated. I added a method to print values for debugging.

Here's the question:

Write a function to delete a node (except the tail) in a singly linked list, given only access to that node.

Supposed the linked list is 1 -> 2 -> 3 -> 4 and you are given the third node with value 3, the linked list should become 1 -> 2 -> 4 after calling your function.

My code can achieve the required result 1 -> 2 -> 4:

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

class Solution(object):
  def deleteNode(self, node):
    """
    :type node: ListNode
    :rtype: void Do not return anything, modify node in-place instead.
    """
    nextNode = node.next

    if nextNode:
      node.val = nextNode.val
      node.next = nextNode.next
    else:
      node = None

  def listToString(self, head):
    string = ""
    while head:
      string += str(head.val) + "\n"
      head = head.next

    return string


head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
head.next.next.next = ListNode(4)

solution = Solution()
print(solution.listToString(head))
print('-'*10)
node = head.next.next
solution.deleteNode(node)
print(solution.listToString(head)) 

Running this gives me:

1
2
3
4

----------
1
2
4

But when I change the bottom to:

head = ListNode(1)

solution = Solution()
print(solution.listToString(head))
print('-'*10)
node = head
solution.deleteNode(head)
print(solution.listToString(head))

I get

1

----------
1

The questions are: Why isn't 1 printed and not None ? Mind you, this linked list has only one node (which means it is the last node) and that's what's passed to the function. Can it be done? If so, what are the modifications I should make?

Answer 1

A function that takes a reference to the head node of a list can delete any element after the head, but there's no way for it to delete the head.

If you think about it, this should be obvious. No matter what you do, your caller still has the same reference to the head that he passed in.

But that's not a limitation of linked lists per se, it's just a limitation of your API. With a different API, it's not impossible at all:

---

A function that takes a reference to a "list handle" object that holds a reference to the head node can delete the head node like this:

handle.head = handle.head.next

A function that takes a reference to a reference to the head node, like a C Node ** , can't be written directly in Python, but in languages where it can, it's just as easy as with a list handle:

*head = (*head)->next

A list handle can really be as simple as:

class LinkedList:
    def __init__(self, head=None):
        self.head = head

But usually you'd want to actually use it for something—eg, add insert , delete , append , etc. methods to it, maybe even store the length. (However, notice that this design can break tail sharing, where two different lists have different heads but the same tails, because now you can change part of a list through one LinkedList handle without the other one knowing you've done so.)

---

Or, a function that takes a reference to the head node and returns the new head can also remove the head:

return head.next

Let's work this one out in a bit more detail:

def deleteNode(head, node):
    if head == node:
        return None
    ptr = head
    while ptr and ptr.next != node:
        ptr = ptr.next
    if ptr.next == node:
        ptr.next = node.next
    return head

Needs a bit of error handling, but if you follow the rules it works:

head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
head.next.next.next = ListNode(4)

# This goes from 1->2->3->4 to 1->2->4
head = deleteNode(head, head.next.next)

# And this goes to 2->4
head = deleteNode(head, head)

And obviously if you change this to search for a value instead of for a node, the same thing works.