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;



}

在上述排序的insert方法中，如何降低这种双链表的复杂性，这是一个hackerrank问题，我在测试用例上超时，我需要帮助以降低此代码的时间复杂性。

Answer 1

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

让我们举个例子。列表= [（1），（4），（4）]（仅1个元素）。新节点是（4）。您的结果应为[（1），（4），（4），（4）]。但是，让我们遍历您的代码并检查会发生什么。最初的Leader =（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不为null；实际上是（4））。

在第3行（（4）>（1））。检查通行证。领导者=（1）。下一个=（4）。跳到第一行

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

在第3行（（4）>（4））。检查失败。输入第7行

在第7行，检查将失败（（4）.prev不为null；实际上是（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;
    }

如何减少代码中的双链表的复杂性

1 个答案: