在 java 中删除 LinkedLIst 中的节点循环时跟踪 lastNode 时出错

Question

我创建了一些带有 lastNode 指向头的节点。 在 removeCycle 方法中，当我尝试使 lastNode(i,e prev).next = null 时，首先检测到 lastNode 然后出错

public class loopsRemove {
    public static class Node{
        int data;
        Node next;

        public Node(int data){
            this.data = data;
            this.next = null;
        }
    }

    public static Node Head;
    public static Node Tail;
    public static int count =0;

   
    public static int removeCycle(){
        Node slow = Head;
        Node fast = Head;
          boolean Cycle = false;
    

        while(fast !=null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
            count++;
            if(slow == fast){
                Cycle =true;
               break;
            }
        }
        if(Cycle == false){
            return 0;  //No Cycle and come out of function (int type is just to observe where function is returning
        }
        

        slow = Head;
        Node prev=null;  //to track previous of fast
        while(slow != fast){
            prev = fast;
            slow = slow.next;
            fast = fast.next;  //speed is same as slow now
        }
        prev.next =null;  //Making endNode.next to null
        return 1;   //int return is just to check weather my code is returning here or above
    }
 
    public static void main(String[] args) {
        Head = new Node(3); 
        Head.next = new Node(4);
        Head.next.next = new Node(5);
        Head.next.next.next = new Node(6);
        Head.next.next.next.next = Head;  //cycle formed
        System.out.println(removeCycle());

       
        System.out.println(Head.next.next.next.next.data); // null is expected at the last node if removeCycle works correctly
    }
}

预期输出： 1个 无效的

当前输出： 线程“main”中的异常 java.lang.NullPointerException：无法分配字段“next”，因为“prev”为空 在 loopsRemove.removeCycle(loopsRemove.java:44) 在 loopsRemove.main(loopsRemove.java:55)

Answer 1

您的算法适用于在任何地方打破循环，除非循环包含头节点。

要解决这个问题，您可以在头部之前临时添加一个虚拟节点前缀，在这个较长的列表上使用该算法，然后再次省略该虚拟节点。

以下代码是您的代码，除了引用 dummy 的行：

    public static int removeCycle() {
        Node dummy = new Node(0); 
        dummy.next = Head; // Prefix a dummy node before the head node
        Node slow = dummy; // Apply the algorithm on this longer list
        Node fast = dummy;
        boolean Cycle = false;

        while(fast !=null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
            count++;
            if(slow == fast){
                Cycle =true;
               break;
            }
        }
        if(Cycle == false){
            return 0;
        }
        

        slow = dummy;  // Start at the temporary head
        Node prev=null;
        while(slow != fast){
            prev = fast;
            slow = slow.next;
            fast = fast.next;
        }
        prev.next =null;
        return 1;
    }

请注意，在您的主程序中，您不应尝试打印 null 引用的数据。只需打印预期为 null 的 next 属性：

        System.out.println(Head.next.next.next.next);

因为虚拟节点除了局部变量外没有被其他任何东西引用，它可以在removeCycle返回后被垃圾回收。

Answer 2

第一个 while 结束时

        if(slow == fast){
            Cycle =true;
           break;
        }

然后

    slow = Head;

没有改变任何东西，在这种情况下 (3->4->5->6) slow 已经是 head，slow==fast 仍然是 true 并且永远不会输入以下 while

    Node prev=null;  //to track previous of fast
        while(slow != fast){
             prev = fast;
             slow = slow.next;
             fast = fast.next;  //speed is same as slow now
         }
         prev.next =null;  

这意味着当您尝试分配 prev.next 时 prev 为空。

编辑： 如果没有虚拟对象，您的代码将无法运行的原因是，当没有不属于圆圈的元素时，第一个 while 在 slow==fast==Head 时停止，这意味着对 head 的下一个引用是丢失的。在 head 之前的元素处使用 dummy，slow==fast（如果没有非圆形元素，否则更早），以便 prev.next 可以重新分配为 null。而且，没有跳过第二个 while 的风险。 （这也可以通过使用 do-while 来避免。）