在一个循环链表中，结点的值递增排序已经设计一个算法，在该循环链表中插入节点，保证插入节点之后的循环链表依旧是排序的。

#include <iostream>

// 定义链表节点结构
class Node {
public:
    int val;    // 节点的值
    Node* next; // 指向下一个节点的指针
    
    Node(int _val) : val(_val), next(nullptr) {} // 构造函数，初始化节点
};

// 在有序循环链表中插入节点的函数
Node* insert(Node* head, int insertVal) {
    // 如果链表为空，创建一个新节点并使其自环
    if (head == nullptr) {
        Node* newNode = new Node(insertVal); // 创建新节点
        newNode->next = newNode; // 使节点自环
        return newNode; // 返回新创建的节点作为头节点
    }
    
    // 如果链表只有一个节点
    if (head->next == head) {
        Node* newNode = new Node(insertVal); // 创建新节点
        head->next = newNode; // 头节点指向新节点
        newNode->next = head; // 新节点指向头节点，形成循环
        return head; // 返回原头节点
    }
    
    Node* prev = head; // 前一个节点，初始为头节点
    Node* curr = head->next; // 当前节点，初始为头节点的下一个节点
    bool inserted = false; // 标记是否已插入新节点
    
    // 遍历链表一周
    do {
        // 情况1：insertVal 在当前范围内
        if (prev->val <= insertVal && insertVal <= curr->val) {
            inserted = true; // 标记为已找到插入位置
        }
        // 情况2：insertVal 在链表的最大值和最小值之间（跨越链表首尾）
        else if (prev->val > curr->val) {
            if (insertVal >= prev->val || insertVal <= curr->val) {
                inserted = true; // 标记为已找到插入位置
            }
        }
        
        if (inserted) {
            Node* newNode = new Node(insertVal); // 创建新节点
            prev->next = newNode; // 前一个节点指向新节点
            newNode->next = curr; // 新节点指向当前节点
            return head; // 返回头节点
        }
        
        prev = curr; // 移动前一个节点指针
        curr = curr->next; // 移动当前节点指针
    } while (prev != head); // 当回到头节点时停止循环
    
    // 如果遍历完整个链表还没插入，说明所有节点值相同，在任意位置插入即可
    Node* newNode = new Node(insertVal); // 创建新节点
    prev->next = newNode; // 将新节点插入到最后一个节点之后
    newNode->next = curr; // 新节点指向头节点，保持循环
    
    return head; // 返回头节点
}

// 打印循环链表
void printList(Node* head) {
    if (head == nullptr) return; // 如果链表为空，直接返回
    
    Node* curr = head; // 从头节点开始
    do {
        std::cout << curr->val << " "; // 打印当前节点的值
        curr = curr->next; // 移动到下一个节点
    } while (curr != head); // 当回到头节点时停止
    std::cout << std::endl; // 换行
}

int main() {
    // 创建一个有序的循环链表：1 -> 3 -> 5 -> 1
    Node* head = new Node(1);
    head->next = new Node(3);
    head->next->next = new Node(5);
    head->next->next->next = head;
    
    std::cout << "原始链表: ";
    printList(head);
    
    // 插入值4
    head = insert(head, 4);
    std::cout << "插入4后: ";
    printList(head);
    
    // 插入值0
    head = insert(head, 0);
    std::cout << "插入0后: ";
    printList(head);
    
    // 插入值6
    head = insert(head, 6);
    std::cout << "插入6后: ";
    printList(head);
    
    return 0;
}

这个算法的关键点如下：

1. 特殊情况处理：
   • 如果链表为空，创建一个新节点并使其自环。
   • 如果链表只有一个节点，直接在其后插入新节点。
2. 主要逻辑：
   • 使用两个指针 prev 和 curr 遍历链表。
   • 考虑三种插入情况： a. insertVal 在当前范围内（prev->val <= insertVal <= curr->val） b. insertVal 在链表的最大值和最小值之间（跨越链表首尾） c. 所有节点值相同，可以在任意位置插入
3. 遍历过程：
   • 使用 do-while 循环确保至少遍历一次，并在回到头节点时停止。
4. 插入操作：
   • 一旦找到合适的插入位置，创建新节点并插入。
5. 边界情况：
   • 如果遍历完整个链表还没插入，说明所有节点值相同，此时在任意位置插入即可。