围绕给定值对链表进行分区，如果我们不关心使列表的元素“稳定”

给定一个链表和一个值 x，围绕一个值 x 划分一个链表，使得所有小于 x 的节点排在所有大于或等于 x 的节点之前。如果 x 包含在列表中，则 x 的值只需在小于 x 的元素之后（见下文）。分区元素 x 可以出现在“右分区”的任何位置；它不需要出现在左右分区之间。
类似问题：围绕给定值对链表进行分区并保持原始顺序
例子：

Input :  3 -> 5 -> 10 -> 2 -> 8 -> 2 -> 1 
         x = 5
Output : 1-> 2-> 2-> 3-> 5-> 10-> 8

如果我们不关心使列表的元素“稳定”，那么我们可以通过增加列表的头部和尾部来重新排列元素。
在这种方法中，我们开始一个“新”列表（使用现有节点）。大于枢轴元素的元素放在尾部，较小的元素放在头部。每次我们插入一个元素时，我们都会更新头部或尾部。
下面是上述想法的实现。

C++

// C++ program to partition a linked list around a
// given value.
#include
using namespace std;
 
/* Link list Node */
struct Node
{
    int data;
    struct Node* next;
};
 
// A utility function to create a new node
Node *newNode(int data)
{
    struct Node* new_node = new Node;
    new_node->data  = data;
    new_node->next = NULL;
    return new_node;
}
 
// Function to make a new list(using the existing
// nodes) and return head of new list.
struct Node *partition(struct Node *head, int x)
{
    /* Let us initialize start and tail nodes of
    new list */
    struct Node *tail = head;
 
    // Now iterate original list and connect nodes
    Node *curr = head;
    while (curr != NULL)
    {
        struct Node *next = curr->next;
        if (curr->data < x)
        {
            /* Insert node at head. */
            curr->next = head;
            head = curr;
        }
 
        else // Append to the list of greater values
        {
            /* Insert node at tail. */
            tail->next = curr;
            tail = curr;
        }
        curr = next;
    }
    tail->next = NULL;
 
    // The head has changed, so we need
    // to return it to the user.
    return head;
}
 
/* Function to print linked list */
void printList(struct Node *head)
{
    struct Node *temp = head;
    while (temp != NULL)
    {
        printf("%d  ", temp->data);
        temp = temp->next;
    }
}
 
// Driver program to run the case
int main()
{
    /* Start with the empty list */
    struct Node* head = newNode(3);
    head->next = newNode(5);
    head->next->next = newNode(8);
    head->next->next->next = newNode(2);
    head->next->next->next->next = newNode(10);
    head->next->next->next->next->next = newNode(2);
    head->next->next->next->next->next->next = newNode(1);
 
    int x = 5;
    head = partition(head, x);
    printList(head);
    return 0;
}

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 a new list
// (using the existing nodes) and
// return head of new list.
static Node partition(Node head, int x)
{
    /* Let us initialize start and tail nodes of
    new list */
    Node tail = head;
 
    // Now iterate original list and connect nodes
    Node curr = head;
    while (curr != null)
    {
        Node next = curr.next;
        if (curr.data < x)
        {
            /* Insert node at head. */
            curr.next = head;
            head = curr;
        }
 
        else // Append to the list of greater values
        {
            /* Insert node at tail. */
            tail.next = curr;
            tail = curr;
        }
        curr = next;
    }
    tail.next = null;
 
    // The head has changed, so we need
    // to return it to the user.
    return head;
}
 
/* 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(3);
    head.next = newNode(5);
    head.next.next = newNode(8);
    head.next.next.next = newNode(2);
    head.next.next.next.next = newNode(10);
    head.next.next.next.next.next = newNode(2);
    head.next.next.next.next.next.next = newNode(1);
 
    int x = 5;
    head = partition(head, x);
    printList(head);
}
}
 
// This code is contributed by prerna saini

Python3

# Python3 program to partition a
# linked list around a given value.
import math
 
# Link list Node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
# A utility function to create a new node
def newNode(data):
    new_node = Node(data)
    new_node.data = data
    new_node.next = None
    return new_node
 
# Function to make a new list
# (using the existing nodes)
# and return head of new list.
def partition(head, x):
     
    # Let us initialize start and
    # tail nodes of new list
    tail = head
 
    # Now iterate original list
    # and connect nodes
    curr = head
    while (curr != None):
        next = curr.next
        if (curr.data < x):
             
            # Insert node at head.
            curr.next = head
            head = curr
         
        else:
             
            # Append to the list of greater values
            # Insert node at tail.
            tail.next = curr
            tail = curr
         
        curr = next
     
    tail.next = None
 
    # The head has changed, so we need
    # to return it to the user.
    return head
 
# Function to print linked list
def printList(head):
    temp = head
    while (temp != None):
        print(temp.data, end = " ")
        temp = temp.next
     
# Driver Code
if __name__=='__main__':
     
    # Start with the empty list
    head = newNode(3)
    head.next = newNode(5)
    head.next.next = newNode(8)
    head.next.next.next = newNode(2)
    head.next.next.next.next = newNode(10)
    head.next.next.next.next.next = newNode(2)
    head.next.next.next.next.next.next = newNode(1)
 
    x = 5
    head = partition(head, x)
    printList(head)
     
# This code is contributed by AbhiThakur

C#

// C# program to partition a linked list
// around a given value.
using System;
 
class GfG
{
 
/* Link list Node */
class Node
{
    public int data;
    public 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 a new list
// (using the existing nodes) and
// return head of new list.
static Node partition(Node head, int x)
{
    /* Let us initialize start and 
    tail nodes of new list */
    Node tail = head;
 
    // Now iterate original list
    // and connect nodes
    Node curr = head;
    while (curr != null)
    {
        Node next = curr.next;
        if (curr.data < x)
        {
            /* Insert node at head. */
            curr.next = head;
            head = curr;
        }
 
        else // Append to the list of greater values
        {
            /* Insert node at tail. */
            tail.next = curr;
            tail = curr;
        }
        curr = next;
    }
    tail.next = null;
 
    // The head has changed, so we need
    // to return it to the user.
    return head;
}
 
/* Function to print linked list */
static void printList(Node head)
{
    Node temp = head;
    while (temp != null)
    {
        Console.Write(temp.data + " ");
        temp = temp.next;
    }
}
 
// Driver code
public static void Main(String[] args)
{
    /* Start with the empty list */
    Node head = newNode(3);
    head.next = newNode(5);
    head.next.next = newNode(8);
    head.next.next.next = newNode(2);
    head.next.next.next.next = newNode(10);
    head.next.next.next.next.next = newNode(2);
    head.next.next.next.next.next.next = newNode(1);
 
    int x = 5;
    head = partition(head, x);
    printList(head);
}
}
 
// This code has been contributed by Rajput-Ji

Javascript

 
// JavaScript program to partition a linked list
// around a given value.
 
    /* Link list Node */
     class Node {
            constructor(val) {
                this.data = val;
                this.next = null;
            }
        }
      
    // A utility function to create a new node
    function newNode(data) {
    var new_node = new Node();
        new_node.data = data;
        new_node.next = null;
        return new_node;
    }
 
    // Function to make a new list
    // (using the existing nodes) and
    // return head of new list.
    function partition(head , x) {
        /*
         * Let us initialize start and tail nodes of new list
         */
         var tail = head;
 
        // Now iterate original list and connect nodes
        var curr = head;
        while (curr != null) {
        var next = curr.next;
            if (curr.data < x) {
                /* Insert node at head. */
                curr.next = head;
                head = curr;
            }
 
            else // Append to the list of greater values
            {
                /* Insert node at tail. */
                tail.next = curr;
                tail = curr;
            }
            curr = next;
        }
        tail.next = null;
 
        // The head has changed, so we need
        // to return it to the user.
        return head;
    }
 
    /* Function to print linked list */
    function printList(head) {
        var temp = head;
        while (temp != null) {
            document.write(temp.data + " ");
            temp = temp.next;
        }
    }
 
    // Driver code
     
        /* Start with the empty list */
        var head = newNode(3);
        head.next = newNode(5);
        head.next.next = newNode(8);
        head.next.next.next = newNode(2);
        head.next.next.next.next = newNode(10);
        head.next.next.next.next.next = newNode(2);
        head.next.next.next.next.next.next = newNode(1);
 
        var x = 5;
        head = partition(head, x);
        printList(head);
 
// This code contributed by Rajput-Ji
 

输出：

1  2  2  3  5  8  10  

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。