首页 > itarticle > merge-k-sorted-lists

merge-k-sorted-lists

admin 11月 12, 2020 0

/*

  • Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
    /
    /*
  • Definition for singly-linked list.
  • public class ListNode {
  • int val;
  • ListNode next;
  • ListNode(int x) {
  • val = x;
  • next = null;
  • }
  • }
    */
  • 把每个 List 和List 进行 Merge，再重复
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
 
class Solution {  
public:  
    ListNode *(vector<ListNode *> &lists) {  
        int sz = lists.size();  
        if (sz == 0)  
            return NULL;  
  
        while (sz > 1) {  
            int k = (sz + 1) / 2;  
            for (int i = 0; i < sz / 2; i++)  
                lists[i] = mergeTwoLists(lists[i], lists[i + k]);  
            sz = k;  
        }  
        return lists[0];  
    }  
  
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {  
        if (l1 == NULL)  
            return l2;  
        if (l2 == NULL)  
            return l1;  
  
        ListNode *start, *p1;  
  
        if (l1->val < l2->val) {  
            p1 = start = l1;  
            l1 = l1->next;  
        } else {  
            p1 = start = l2;  
            l2 = l2->next;  
        }  
        while (l1 != NULL && l2 != NULL) {  
            if (l1->val < l2->val) {  
                p1->next = l1;  
                p1 = l1;  
                l1 = l1->next;  
            } else {  
                p1->next = l2;  
                p1 = l2;  
                l2 = l2->next;  
            }  
        }  
        if (l1 != NULL)  
            p1->next = l1;  
        else  
            p1->next = l2;  
        return start;  
    }  
};
  • 先把每个 List 的第一个节点放进优先队列，每次取出队列中的最大值节点，再把那个节点的 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
26
27
 
public class Solution {  
  
    public ListNode (List<ListNode> lists) {  
        Queue<ListNode> heap = new PriorityQueue<ListNode>(new Comparator<ListNode>(){  
             
            public int compare(ListNode l1, ListNode l2) {  
                return l1.val - l2.val;  
            }  
        });  
  
        ListNode dummy = new ListNode(0), cur = dummy, tmp;  
        for (ListNode list : lists) {  
            if (list != null) {  
                heap.offer(list);  
            }  
        }  
        while (!heap.isEmpty()) {  
            tmp = heap.poll();  
            cur.next = tmp;  
            cur = cur.next;  
            if (tmp.next != null) {  
                heap.offer(tmp.next);  
            }  
        }  
        return dummy.next;  
    }  
}
微海报分享

近期文章

近期评论

标签

热门

文章归档

分类目录

功能