README.md

剑指 Offer II 029. 排序的循环链表

题目描述

给定循环升序列表中的一个点，写一个函数向这个列表中插入一个新元素 insertVal ，使这个列表仍然是循环升序的。

给定的可以是这个列表中任意一个顶点的指针，并不一定是这个列表中最小元素的指针。

如果有多个满足条件的插入位置，可以选择任意一个位置插入新的值，插入后整个列表仍然保持有序。

如果列表为空（给定的节点是 null），需要创建一个循环有序列表并返回这个节点。否则。请返回原先给定的节点。

 

示例 1：

 

输入：head = [3,4,1], insertVal = 2
输出：[3,4,1,2]
解释：在上图中，有一个包含三个元素的循环有序列表，你获得值为 3 的节点的指针，我们需要向表中插入元素 2 。新插入的节点应该在 1 和 3 之间，插入之后，整个列表如上图所示，最后返回节点 3 。

示例 2：

输入：head = [], insertVal = 1
输出：[1]
解释：列表为空（给定的节点是 null），创建一个循环有序列表并返回这个节点。

示例 3：

输入：head = [1], insertVal = 0
输出：[1,0]

 

提示：

• 0 <= Number of Nodes <= 5 * 10^4
• -10^6 <= Node.val <= 10^6
• -10^6 <= insertVal <= 10^6

 

注意：本题与主站 708 题相同： https://leetcode-cn.com/problems/insert-into-a-sorted-circular-linked-list/

解法

1. 头节点如果为空，直接返回 node
2. 如果 insertVal 在链表的最小值和最大值之间，找到合适的位置插入
3. 如果 insertVal 小于链表的最小值或大于链表的最大值，则在头节点和尾节点之间插入
4. 链表的所有值和 insertVal 都相等，任意位置插入

Python3

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, next=None):
        self.val = val
        self.next = next
"""

class Solution:
    def insert(self, head: 'Node', insertVal: int) -> 'Node':
        node = Node(insertVal)
        if head is None:
            node.next = node
            return node
        p = head
        while True:
            if p.val <= insertVal and insertVal <= p.next.val or \
                p.val > p.next.val and (insertVal <= p.next.val or insertVal >= p.val) or \
                p.next == head:

                node.next = p.next
                p.next = node
                break

            p = p.next
        return head

Java

/*
// Definition for a Node.
class Node {
    public int val;
    public Node next;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _next) {
        val = _val;
        next = _next;
    }
};
*/

class Solution {
    public Node insert(Node head, int insertVal) {
        Node node = new Node(insertVal);
        if (head == null) {
            node.next = node;
            return node;
        }
        Node p = head;
        for (;;) {
            if (p.val <= insertVal && insertVal <= p.next.val ||
                    p.val > p.next.val && (insertVal <= p.next.val || insertVal >= p.val) ||
                    p.next == head) {
                node.next = p.next;
                p.next = node;
                break;
            }
            p = p.next;
        }
        return head;
    }
}

C++

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;

    Node() {}

    Node(int _val) {
        val = _val;
        next = NULL;
    }

    Node(int _val, Node* _next) {
        val = _val;
        next = _next;
    }
};
*/

class Solution {
public:
    Node* insert(Node* head, int insertVal) {
        Node* insert = new Node(insertVal);
        if (head == nullptr) {
            head = insert;
            head->next = head;
        } else if (head->next == nullptr) {
            head->next = insert;
            insert->next = head;
        } else {
            insertCore(head, insert);
        }

        return head;
    }

    void insertCore(Node* head, Node* insert) {
        Node* cur = head;
        Node* maxNode = head;
        Node* next = head->next;

        while (!(cur->val <= insert->val && insert->val <= next->val) && next != head) {
            cur = cur->next;
            next = next->next;

            if (cur->val >= maxNode->val)
                maxNode = cur;
        }

        if (cur->val <= insert->val && insert->val <= next->val) {
            insert->next = next;
            cur->next = insert;
        } else {
            insert->next = maxNode->next;
            maxNode->next = insert;

        }

    }
};

...