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

复制代码
#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. 主要逻辑:
    • 使用两个指针 prevcurr 遍历链表。
    • 考虑三种插入情况: a. insertVal 在当前范围内(prev->val <= insertVal <= curr->val) b. insertVal 在链表的最大值和最小值之间(跨越链表首尾) c. 所有节点值相同,可以在任意位置插入
  3. 遍历过程:
    • 使用 do-while 循环确保至少遍历一次,并在回到头节点时停止。
  4. 插入操作:
    • 一旦找到合适的插入位置,创建新节点并插入。
  5. 边界情况:
    • 如果遍历完整个链表还没插入,说明所有节点值相同,此时在任意位置插入即可。
相关推荐
岁忧34 分钟前
(LeetCode 面试经典 150 题 ) 11. 盛最多水的容器 (贪心+双指针)
java·c++·算法·leetcode·面试·go
chao_78937 分钟前
二分查找篇——搜索旋转排序数组【LeetCode】两次二分查找
开发语言·数据结构·python·算法·leetcode
秋说3 小时前
【PTA数据结构 | C语言版】一元多项式求导
c语言·数据结构·算法
Maybyy3 小时前
力扣61.旋转链表
算法·leetcode·链表
谭林杰4 小时前
B树和B+树
数据结构·b树
卡卡卡卡罗特5 小时前
每日mysql
数据结构·算法
chao_7895 小时前
二分查找篇——搜索旋转排序数组【LeetCode】一次二分查找
数据结构·python·算法·leetcode·二分查找
lifallen6 小时前
Paimon 原子提交实现
java·大数据·数据结构·数据库·后端·算法
lixzest6 小时前
C++ Lambda 表达式详解
服务器·开发语言·c++·算法
EndingCoder6 小时前
搜索算法在前端的实践
前端·算法·性能优化·状态模式·搜索算法