编写一个程序exp2-3.cpp，以单链表的首结点值x为基准将该单链表分割为两部分，使所有小于x的结点排在大于或等于x的结点之前

此题要求写一个程序exp2-3.cpp，以单链表的首结点值x为基准将该单链表分割为两部分，使所有小于x的结点排在大于等于x的结点之前，然后返回新链表的头结点。
具体操作是将所有小于x的结点按原有顺序放在大于等于x的结点之前。

相关问题

编写一个程序exp2-6.cpp，以单链表的首结点值2为基准将该单链表分割为两部分，使所有小于2的结点排在大于或等于2的结点之前。

在C++中编写这样的程序，我们需要首先创建一个单链表节点结构，并实现链表的基本操作，如遍历、插入和查找。然后我们可以在遍历过程中找到基准值2，通过两个指针分别跟踪小于和大于等于2的节点。

下面是一个简单的`exp2-6.cpp`示例代码：

#include <iostream>
using namespace std;

// 链表节点结构体
struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(NULL) {}
};

// 查找第一个大于等于基准值的节点
ListNode* findSplitNode(ListNode* head, int target) {
    if (head == nullptr || head->val >= target)
        return head;

    ListNode* current = head;
    while (current->next != nullptr && current->next->val < target) {
        current = current->next;
    }
    return current;
}

// 将链表分割成两部分
void splitList(ListNode* &head, ListNode* &splitNode) {
    if (head == nullptr)
        return;

    splitNode = findSplitNode(head, 2);
    if (splitNode == head) { // 如果没有找到大于等于2的节点，直接返回原链表
        cout << "No node with value greater than or equal to 2 found." << endl;
        return;
    }

    ListNode* smallerHead = head; // 创建新链表头，包含小于2的节点
    ListNode* smallerTail = head; // 小于2的链表尾部
    for (ListNode* temp = head; temp != splitNode; temp = temp->next) {
        smallerTail->next = temp;
        smallerTail = smallerTail->next;
    }
    smallerTail->next = nullptr; // 结束小于2的部分

    head = splitNode->next; // 原链表去掉已分割部分，剩余大于等于2的节点
    splitNode->next = nullptr; // 分割节点断开连接
}

int main() {
    // 这里假设有一个已经初始化好的链表实例，你可以根据实际需求替换这个部分
    ListNode* head = new ListNode(1); // 示例链表，[1 -> 0 -> -1 -> 4 -> 3]
    head->next = new ListNode(0);
    head->next->next = new ListNode(-1);
    head->next->next->next = new ListNode(4);
    head->next->next->next->next = new ListNode(3);

    ListNode* splitNode = nullptr;
    splitList(head, splitNode);

    // 输出结果
    cout << "Original list: ";
    printList(head);
    cout << "\nSmaller list: ";
    printList(smallerHead);

    return 0;
}

// 辅助函数，用于打印链表
void printList(ListNode* head) {
    while (head) {
        cout << head->val << " -> ";
        head = head->next;
    }
    cout << "nullptr" << endl;
}

运行此程序，它会根据链表的内容找到基准值2的位置并将其分割。如果没有大于等于2的节点，则会在主函数中给出提示。

编写一个程序exp2-6.cpp，以单链表的首结点值x为基将该单链表分割为两部分，使所有小于x的结点排在大于或等于x的结点之前

编写一个名为`exp2-6.cpp`的程序，用于基于给定的链表元素值`x`将其分割成两个子链表，可以按照以下步骤完成：

首先，我们需要定义一个简单的单链表结构，包含节点数据和指向下一个节点的指针：

#include <iostream>
using namespace std;

// 定义链表节点结构体
struct ListNode {
    int val;           // 节点值
    ListNode* next;     // 指向下一个节点的指针
    ListNode(int x) : val(x), next(nullptr) {}  // 构造函数
};

接下来，我们创建一个函数来分割链表：

ListNode* splitList(ListNode* head, int x) {
    if (head == nullptr || head->next == nullptr) {  // 如果链表为空或只有一个元素
        return head;
    }

    ListNode* smallerHead = new ListNode(head->val);  // 新链表头，保存小于x的节点
    ListNode* largerHead = nullptr;                  // 新链表头，保存大于等于x的节点

    // 遍历链表，根据值大小分隔节点
    ListNode* current = head;
    while (current != nullptr) {
        if (current->val < x) {  // 小于x，添加到smallerHead链表
            smallerHead->next = current;
            smallerHead = smallerHead->next;
        } else {               // 大于等于x，开始新链表
            if (largerHead == nullptr) {
                largerHead = current;
            }
            // 否则直接连接到现有较大的链表头部
            current->next = nullptr;
            largerHead->next = current;
        }
        current = current->next;
    }

    return smallerHead ? smallerHead : largerHead;  // 返回较小的链表头
}

最后，在main函数中测试这个函数：

int main() {
    // 创建并初始化链表示例
    ListNode* list = new ListNode(4);
    list->next = new ListNode(2);
    list->next->next = new ListNode(9);
    list->next->next->next = new ListNode(5);
    list->next->next->next->next = new ListNode(1);

    int x = 5;  // 分割值
    ListNode* result = splitList(list, x);

    // 输出结果链表
    while (result != nullptr) {
        cout << result->val << " ";
        result = result->next;
    }

    return 0;
}

运行上述代码后，你会得到一个小于5的元素组成的链表和一个大于等于5的元素组成的链表。