有序链表合并

将两个有序链表合并

https://leetcode.com/problems/merge-two-sorted-lists/
Merge Two Sorted Lists
Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.
类似归并中的合并.给定游标t不断向后找两个链表中最小的元素链接上。

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
       ListNode head = new ListNode(0), last1 = l1, last2 = l2, t = head;
       while(last1 != null && last2 != null){
            if(last1.val < last2.val){
                t.next = last1;
                last1 = last1.next;
            }else{
                t.next = last2;
                last2 = last2.next;
            }
            t = t.next;
       }
       if(last1 != null) t.next = last1;
       if(last2 != null) t.next = last2;
       return head.next;
}

将k个有序链表合并

Merge k Sorted Lists
https://leetcode.com/problems/merge-k-sorted-lists/
Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
通过上一道题，知道时间主要花费在链表之间待定元素的比较上（找到最小元素），若链表增加，比较的时间也增加了。
因此，要想到最快找到最小元素的方法，由于元素本身是变动的，但元素个数并未变动，因此用堆较为合适。
如果用堆存k个链表（若所有链表总元素数目为L个）中的待比较元素，则堆的大小为k。
建堆时间渐进为O(k)，单次调整时间为O(logK),总调整时间为O（(L-k)logK）。总的时间复杂度为两个相加。

public ListNode mergeKLists(List<ListNode> lists) {
    if(lists == null) return null;
    ListNode head = new ListNode(0), t = head, minNode = null;
    List<ListNode> ls = new ArrayList<ListNode>();
    for(int i = 0; i < lists.size(); i++) 
        if(lists.get(i) != null) ls.add(lists.get(i));
    int len = ls.size();
    if(len == 0) return null;
    for(int i = len/2-1; i >= 0 ; i--) AdjustHeap(ls, i, len);
    while(ls.size() > 1){
        minNode = ls.get(0);
        t.next = minNode;
        t = t.next;
        if(minNode.next != null) ls.set(0, minNode.next);
        else{
            ls.set(0, ls.get(ls.size()-1));
            ls.remove(ls.size()-1);
        }
        AdjustHeap(ls, 0, ls.size());
    }
    t.next = ls.get(0);
    return head.next;
}
private void AdjustHeap(List<ListNode> ls, int i, int length) {
    int left = 2*i+1, right = 2*i+2, min = i;
    if(left < length && ls.get(left).val < ls.get(i).val) min = left;
    if(right < length && ls.get(right).val < ls.get(min).val) min = right;
    if(i != min){
        ListNode tmp = ls.get(min);
        ls.set(min, ls.get(i));
        ls.set(i, tmp);
        AdjustHeap(ls, min, length);
    }
}