为什么在划分链表时会进入无限循环？

Question

This is a common problem of partitioning a linked list into two parts. The list with nodes smaller than x will come first and the list of nodes larger than x will come after.

My question is - why do i need to set after.next to null after creating my two separate linked lists? Without setting it to null, I enter an infinite loop when trying to print this list. My debugger shows that before_head.next has a never-ending list of nodes attached to it...

public Node partition(Node head, int x){
  Node before_head=new Node(0);
  Node before=before_head;
  Node after_head=new Node(0);
  Node after=after_head;

  while(head != null){
    if(head.val < x){
      before.next=head;
      before=before.next;
    else{
      after.next=head;
      after=after.next;
     }
    head=head.next;
   }

   after.next=null;
   before.next=after_head;

   return before_head.next;
}

Answer 1

why do i need to set after.next to null after creating my two separate linked lists?

The last node of a linked list doesn't have a next node. In a linked list representation such as yours, that takes the form of the last node's next reference being null.

You are rearranging the existing nodes of the list by changing their next references. At the end of that process, after is a reference to the last node, therefore its next reference needs to be null. If it was also the last node in the original order then all is well -- its next reference is already null. If after was not the last node in the original order, however, then after.next will refer to one of the other nodes until you set it null. And whatever other node that is, it comes before after in the new order, forming a loop.

---

Note also that

 before.next=after_head;

appears to be wrong. after_head is the dummy head node of the second partition, so you do not want to include it in the new list. I think you want

    before.next = after_head.next;