C++循环链表分割：优化rcl_split函数

本文介绍一个优化后的C++ rcl_split 函数，用于将一个循环链表分割成两个新的循环链表。该函数使用了 cur 代替 current，pre 代替 previous，以及 NULL 代替 nullptr，以提高代码的可读性和效率。

以下是经过修改的 rcl_split 函数的代码：

#include <iostream>

typedef struct Node {
    int data;
    struct Node* next;
} chainList;

void rcl_split(chainList* h, chainList*& h1, chainList*& h2) {
    if (h == NULL) {
        h1 = NULL;
        h2 = NULL;
        return;
    }

    chainList* cur = h;
    chainList* cur1 = NULL;
    chainList* cur2 = NULL;
    chainList* lastNode1 = NULL;
    chainList* lastNode2 = NULL;

    int index = 1; // 计数器，用于记录当前节点的序号

    do {
        if (index % 2 == 1) {
            if (cur1 == NULL) {
                cur1 = new chainList;
                cur1->data = cur->data;
                cur1->next = NULL;
                lastNode1 = cur1;
                h1 = cur1;
            } else {
                lastNode1->next = new chainList;
                lastNode1 = lastNode1->next;
                lastNode1->data = cur->data;
                lastNode1->next = NULL;
            }
        } else {
            if (cur2 == NULL) {
                cur2 = new chainList;
                cur2->data = cur->data;
                cur2->next = NULL;
                lastNode2 = cur2;
                h2 = cur2;
            } else {
                lastNode2->next = new chainList;
                lastNode2 = lastNode2->next;
                lastNode2->data = cur->data;
                lastNode2->next = NULL;
            }
        }

        cur = cur->next;
        index++;
    } while (cur != h);
    
    // 将循环链表的最后一个节点与第一个节点连接起来
    lastNode1->next = h1;
    lastNode2->next = h2;
}

代码说明：

该函数接受三个参数：
- h：原始循环链表的头指针
- h1：分割后的第一个循环链表的头指针 (通过引用传递)
- h2：分割后的第二个循环链表的头指针 (通过引用传递)
函数首先检查原始链表是否为空。如果为空，则将 h1 和 h2 设置为 NULL 并返回。
接下来，函数使用 cur 指针遍历原始链表，并使用 index 计数器记录当前节点的序号。
根据 index 的奇偶性，将节点依次插入到 h1 或 h2 链表中。
在插入节点时，函数维护了每个链表的最后一个节点 (lastNode1 和 lastNode2)，以便将最后一个节点与第一个节点连接起来，形成循环链表的闭环。

总结：

这个优化后的 rcl_split 函数使用更简洁的变量名，例如 cur 和 pre，并使用 NULL 代替 nullptr，提高了代码的可读性。该函数有效地将一个循环链表分割成两个新的循环链表，可以应用于各种链表操作场景。