理解作业

Question

问题是：编写代码来围绕值x对链表进行分区，这样所有小于x的节点都会出现在大于或等于x的所有节点之前。

我得到了这个答案：

public Node partition(Node head, int x) {
    Node firstHead = null;
    Node secondHead = null;
    Node n = head;

    if (head == null) {
        return null;
    }

    while (n != null) {
        Node next = n.next;

        if (n.data < x) {
            n.next = firstHead; *
            firstHead = n;
        }
        else {
            n.next = secondHead;
            secondHead = n;
        }

        n = next; **
    } 

    if (firstHead == null) {
        return secondHead;
    }
    else {
        n = firstHead;

        while (n.next != null) {
            n = n.next;
        }

        n.next = secondHead;

        return firstHead;
    }
}

例如，如果列表是3 7 9 1 4 8 2 3并且您要在x = 4处进行分区，那么在第一个while循环内部第二个元素（7）将被设置为null（其中有一个星号）代码）然后n将再次设置7（其中有两颗星）。我不太确定这是如何工作的？是否创建了LinkedList中的另一个节点并且推回了null？对不起任何麻烦

Answer 1

你似乎遇到了几行问题，所以我会尝试解释

 n.next = firstHead; // This is the first step of an Insert, remove the next pointer.
                     // There may be (and is) a second level of looping where we
                     // find the new next value, but it might involve a second swap.
 firstHead = n;      // so make sure to store the current node.


 n = next;           // continue down the list of nodes to find the correct place for
                     // firstHead (if we have one).

如果我对你提出的要求有误，我会删除这个答案。

Answer 2

它不是“将7设置为null”，它只是将3的下一个指针设置为null，这意味着包含3的节点没有下一个节点。

要解释代码，请注意它尝试创建两个新的链接列表，一个从firsthead开始，第二个从secondhead开始。第一个链接价值低于x的元素，第二个等于或大于x的值。

首先两个链表都是空的（头为空）

在while循环中，它迭代原始列表，并且每个元素检查如果其数据小于x，则将其添加到第一个列表，如果不是，则将其添加到第二。看来你在理解这部分时遇到了麻烦。请注意，此行n.next = firsthead表示将n附加到第一个列表的头部。在此行之前，第一个列表从firsthead开始，现在从n和n点开始到firsthead。然后firsthead指针（应该显示列表的“头部”）更新以引用这个新头。

见这个草图：

之前：

firsthead
    \
     \           &
      _|                   (next)
        X (NULL)       [3]--------> [7]---------> [9]--------> ...

中间（在*行之后）：

firsthead
    \
     \           &                       &
      _|                   (next)
        X              [3]--------> X        [7]---------> [9]---------> ...

后：

firsthead
    \
     \                     &
      _|
       [3]---------> X          [7]--------> [9]--------> ...

你知道吗？现在第一个列表将成形，它得到了它的第一个项目。

第4次运行while循环后，它变为1，它变为：

firsthead
    \
     \
      _|
       [1]--------> [3]-------> X

第二个名单也是这样。

最后它有两个单独的列表，为了得到一个列表，它迭代到第一个结束，然后将它与第二个连接。

Answer 3

import java.io.*;
import java.lang.*;   
import java.util.*;
class ListNode
{
 int data;
 ListNode next;

  public ListNode(int data)
  {
    this.data=data;
  }

  public void setData(int data)
  {
    this.data=data;
  }

  public int getData()
  {
    return this.data;
  }
 public void setNext(ListNode next)
 {
   this.next= next;
 }

 public ListNode getNext()
  {
    return this.next;
  }
}

class LinkedList
 {
   ListNode head;
   int length =0;

   public LinkedList()
    {
      length=0;
    }
  public ListNode getHead()
   {
     return head; 
   }

  public int length()
 {
  return length;
 }

public void insertAtEnd(ListNode node)
 {
   String res="";
   if(head==null)
     head = node;
   else
      {
       ListNode p,q;
       for(p=head;(q=p.getNext())!=null;p=q);
              {p.setNext(node);}
      }

   length++;
  }
 public String toString()
 {
   String result="[";
   if(head==null)
      {
         return result+"]";
      }
  result= result+head.getData();
  ListNode temp = head.getNext();
  while(temp!=null)
 {
  result=result+","+temp.getData();
  temp=temp.getNext();
 }
 return result+"]";
 }

public void partition(int k)
{
 ListNode prev=null;
 ListNode pointer=head;
 ListNode innerPointer=head;
ListNode prevInnerPointer=null;
ListNode temp=null; 
int flag=0; 
 while(pointer!=null)
 {
  if(pointer.getData()<k && prev!=null)
     {
        temp=pointer;
        prev.setNext(pointer.getNext());
        pointer=prev.getNext();

      if(prevInnerPointer!=null)
          prevInnerPointer.setNext(temp);
           if(flag==0)
              {
               head=temp;
               flag=1;
               }     
      temp.setNext(innerPointer);
      prevInnerPointer=temp;
      innerPointer=temp.getNext();
    }
   else if(pointer.getData()<k)
          {
           head=pointer;
           flag=1;
           prevInnerPointer=innerPointer;
           innerPointer=innerPointer.getNext();
           prev=pointer;
           pointer=pointer.getNext();
          }        
   else
   {
   prev=pointer;
   pointer=pointer.getNext();
   }
 }
}
}
class START
{
 public static void main(String args[])throws IOException
  {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    LinkedList obj = new LinkedList();
    int i,num=0;
    int n = Integer.parseInt(br.readLine());
    System.out.println("Enter numbers ");       
    for(i=0;i<n;i++)
      {
        num=Integer.parseInt(br.readLine()); 
        ListNode a = new ListNode(num);
        obj.insertAtEnd(a);
      }
    System.out.println("length:"+obj.length());
    String res=obj.toString();
    System.out.println(res);  
    int k = Integer.parseInt(br.readLine()); 
    obj.partition(k);
    System.out.println(obj.toString());
 }

}