Java 当您被授予仅访问链接列表中某个节点的权限时，如何删除该节点

我的理解是，为了删除单链表中的节点，我们需要访问当前节点和前一个节点。我有以下逻辑：

public SingleNode delete(int val) {

    SingleNode current = head;
    SingleNode prev = head;

    while(current.data != val) {

        if (current.next == null) {
            return null;
        } else {
            prev = current;
            current = current.next;
        }

    }

    if(current == head) {
        head = current.next;
    } else {
        prev.next = current.next;
    }

    return current;

}

---

当您被授予仅访问当前节点的权限时，如何更改代码，以便删除链表中的节点？

如果只有要删除的节点的访问权限，您可以通过设置下一个节点到当前节点的数据和下一个指针来执行以下操作

public void delete (Node<E> node){
    if (node.next! = null){
        node.data = node.next.data;
        node.next = node.next.next;
    }else{
        node.next = null;
        node.data = null;
    }

当您被授予仅访问当前节点的权限时，如何更改代码以便删除链表中的节点

对于单链接列表，除非具有上一个节点，或者可以访问列表的标题，否则无法删除具有给定引用的节点

如果你有头，你可以找到上一个节点。。。在

O（N）

步骤中

有一种方法可以通过修改节点来删除节点，这种方法在大多数情况下都有效，但有各种各样的边缘情况使得删除节点变得困难。（如果您需要支持并发删除和迭代等，那么它肯定不起作用。）

void deleteNode（struct node*node_ptr）

{

结构节点*temp=node_ptr->next

节点\u ptr->data=temp->data

节点\u ptr->next=temp->next

免费（临时）

}

上述函数使用单个指针删除节点。

---

如果要删除的节点是列表中的最后一个节点，则该方法不起作用。

提示：如果要删除的节点不是最后一个节点，则可能存在这种情况。如果是最后一个节点，则列表中仍有要删除的节点，数据为

null

。如果列表中允许空数据值，这将特别有问题。是的，我同意，但如果head和tail具有虚拟节点，这将不是问题。我不相信您的“将head/tail设置为虚拟节点”参数。您需要提供完整的详细信息，包括插入和查找操作的代码。@Saravana-如果删除列表中的最后一个（或唯一一个）节点，您的代码将不起作用。

public class LinkedList<E> {

    private static class Node<E> {
        E element;
        Node<E> next;

        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }

        @Override
        public String toString() {
            return "Node [element=" + element + ", next=" + next + "]";
        }

    }

    private int size;
    private Node<E> head; // sentinel
    private Node<E> tail; // sentinel

    public LinkedList() {
        tail = new Node<>(null, null);
        head = new Node<>(null, tail);
    }

    public int size() {
        return this.size;
    }

    public boolean isEmpty() {
        return this.size == 0;
    }

    public Node<E> head() {
        return head.next;
    }

    public Node<E> tail() {
        // TODO
    }

    public void addFirst(E e) {
        addBetween(head, e, head.next);
    }

    public void addLast(E e) {
        // TODO
    }

    public void addBetween(Node<E> prev, E element, Node<E> next) {
        Node<E> curr = new Node<>(element, next);
        prev.next = curr;
        size++;
    }

    public Node<E> node(E e) {
        Node<E> temp = head;
        while (temp != null) {
            if (temp.element == e) {
                return temp;
            }
            temp = temp.next;
        }
        return null;
    }

    public E delete(Node<E> node) {
        E e = node.element;
        node.element = node.next.element;
        node.next = node.next.next;
        return e;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        Node<E> temp = head;
        while (temp != null) {
            sb.append(temp.element + " ");
            temp = temp.next;
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        LinkedList<Integer> ll = new LinkedList<>();
        ll.addFirst(10);
        ll.addFirst(20);
        ll.addFirst(30);
        ll.addFirst(40);
        ll.addFirst(50);
        System.out.println("Linked List :: " + ll);
        Node<Integer> node = ll.node(10);
        System.out.println("Node :: " + node);
        System.out.println("Element :: " + ll.delete(node));
        System.out.println("Final List :: " + ll);
    }
}

Linked List :: null 50 40 30 20 10 null 
Node :: Node [element=10, next=Node [element=null, next=null]]
Element :: 10
Final List :: null 50 40 30 20 null 

struct node *temp  = node_ptr->next;
node_ptr->data  = temp->data;
node_ptr->next  = temp->next;
free(temp);