合並K個排序的鏈表，為什么復雜度為O（N * K * K），而不是O（N * K）

Question

我有以下解決方案，但我從其他審閱者那里聽到，它是O(N * K * K) ，而不是O(N * K) ，其中N是K列表的（最大）長度， K是數字列表。 例如，給定列表[1, 2, 3]和[4, 5] ， N為3， K為2。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    private void advance(final ListNode[] listNodes, final int index) {
        listNodes[index] = listNodes[index].next;
    }

    public ListNode mergeKLists(final ListNode[] listNodes) {
        ListNode sortedListHead = null;
        ListNode sortedListNode = null;

        int associatedIndex;

        do {            
            int minValue = Integer.MAX_VALUE;
            associatedIndex = -1;

            for (int listIndex = 0; listIndex < listNodes.length; listIndex++) {
                final ListNode listNode = listNodes[listIndex];

                if (listNode != null && listNode.val < minValue) {                
                    minValue = listNode.val;
                    associatedIndex = listIndex;
                }
            }

            if (associatedIndex != -1) {
                if (sortedListNode == null) {
                    sortedListNode = new ListNode(minValue);
                    sortedListHead = sortedListNode;
                }
                else {
                    sortedListNode.next = new ListNode(minValue);
                    sortedListNode = sortedListNode.next;
                }

                advance(listNodes, associatedIndex);
            }
        }
        while (associatedIndex != -1);

        return sortedListHead;
    }
}

我的理由是， do-while循環的主體將發生N次（因為最長的列表被迭代通過時， do-while循環的停止條件已滿足），而do-while循環的for循環的主體將發生K次。 （ listNodes.length ）， listNodes.length O(n * k) 。

為什么上述解決方案為O(n * k * k) ？

Answer 1

您的結果列表最多包含n * k個項目。 將這些項目的每一個相加會花費O（ k ）（內部循環執行k次迭代以檢查每個列表的頭部）。 因此，總運行時間為O（ n * k * k ）。