LeetCode OJ-- Merge k Sorted Lists *@

https://oj.leetcode.com/problems/merge-k-sorted-lists/

这道题主要是考虑测试数据的特点吧。

刚开始的时候想，每次找出头结点中最小的两个，然后取最小的一个，一直取到它的值 > 倒数第二小的，之后重复这个过程。

适合的数据特点为： 1 2 3 5 6 7 10 20

                          11 12 15 18 …… 这样子的

于是写出了代码，但是超时了。

超时的数据是这样的：[{7},{49},{73},{58},{30},{72},{44},{78},{23},{9},{40},{65},{92},{42},{87},{3},{27},{29},{40},……

也就是每个链表长度为1，这样的话，就多了好多去两个最小值的操作。

于是参考了答案，方法是每次合并两个链表，得到一个新链表，之后新链表再和下一个合并……

代码分别如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        ListNode *dummy = new ListNode(0);
        if(lists.size() == 0)
            return dummy->next;
            
        int count = 0;  // record null number
        int small = 0;
        int bigger = 0;
        int smallestIndex = 0;
        int biggerIndex = 0;
        ListNode *currentNode = dummy;
        
        for(int i = 0; i < lists.size(); i++)
        {
            if(lists[i] == NULL)
                count++;
        }
        
        while(count < lists.size() - 1)
        {
            findTwoLittle(lists,smallestIndex,biggerIndex);
            currentNode->next = lists[smallestIndex];
            
            while(lists[smallestIndex]->next != NULL &&lists[smallestIndex]->next->val <= lists[biggerIndex]->val)
            {
                lists[smallestIndex] = lists[smallestIndex]->next;
            }
            currentNode = lists[smallestIndex];
            lists[smallestIndex] = lists[smallestIndex]->next;
            if(lists[smallestIndex] == NULL)
                count++;
        }
        // only one isn't null
        for(int i = 0; i < lists.size(); i++)
        {
            if(lists[i] != NULL)
            {
                currentNode->next = lists[i];
                break;
            }
        }
        return dummy->next;
    }
    //至少还有两个元素的时候
    void findTwoLittle(vector<ListNode *> &lists, int &smallestIndex, int &biggerIndex)
    {
        int small = INT16_MAX;
        int bigger = INT16_MAX;
        smallestIndex = 0;
        biggerIndex = 0;
        
        for(int i = 0; i < lists.size(); i++)
        {
            if(lists[i] != NULL)
            {
                if(lists[i]->val <= small)
                {
                    bigger = small;
                    small = lists[i]->val;
                    biggerIndex = smallestIndex;
                    smallestIndex = i;
                }
                else if(lists[i]->val > bigger)
                    continue;
                else
                {
                    bigger = lists[i]->val;
                    biggerIndex = i;
                }
            }
            
        }
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        if(lists.size() == 0)
            return NULL;
        ListNode *p = lists[0];
        for(int i = 1; i < lists.size(); i++)
            p = mergeTwoLists(p,lists[i]);
        return p;
    }
    ListNode *mergeTwoLists(ListNode *l1,ListNode *l2){
        ListNode head(-1);
        for(ListNode *p = &head; l1 != NULL || l2 != NULL; p = p->next)
        {
            int val1 = l1 == NULL? INT_MAX:l1->val;
            int val2 = l2 == NULL? INT_MAX:l2->val;
            if(val1 <= val2)
            {
                p->next = l1;
                l1 = l1->next;
            }
            else
            {
                p->next = l2;
                l2 = l2->next;
            }
        }
        return head.next;
    }
};