leetcode 23 合并K个排序链表

题目描述：合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。
示例:
输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6
方法1：暴力合并
最普通的方法，K个链表按顺序合并K-1次
设有K个链表，平均每个链表有n个节点，时间复杂度为
（n+n)+(2n+n)+(3n+n)+((k-1)n+n) = O(k^2n)
方法2：排序后相连
将kn个节点放到vector中，再将vector排序，再将节点顺序相连。假设有K个链表，平均每个链表有n个节点，时间复杂度为：
排序的复杂度为NlogN,对于KN个节点来说，排序的复杂度即为NKlogKN
总时间复杂度：KN*logKN + KN

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
bool cmp(const ListNode* a, const ListNode *b){
    return a->val < b->val;
}
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        vector<ListNode*> node_vec;
        for(int i = 0; i < lists.size(); i++){
            ListNode* head = lists[i];  //遍历k个链表，将节点全部添加至node_vec
            while(head){
                node_vec.push_back(head);
                head = head->next;
            }
        }
        if(node_vec.size() == 0){  
            return NULL;
        }   
        //根据节点值进行排序
        sort(node_vec.begin(),node_vec.end(),cmp);
        for(int i = 1; i < node_vec.size(); i++){    //连接新的链表
            node_vec[i-1]->next = node_vec[i];
        }
        node_vec[node_vec.size()-1]->next = NULL;   //将最后元素中的指针指向为NULL
        return node_vec[0];   //返回vector的第一个节点
    }
};

方法3：分治后相连
对K个链表进行分治，两两进行合并
设有K个链表，平均每个链表有n个节点，时间复杂度：
第一轮：进行K/2次，每次处理2n个数字
第二轮：进行k/4次，每次处理4n个数字
最后一次：
进行k/(2^logk)次，每次处理
2^logk*n个值
总体复杂度：
2n * k/2 + 4n * k/4 + 8n * k/8 + ……= NK + NK+ ……
O(KNlogk) ,有logk倍的NK
假设有4个链表，每个链表长度为3，则总共的比较次数为
（3+3）+（3+3）+（6+6）= 24次

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode temp_head(0);      //设置临时头节点temp_head
        ListNode *pre = &temp_head;    //使用pre指针指向temp_head
        while(l1 && l2){
            if(l1->val < l2->val){    //l1和l2同时不为空时，对它们进行比较
                pre->next = l1;
                l1 = l1->next;
            }
            else{
                pre->next = l2;
                l2 = l2->next;
            }
            pre = pre->next;
        }
        if(l1){   //如果l1有剩余
            pre->next = l1;
        }
        if(l2){    //如果l2有剩余
            pre->next = l2;
        }
        return temp_head.next;
    }
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size() == 0){
            return NULL;       //如果list为空，返回NULL
        }
        if(lists.size() == 1){
            return lists[0];
        }
        if(lists.size() == 2){     //如果只有两个list，调用两个list_merge函数
            return mergeTwoLists(lists[0], lists[1]);
        }
        int mid = lists.size() / 2;    //求中间链表的头节点
        vector<ListNode*> sub1_lists;  //拆分lists为两个子lists
        vector<ListNode*> sub2_lists;
        for(int i = 0; i < mid; i++){
            sub1_lists.push_back(lists[i]);
        }
        for(int i = mid; i < lists.size(); i++){
            sub2_lists.push_back(lists[i]);
        }
        ListNode *l1 = mergeKLists(sub1_lists);
        ListNode *l2 = mergeKLists(sub2_lists);
        return mergeTwoLists(l1,l2);   //分治处理
    }
};