Java 删除链表中间的一个节点

我试图删除单个链表中两个节点中间的一个节点。< /P>

public void deleteAfter(Node del){
        del.next=del.next.next; 
    }  

其中删除指定节点后面的节点del。
我得到一个空指针异常。我认为问题是删除后与其他节点的链接断开。我如何修复它。以下是我的完整代码：

public class Node{
    public Object item;
    public Node next;
    public Node(){
        item=null;
        next=null;
    }
    public Node(Object x){
        item=x;     
        next=null;
    }

    public void insertAfter(Node after,Object x){
        Node newNode=new Node(x);
        newNode.next=after.next;
        after.next=newNode;
    }
    public void deleteAfter(Node del){//Deletes the node that is after the specified node
        del.next=del.next.next; 
    }
    public static void main (String args[]){
    Node front=new Node(),p=new Node(),q=new Node();
    p.item="green";
    q.item="red";
    p.next=q;
    front=p;
    front.deleteAfter(p);
    front.insertAfter(p,"black");

    front.insertAfter(q,"blue");
    front.insertAfter(q.next,"orange");
    front.deleteAfter(q);
    System.out.println(front.item);
    System.out.println(front.next.item);
    System.out.println(front.next.next.item);
    System.out.println(front.next.next.next.item);
    }
}

---

首先，你的列表应该记住最后一个元素或标题

public class YourList{
   Node heaed;
   public YourList(){
      head = null;
  }
  public void insert(Node node){
     if(last == null){
        head = node;
     } 
  }
  public void deleteAfter(Node del){
        if(del.next == head)){
            head = del;
         }
        if(del.next == null){
           //do nothing because there is nothing to delete
        }
        else{
        del.next=del.next.next; 
        }
   }

 }

地址：

您已经创建了一个从

p

开始的两节点链表，并将其指向

front

，然后将其缩小为一个单节点链表，并将其重新压缩为两个，由{“绿色”、“黑色”}组成

q

是一个单例列表节点，稍后将对其进行操作

从

front

开始打印时，由于它只有两个节点，因此尝试获取不存在的第三个节点的

项会导致异常

您的问题是从询问您的
deleteAfter（）
是否有问题开始的，问题的关键在于它不会正确处理任何正确的节点列表，而只会处理一个在它后面有内容的列表。传入空列表或仅包含一个节点的列表将导致异常。
您可以首先使用双指针方法找到中间节点，然后删除该节点

public Node findMiddleNode(Node node){
    Node runner = node;
    while(node!=null){
        node = node.next;
        if(node != null){
            node = node.next;
            runner = runner.next;
        }
    }
    return runner;
}

public static boolean deleteNode(Node node){
    if(node==null || node.next==null) return false;
    Node next = node.next;
    node.data = next.data;
    node.next = next.next;

    return true;
}

首先计算列表大小并删除n/2元素而不使用两个指针的解决方案

例如，若给定的链表是1->2->3->4->5，那个么链表应该修改为1->2->4->5。如果有偶数个节点，那么将有两个中间节点，第二个中间元素将被删除。例如，如果给定的链表是1->2->3->4->5->6，则应将其修改为1->2->3->5->6

    public void deleteMiddle() {

    if (head == null) {
        System.out.println("List is emplty");
        return;
    } else if (head.next == null) {
        head = null;
        return;
    } else {
        int count = 0;
        int nodeDeleteIndex = 0;
        Node node = this.head;
        Node temp = this.head;

        // To calculate the list size
        while (node != null) {
            count++;
            node = node.next;
        }
        // getting the n/2 index of the node which needs to be deleted
        nodeDeleteIndex = (count / 2);
        for (int i = 0; i < nodeDeleteIndex - 1; i++) {
            temp = temp.next;
        }
        temp.next = temp.next.next;
    }
}

public void deletemidle（）{
if（head==null）{
System.out.println（“列表为雇员”）；
返回；
}else if（head.next==null）{
head=null；
返回；
}否则{
整数计数=0；
int nodeDeleteIndex=0；
Node=this.head；
节点温度=this.head；
//计算列表大小的步骤
while（节点！=null）{
计数++；
node=node.next；
}
//获取需要删除的节点的n/2索引
nodeDeleteIndex=（计数/2）；
对于（int i=0；i你的删除代码不能处理输入本身就是最后一个节点的情况。这是当要删除的节点在另外两个节点的中间时，为什么我必须记住最后一个或头元素。如果中间节点被删除，那么为什么不是“代码> DEL。Next＝Del.Next？Next；代码>足够，因为当您没有列表数据的任何句柄时。因此，添加任何元素都是毫无意义的，因为您无法检索它：）请粘贴您的
列表
结构。列表结构在main方法中定义。虽然我最初只创建了两个节点p，q当我调用inserFront（）方法时，我正在创建新节点，对吗？因此，当您从前面开始打印时，
“由于它只有两个节点，因此尝试获取第三个节点的项目（不存在）会导致您的异常。”
发生？因为前面有三个节点“红色”、“绿色”、q
。deleteAfter（p）
将列表减少一个，使它只有一个节点。然后
front.insertAfter（p，“black”）
将其从一个后面增加到两个。
    public void deleteMiddle() {

    if (head == null) {
        System.out.println("List is emplty");
        return;
    } else if (head.next == null) {
        head = null;
        return;
    } else {
        int count = 0;
        int nodeDeleteIndex = 0;
        Node node = this.head;
        Node temp = this.head;

        // To calculate the list size
        while (node != null) {
            count++;
            node = node.next;
        }
        // getting the n/2 index of the node which needs to be deleted
        nodeDeleteIndex = (count / 2);
        for (int i = 0; i < nodeDeleteIndex - 1; i++) {
            temp = temp.next;
        }
        temp.next = temp.next.next;
    }
}