Java 当我从LinkedList对象中删除节点与从给定的头节点中删除节点时，为什么会得到不同的结果？

我想我知道问题可能是什么（对全局变量和局部变量的误解），但我想进一步验证为什么它没有做我想做的事情

因此，最初，我只是在胡闹，并尝试实现LinkedList delete方法，如下所示： （另外，我知道现在大部分事情看起来都一团糟，我想我在做一些不好的事情，所以你可以坦率地说）

当我调试这个并最终检查头部时，它仍然显示1->2->3->4， 但是，当我使用这个方法时，当我删除一个中间元素时，它似乎做了正确的事情（例如，删除3个收益率，最后得到1->2->4）

当看到Geeksforgek时，他们是这样实现的（而且效果很好） （这只是一个带有delete-rest的片段，可以在以下位置找到）：

（我的代码可能还有其他问题，但现在我只关注删除第一个不起作用的元素） 我认为问题可能是我不完全理解全球和本地正在发生的事情，如果这有意义的话

---

进一步澄清： （进一步研究，我认为我的方法与Geeksforgek的方法有很多不同，但我认为我缩小了问题所在）总之，在移动了一些东西之后，我想我的问题是，为什么他们的delete方法与链表对象一起工作，而不仅仅是使用主节点中的ListNodes构建的链表，例如：



// Practicing with Lists...

public class ListPrac1 {

   public static ListNode head;
   public static ListNode headExample; // the different example

   public static void main(String[] args) {
   
      ListPrac1 ll1= new ListPrac1();
      
      ll1.push(4); 
      ll1.push(3); 
      ll1.push(2); 
      ll1.push(1); 

      ll1.delete(1);
      System.out.println("done");
      System.out.println("\nLinked List after Deletion of 1:"); 
      ll1.printList(); 
      // This is what they did basically while creating a LinkedList
      // Object I guess and it works...
      
      // but... with the same structure of delete method and just 
      // using ListNodes to build a list starting with
      // variable headExample instead and then calling deleteMine.
      // (which has the same structure as delete except a reference to 
      // the new head...)
      ListNode headExample = new ListNode(1);
      headExample.next = new ListNode(2);
      headExample.next.next = new ListNode(3);
      headExample.next.next.next = new ListNode(4);
      deleteMine(1);
      System.out.println();
      System.out.println("\nLinked List starting with headExample after Deletion of 1:"); 

      while (headExample != null) {
         System.out.print(headExample.dat + " ");
         headExample = headExample.next;
      }
   }
   
   public static void printList() { 
        ListNode tnode = head; 
        while (tnode != null) 
        { 
            System.out.print(tnode.dat+" "); 
            tnode = tnode.next; 
        } 
   } 
    
   public static int delete(int deleteMe) {
 
        // Store head node 
        ListNode temp = head, prev = null; 
  
        // If head node itself holds the key to be deleted 
        if (temp != null && temp.dat == deleteMe) 
        { 
            head = temp.next; // Changed head 
            return deleteMe; 
        } 
  
        // Search for the key to be deleted, keep track of the 
        // previous node as we need to change temp.next 
        while (temp != null && temp.dat != deleteMe) 
        { 
            prev = temp; 
            temp = temp.next; 
        }     
  
        // If key was not present in linked list 
        if (temp == null) return -1; 
  
        // Unlink the node from linked list 
        prev.next = temp.next; 
        return deleteMe;

      
      
      
     
   
   }
   
   
   public static int deleteMine(int deleteMe) {
 
        // Store head node 
        ListNode temp = headExample, prev = null; 
  
        // If head node itself holds the key to be deleted 
        if (temp != null && temp.dat == deleteMe) 
        { 
            headExample = temp.next; // Changed head 
            return deleteMe; 
        } 
  
        // Search for the key to be deleted, keep track of the 
        // previous node as we need to change temp.next 
        while (temp != null && temp.dat != deleteMe) 
        { 
            prev = temp; 
            temp = temp.next; 
        }     
  
        // If key was not present in linked list 
        if (temp == null) return -1; 
  
        // Unlink the node from linked list 
        prev.next = temp.next; 
        return deleteMe;
   }

   
   
   public static void push(int new_data) { 
        ListNode new_node = new ListNode(new_data); 
        new_node.next = head; 
        head = new_node; 
   } 


   public static class ListNode {
   
      int dat;
      ListNode next;
   
      public ListNode(int val) {
         dat = val;
         next = null;
      }
   
   }
}

产量： 完成 

删除1后的链接列表： 
2 3 4 

删除1后以headExample开头的链表： 
1234

因此，在创建LinkedList时，它适用于他们的方式，而不是我使用节点创建LinkedList的方式

delete和deleteMine方法相同，除了deleteMine引用headExample（这是在第二部分中构建我的第二个列表的方法）

所以，我的问题是：

在这两种情况下，删除不应该都起作用吗？既然LinkedList和headExample都引用各自的head变量，为什么删除后headExample不被修改，而LinkedList ll1被修改

---

我认为实现的问题在于没有“列表”对象。 您有一些ListNode类的实例

对于LinkedList，您需要有一个表示列表的附加类。 该列表类应该有一个表示列表头的ListNode变量。看这张照片

类链接列表1
{ 
节点头；//列表头

它有一个名为“head”的成员。 当调用delete方法时，它会更改列表对象的head成员变量

如果类ListPrac代表您的列表，则起点可能如下所示：

公共类ListPrac{
//ListPrac的每个实例都有一个表示列表头的ListNode。
节点头；
公共静态void main（字符串[]args）{
ListPrac theList=新ListPrac（）；
ListNode头=新的ListNode（1）；
head.next=新列表节点（2）；
head.next.next=新列表节点（3）；
head.next.next.next=新列表节点（4）；
//这里我们指定一个ListNode作为列表的头部。
theList.head=头；
//在列表上调用delete方法。
删除（1）；
//将列表打印到控制台。
System.out.println（列表）；
}
//不是静态的，因为我们操作的是ListPrac实例。
公共整数删除（整数删除）{
//...
公共静态类ListNode{
//...
@凌驾
公共字符串toString（）{
字符串nextNodeAsString=next==null？“null”：next.toString（）；
返回“{data=“+dat+”，next=“+nextNodeAsString+”}”；
}
}
//...
@凌驾
公共字符串toString（）{
返回“一个列表：{head=“+head.toString（）+”}”；
}
}

在下一步中，您应该比较您的解决方案和其他解决方案，并尝试找出错误。

---

快乐编码：）

我不确定问题是什么。您有一个有效的实现，请将它与您的版本进行比较并找出差异。您是否要求我们为您这样做？如果是这样，您误解了堆栈溢出的目的。请阅读。@JimGarrison哦，对不起，我认为对两个示例进行比较可以说明问题我想我缩小了我的问题范围，并在编辑中详细阐述了这一点。（如果这也是编辑问题而不是等待并在以后发布的错误方式，请随时告诉我，我是新来的）谢谢，我想我更清楚我的误解在哪里。

class LinkedList1 
{ 
    Node head; // head of list 
  
    /* Linked list Node*/
    class Node 
    { 
        int data; 
        Node next; 
        Node(int d) 
        { 
            data = d; 
            next = null; 
        } 
    } 
  
    /* Given a key, deletes the first occurrence of key in linked list */
    void deleteNode(int key) 
    { 
        // Store head node 
        Node temp = head, prev = null; 
  
        // If head node itself holds the key to be deleted 
        if (temp != null && temp.data == key) 
        { 
            head = temp.next; // Changed head 
            return; 
        } 
  
        // Search for the key to be deleted, keep track of the 
        // previous node as we need to change temp.next 
        while (temp != null && temp.data != key) 
        { 
            prev = temp; 
            temp = temp.next; 
        }     
  
        // If key was not present in linked list 
        if (temp == null) return; 
  
        // Unlink the node from linked list 
        prev.next = temp.next; 
    } 
}
  



// Practicing with Lists...

public class ListPrac1 {

   public static ListNode head;
   public static ListNode headExample; // the different example

   public static void main(String[] args) {
   
      ListPrac1 ll1= new ListPrac1();
      
      ll1.push(4); 
      ll1.push(3); 
      ll1.push(2); 
      ll1.push(1); 

      ll1.delete(1);
      System.out.println("done");
      System.out.println("\nLinked List after Deletion of 1:"); 
      ll1.printList(); 
      // This is what they did basically while creating a LinkedList
      // Object I guess and it works...
      
      // but... with the same structure of delete method and just 
      // using ListNodes to build a list starting with
      // variable headExample instead and then calling deleteMine.
      // (which has the same structure as delete except a reference to 
      // the new head...)
      ListNode headExample = new ListNode(1);
      headExample.next = new ListNode(2);
      headExample.next.next = new ListNode(3);
      headExample.next.next.next = new ListNode(4);
      deleteMine(1);
      System.out.println();
      System.out.println("\nLinked List starting with headExample after Deletion of 1:"); 

      while (headExample != null) {
         System.out.print(headExample.dat + " ");
         headExample = headExample.next;
      }
   }
   
   public static void printList() { 
        ListNode tnode = head; 
        while (tnode != null) 
        { 
            System.out.print(tnode.dat+" "); 
            tnode = tnode.next; 
        } 
   } 
    
   public static int delete(int deleteMe) {
 
        // Store head node 
        ListNode temp = head, prev = null; 
  
        // If head node itself holds the key to be deleted 
        if (temp != null && temp.dat == deleteMe) 
        { 
            head = temp.next; // Changed head 
            return deleteMe; 
        } 
  
        // Search for the key to be deleted, keep track of the 
        // previous node as we need to change temp.next 
        while (temp != null && temp.dat != deleteMe) 
        { 
            prev = temp; 
            temp = temp.next; 
        }     
  
        // If key was not present in linked list 
        if (temp == null) return -1; 
  
        // Unlink the node from linked list 
        prev.next = temp.next; 
        return deleteMe;

      
      
      
     
   
   }
   
   
   public static int deleteMine(int deleteMe) {
 
        // Store head node 
        ListNode temp = headExample, prev = null; 
  
        // If head node itself holds the key to be deleted 
        if (temp != null && temp.dat == deleteMe) 
        { 
            headExample = temp.next; // Changed head 
            return deleteMe; 
        } 
  
        // Search for the key to be deleted, keep track of the 
        // previous node as we need to change temp.next 
        while (temp != null && temp.dat != deleteMe) 
        { 
            prev = temp; 
            temp = temp.next; 
        }     
  
        // If key was not present in linked list 
        if (temp == null) return -1; 
  
        // Unlink the node from linked list 
        prev.next = temp.next; 
        return deleteMe;
   }

   
   
   public static void push(int new_data) { 
        ListNode new_node = new ListNode(new_data); 
        new_node.next = head; 
        head = new_node; 
   } 


   public static class ListNode {
   
      int dat;
      ListNode next;
   
      public ListNode(int val) {
         dat = val;
         next = null;
      }
   
   }
}