LeetCode-Merge k Sorted Lists

算法分析与设计，第7周博客

23. Merge k Sorted Lists

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

题意是，给出k个已排好序的链表，把它们合并成一个链表。看完题目以后，可能不是很清楚，但是看到给出的函数接口会更加的明白。所给出的代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        
    }
}

给出了k个链表的头节点组成的数组lists，其中的每个元素是每个链表的head节点，这样一来，题目的意思就很清楚了。

首先，考虑最简单的办法，每次取数组里面最小的那个，放在已排序的链表的尾部，然后再把这个节点改成它的下一个节点放在数组里，如此反复直到每个链表都到了尾部。这个方法的代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    ListNode head(ListNode[] cur) {
        int k = cur.length;
        ListNode res = new ListNode(Integer.MAX_VALUE);
        int min = 0;
        for (int i = 0; i < k; ++i) {
            if (cur[i] != null && (cur[min] == null || cur[i].val < cur[min].val)) {
                min = i;
            }
        }
        res = cur[min];
        cur[min] = cur[min].next;
        return res;
    }
    
    boolean over(ListNode[] cur) {
        for (int i = 0; i < cur.length; ++i) {
            if (cur[i] != null)
                return false;
        }
        return true;
    }
    
    public ListNode mergeKLists(ListNode[] lists) {
        int k = lists.length;
        ListNode head = null;
        ListNode cur = null; 
        while (!over(lists)) {
            if (head == null) {
                cur = head = head(lists);
            } else {
                cur.next = head(lists);
                cur = cur.next;
            }
        }
        return head;
    }
}

来看下这个算法的时间复杂度，设数组的大小为k，总的链表的长度为n，每选出一个节点，都要调用一次head函数，head函数的时间复杂度是O(k)，一共有n个节点，所以总的时间复杂度是O(n*k)。这个算法并不是一个非常有效率的，在测试的时候也确实超时了。

我们的思路是没有问题的，那么，怎么能够降低这个算法的时间复杂度呢。如果降低head函数的时间复杂度呢？在之前的代码中，head函数是通过遍历的方式来得到最小的节点，所以时间复杂度是O(k)。因为我们每次都只需要最小的节点，而不需要保持整个数组的有序性，所以很容易就可以联想到最小堆。最小堆是这样的一棵二叉树，每个父节点都比左节点和右节点要小。最重要的是当我们取出整个最小堆的根节点，并插入一个新的节点时，所需要的时间复杂度是O(long(k))。这样，我们就把head函数的时间复杂度从O(k)缩小到了O(log(k))。所需要的就是维护一个最小堆。维护最小堆的代码如下：

void rebulidHeap(ListNode[] list, int s) {
        int left = 2*s+1;
        int right = 2*s+2;
        if (left >= list.length)
            return;
        int small = left;
        if (right < list.length && list[right] != null && (list[small] == null || list[right].val < list[small].val))
            small = right;
        if (list[small] != null && (list[s] == null || list[small].val < list[s].val)) {
            swap(list, small, s);
            rebulidHeap(list, small);
        }
    }

在整个程序的开始之初，还需要建堆，把这个数组变成一个最小堆。代码如下：

    void bulidHeap(ListNode[] list) {
        for (int i = list.length-1; i > 0; --i) {
            if (list[i] == null)
                continue;
            int parent = (i-1)/2;
            if (list[parent] == null || list[i].val < list[parent].val) {
                swap(list, i, parent);
                rebulidHeap(list, i);
            }
        }
    }

而建堆的时间复杂度是O(k*log(k))。

总体的代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {    
    void rebulidHeap(ListNode[] list, int s) {
        int left = 2*s+1;
        int right = 2*s+2;
        if (left >= list.length)
            return;
        int small = left;
        if (right < list.length && list[right] != null && (list[small] == null || list[right].val < list[small].val))
            small = right;
        if (list[small] != null && (list[s] == null || list[small].val < list[s].val)) {
            swap(list, small, s);
            rebulidHeap(list, small);
        }
    }
    
    void bulidHeap(ListNode[] list) {
        for (int i = list.length-1; i > 0; --i) {
            if (list[i] == null)
                continue;
            int parent = (i-1)/2;
            if (list[parent] == null || list[i].val < list[parent].val) {
                swap(list, i, parent);
                rebulidHeap(list, i);
            }
        }
    }
    
    void swap(ListNode[] list, int i, int j) {
        ListNode tmp = list[i];
        list[i] = list[j];
        list[j] = tmp;
    }   
    
    public ListNode mergeKLists(ListNode[] lists) {
        int k = lists.length;
        ListNode head = null;
        ListNode cur = null; 
        bulidHeap(lists);
        while (lists.length > 0 && lists[0] != null) {
            if (head == null) {
                cur = head = lists[0];
            } else {
                cur.next = lists[0];
                cur = cur.next;
            }
            lists[0] = lists[0].next;
            rebulidHeap(lists, 0);
        }
        return head;
    }
}

再来看下这个算法的时间复杂度，建堆的时间复杂度是O(k*log(k))，合并链表的时间复杂度是O(n*log(k))，所以总的时间复杂度是O((k+n)*log(k))。