如何降低代码中的双向链表复杂度

Question

// Complete the sortedInsert function below.

/*
 * For your reference:
 *
 * DoublyLinkedListNode {
 *     int data;
 *     DoublyLinkedListNode next;
 *     DoublyLinkedListNode prev;
 * }
 *
 */
static DoublyLinkedListNode sortedInsert(DoublyLinkedListNode head, int data) {
    DoublyLinkedListNode Leader=head;
    DoublyLinkedListNode newNode = new DoublyLinkedListNode(data);
    while(Leader.next!=null){

        if(data>Leader.data){
            Leader = Leader.next;
        } 
        else {
            if(Leader.prev == null) {
                newNode.next = Leader;
                Leader.prev = newNode;
                head = newNode;
                return head;
            } 
        }

    }
    if(Leader.next == null) {
        if(data<Leader.data) {
            newNode.prev = Leader.prev;
            newNode.next = Leader;
            Leader.prev.next = newNode;
            return head;
        } else {
            newNode.prev = Leader;
            Leader.next = newNode;
            return head;
        }


    }
       return head;



}

在上面排序的插入方法中，如何降低这种双向链表的复杂性，这是一个hackerrank问题，我在测试用例中超时了，我需要帮助来降低这段代码的时间复杂度。

Answer 1

您的代码永远不会退出 while 循环。

让我们举个例子。 List = [(1), (4), (4)]（只有 1 个元素）。新节点是 (4)。你的结果应该是 [(1), (4), (4), (4)]。但是让我们看看你的代码，看看会发生什么。最初的领导者 = (1)

while(Leader.next!=null){ // 1

    if(data>Leader.data){  // 3
        Leader = Leader.next;
    } 
    else { // 6
        if(Leader.prev == null) { // 7
            newNode.next = Leader;
            Leader.prev = newNode;
            head = newNode;
            return head;
        } 
    }

}

在第 1 行检查将通过（因为 (1).next 不为空；实际上是 (4)）。

在第 3 行 ((4) > (1))。检查通行证。领导者 = (1).next = (4)。跳转到第 1 行

在第 1 行检查将通过（因为 (4).next 不为空；实际上是 (4)）。

在第 3 行 ((4) > (4))。检查失败。进入第 7 行

在第 7 行检查将失败（(4).prev 不为空；实际上是 (4) - 1st 4）。 Leader 不会发生更新。领导者将保持不变，您将从这里进入无限循环。

你必须照顾好这个。也许问题的讨论页面会有所帮助。但是一定要试一试。

我自己的尝试如下：

static DoublyLinkedListNode sortedInsert(DoublyLinkedListNode head, int data) {
        DoublyLinkedListNode n = new DoublyLinkedListNode();
        n.data = data;
        DoublyLinkedListNode curr = head;
        if (head == null) {
            return n;
        }
        // if given node is smaller than 1st node
        if (data < curr.data) {
            n.next = curr;
            return n;
        }
        // find first node greater than given node
        while (curr.next != null && curr.data < data) {
            curr = curr.next;
        }
        // reached to the end.
        if (curr.next == null && data >= curr.data) {
            curr.next = n;
        } else { // found the 1st node which is greater than given node
            curr.prev.next = n;
            n.next = curr;
        }
        return head;
    }