用于围绕给定值对链表进行分区并保持原始顺序的Java程序

给定一个链表和一个值 x，对它进行分区，使得所有小于 x 的节点首先出现，然后是所有值等于 x 的节点，最后是值大于或等于 x 的节点。应保留三个分区中每个分区中节点的原始相对顺序。隔板必须工作到位。
例子：

Input: 1->4->3->2->5->2->3, 
        x = 3
Output: 1->2->2->3->3->4->5

Input: 1->4->2->10 
        x = 3
Output: 1->2->4->10

Input: 10->4->20->10->3 
        x = 3
Output: 3->10->4->20->10 

为了解决这个问题，我们可以使用快速排序的分区方法，但这不会保留两个分区中每个分区中节点的原始相对顺序。
下面是解决这个问题的算法：

1. 将以下三个链表的第一个和最后一个节点初始化为NULL。
   • 小于 x 的值的链表。
   • 等于 x 的值的链接列表。
   • 大于 x 的值的链接列表。
2. 现在遍历原始链表。如果节点的值小于 x，则将其附加到较小列表的末尾。如果该值等于 x，则在等号列表的末尾。如果一个值更大，则在更大列表的末尾。
3. 现在连接三个列表。

下面是上述思想的实现。

Java

// Java program to partition a 
// linked list around a given value. 
class GfG{ 
  
// Link list Node 
static class Node 
{ 
    int data; 
    Node next; 
}
  
// A utility function to create 
// a new node 
static Node newNode(int data) 
{ 
    Node new_node = new Node(); 
    new_node.data = data; 
    new_node.next = null; 
    return new_node; 
} 
  
// Function to make two separate lists 
// and return head after concatenating 
static Node partition(Node head, int x) 
{     
    /* Let us initialize first and last 
       nodes of three linked lists 
       1) Linked list of values smaller 
          than x. 
       2) Linked list of values equal 
          to x. 
       3) Linked list of values greater 
          than x.*/
    Node smallerHead = null, 
         smallerLast = null; 
    Node greaterLast = null, 
         greaterHead = null; 
    Node equalHead = null, 
         equalLast =null; 
  
    // Now iterate original list and connect 
    // nodes of appropriate linked lists. 
    while (head != null) 
    { 
        // If current node is equal to x, 
        // append it to the list of x values 
        if (head.data == x) 
        { 
            if (equalHead == null) 
                equalHead = equalLast = head; 
            else
            { 
                equalLast.next = head; 
                equalLast = equalLast.next; 
            } 
        } 
  
        // If current node is less than X, 
        // append it to the list of smaller 
        // values 
        else if (head.data < x) 
        { 
            if (smallerHead == null) 
                smallerLast = smallerHead = head; 
            else
            { 
                smallerLast.next = head; 
                smallerLast = head; 
            } 
        } 
  
        // Append to the list of greater values 
        else 
        { 
            if (greaterHead == null) 
                greaterLast = greaterHead = head; 
            else
            { 
                greaterLast.next = head; 
                greaterLast = head; 
            } 
        } 
        head = head.next; 
    } 
  
    // Fix end of greater linked list to 
    // NULL if this list has some nodes 
    if (greaterLast != null) 
        greaterLast.next = null; 
  
    // Connect three lists 
  
    // If smaller list is empty 
    if (smallerHead == null) 
    { 
        if (equalHead == null) 
            return greaterHead; 
        equalLast.next = greaterHead; 
        return equalHead; 
    } 
  
    // If smaller list is not empty 
    // and equal list is empty 
    if (equalHead == null) 
    { 
        smallerLast.next = greaterHead; 
        return smallerHead; 
    } 
  
    // If both smaller and equal list 
    // are non-empty 
    smallerLast.next = equalHead; 
    equalLast.next = greaterHead; 
    return smallerHead; 
} 
  
// Function to print linked list 
static void printList(Node head) 
{ 
    Node temp = head; 
    while (temp != null) 
    { 
        System.out.print(temp.data + 
                         " "); 
        temp = temp.next; 
    } 
} 
  
// Driver code 
public static void main(String[] args) 
{ 
    // Start with the empty list 
    Node head = newNode(10); 
    head.next = newNode(4); 
    head.next.next = newNode(5); 
    head.next.next.next = newNode(30); 
    head.next.next.next.next = 
    newNode(2); 
    head.next.next.next.next.next = 
    newNode(50); 
  
    int x = 3; 
    head = partition(head, x); 
    printList(head); 
}
} 
// This code is contributed by Prerna saini.

输出：

2 10 4 5 30 50

有关详细信息，请参阅有关围绕给定值对链表进行分区并保持原始顺序的完整文章！