链表根据主元切分成3段

把链表根据给定的主元重新排序，使得比主元小的在左侧，中间是主元，大的在右侧。

思路，不创建新的节点，但是利用原来结构创建3个新的链表，之后拼接，代码如下：

#include <iostream>
#include <utility>
#include <algorithm>

template<typename T>
struct Node {
    T value;
    struct Node* next {nullptr};
};

template<typename T>
Node<T>* Create(int N) {
    if (N <= 0) {
        return nullptr;
    }
    auto head = new Node<T>();
    std::cin >> head->value;
    auto p = head;
    for (int i = 1; i < N; ++i) {
        p->next = new Node<T>();
        p = p->next;
        std::cin >> p->value;
    }
    return head;
}

template<typename T>
void Print(Node<T>* head) {
    for (auto p = head; p != nullptr; p=p->next) {
        std::cout << p->value << " ";
    }
    std::cout << std::endl;
}

template<typename T>
void Partition(Node<T>* head, int pivot) {
    if (head == nullptr) {
        return;
    }
    auto small = new Node<T>();
    auto sp = small;
    auto equal = new Node<T>();
    auto ep = equal;
    auto big = new Node<T>();
    auto bp = big;
    for (auto p = head; p != nullptr; p = p->next) {
        if (p->value < pivot) {
            sp->next = p;
            sp = p;
        } else if (p->value == pivot) {
            ep->next = p;
            ep = p;
        } else {
            bp->next = p;
            bp = p;
        }
    }
    // 切断原来的连接
    sp->next = nullptr;
    ep->next = nullptr;
    bp->next = nullptr;
    // 拼接链表
    if (sp != small) {
        head = small->next;
        if (equal->next != nullptr) {
            sp->next = equal->next;
            ep->next = big->next;
        } else {
            sp->next = big->next;
        }
    } else if (equal != ep) {
        head = equal->next;
        ep->next = big->next;
    } else {
        head = big->next;
    }
    delete small;
    delete equal;
    delete big;
}

int main() {
    int n;
    std::cout << "input num: ";
    std::cin >> n;
    std::cout << "input datas: ";
    auto head = Create<int>(n);
    std::cout << "input pivot: ";
    std::cin >> n;
    std::cout << "after partition: " << std::endl;
    Partition<int>(head, n);
    Print<int>(head);
    return 0;
}