[LeetCode 23]合并K个升序链表_23.合并k个升序链表 c++

[LeetCode 23]C++实现合并K个升序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

来源：力扣（LeetCode 23）
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists

方法1、push进vector中排序

class myCompare{
public:
    bool operator()(ListNode* node1,ListNode* node2){
    return node1->val<node2->val;//仿函数由小到大排序
    }
};
class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists){
	if(lists.size()==0)
		return NULL;
    vector<ListNode*>node_V;
    for(int i=0;i<lists.size();++i){
	    //建立临时变量存储各个链表开始节点
        ListNode* head=lists[i];
        while(head){
            node_V.push_back(head);
            head=head->next;//遍历链表
        }
    }
    if(node_V.empty())
        return NULL;
    sort(node_V.begin(),node_V.end(),myCompare());//利用algorithm中sort排序
    for(int i=1;i<node_V.size();++i){
        node_V[i-1]->next=node_V[i];//链接链表
    }
    node_V[node_V.size()-1]->next=NULL;//尾置空
    return node_V[0];//返回头节点
    }  
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

方法2、分治

class Solution {
public:
ListNode* mergeTwoLists(ListNode* node1,ListNode* node2){//合并两个链表//迭代
    if(!node1&&!node2)
        return NULL;
    ListNode* head=new ListNode(0);
    ListNode* ptr=head;
    while(node1&&node2){
        if(node1->val<node2->val){//升序排列
        ptr->next=node1;
        node1=node1->next;
        }
        else{
           ptr->next=node2;
           node2=node2->next;
        }
        ptr=ptr->next;
    }
    if(!node1)
        ptr->next=node2;
    else
        ptr->next=node1;
 //   head->next=NULL;
    return head->next;
}
ListNode* mergeKLists(vector<ListNode*>& lists){
    if(!lists.size())
        return NULL;
    if(lists.size()==1){
        return lists[0];
    }
    if(lists.size()==2){
        return mergeTwoLists(lists[0],lists[1]);
    }
    int mid=lists.size()/2;
    //创建两个子链表
    vector<ListNode*>subList_1;
    vector<ListNode*>subList_2;
	//遍历开始节点
    for(int i=0;i<mid;++i)
        subList_1.push_back(lists[i]);
    for(int i=mid;i<lists.size();++i)
        subList_2.push_back(lists[i]);
	//进入递归
    ListNode* node1=mergeKLists(subList_1);
    ListNode* node2=mergeKLists(subList_2);
    return mergeTwoLists(node1,node2);
    }  
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

ps :mergeTwoLists
https://leetcode-cn.com/problems/merge-two-sorted-lists/ (LeetCode 21)
方法1、迭代

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(!l1&&!l2)
            return NULL;
        ListNode* head=new ListNode(0);
        ListNode* ptr=head;
        while(l1&&l2){
            if(l1->val<=l2->val){
                ptr->next=l1;
                l1=l1->next;
            }
            else{
                ptr->next=l2;
                l2=l2->next;
            }
            ptr=ptr->next;
        }
        if(!l1)
            ptr->next=l2;
        else    
            ptr->next=l1;
        return head->next;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

方法2、递归

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1==NULL)
            return l2;
        if(l2==NULL)
            return l1;
        
        if(l1->val<=l2->val){
            l1->next=mergeTwoLists(l1->next,l2);
            return l1;
        }
        else{
            l2->next=mergeTwoLists(l1,l2->next);
            return l2;
        }
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18