1. var mergeKLists = function(lists) {
    2.     if (lists.length === 0) return null;
    3.     return mergeArr(lists);
    4. };
    5. function mergeArr(lists) {
    6.     if (lists.length <= 1) return lists[0];
    7.     let index = Math.floor(lists.length / 2);
    8.     const left = mergeArr(lists.slice(0, index))
    9.     const right = mergeArr(lists.slice(index));
    10.     return merge(left, right);
    11. };
    12. function merge(l1, l2) {
    13.     if (l1 == null && l2 == null) return null;
    14.     if (l1 != null && l2 == null) return l1;
    15.     if (l1 == null && l2 != null) return l2;
    16.     let newHead = null, head = null;
    17.     while (l1 != null && l2 != null) {
    18.         if (l1.val < l2.val) {
    19.             if (!head) {
    20.                 newHead = l1;
    21.                 head = l1;
    22.             } else {
    23.                 newHead.next = l1;
    24.                 newHead = newHead.next;
    25.             }
    26.             l1 = l1.next;
    27.         } else {
    28.             if (!head) {
    29.                 newHead = l2;
    30.                 head = l2;
    31.             } else {
    32.                 newHead.next = l2;
    33.                 newHead = newHead.next;
    34.             }
    35.             l2 = l2.next;
    36.         }
    37.     }
    38.     newHead.next = l1 ? l1 : l2;
    39.     return head;
    40. };
    1. //自顶而下归并 先分在合
    2. var mergeKLists = function (lists) {
    3.     // 当是空数组的情况下
    4.     if (!lists.length) {
    5.         return null;
    6.     }
    7.     // 合并两个排序链表
    8.     const merge = (head1, head2) => {
    9.         let dummy = new ListNode(0);
    10.         let cur = dummy;
    11.         // 新链表，新的值小就先接谁
    12.         while (head1 && head2) {
    13.             if (head1.val < head2.val) {
    14.                 cur.next = head1;
    15.                 head1 = head1.next;
    16.             } else {
    17.                 cur.next = head2;
    18.                 head2 = head2.next;
    19.             }
    20.             cur = cur.next;
    21.         }
    22.         // 如果后面还有剩余的就把剩余的接上
    23.         cur.next = head1 == null ? head2 : head1;
    24.         return dummy.next;
    25.     };
    26.     const mergeLists = (lists, start, end) => {
    27.         if (start + 1 == end) {
    28.             return lists[start];
    29.         }
    30.         // 输入的k个排序链表，可以分成两部分，前k/2个链表和后k/2个链表
    31.         // 如果将这前k/2个链表和后k/2个链表分别合并成两个排序的链表，再将两个排序的链表合并，那么所有链表都合并了
    32.         let mid = (start + end) >> 1;
    33.         let head1 = mergeLists(lists, start, mid);
    34.         let head2 = mergeLists(lists, mid, end);
    35.         return merge(head1, head2);
    36.     };
    37.     return mergeLists(lists, 0, lists.length);
    38. };
    40. //自底而上合并
    41. var mergeKLists = function (lists) {
    42.     if (lists.length <= 1) return lists[0] || null;//当归并的节点只有一个时 返回这个节点
    43.     const newLists = [];
    44.     //自底而上归并，第一次归并大小为2的链表，第二次归并大小4的链表...
    45.     for (let i = 0; i < lists.length; i += 2) {
    46.         newLists.push(merge(lists[i], lists[i + 1] || null));
    47.     }
    48.     return mergeKLists(newLists);
    49. };
    51. const merge = (list_1, list_2) => {//合并两个有序链表
    52.     const dummyNode = new ListNode(0);
    53.     let p = dummyNode;
    55.     while (list_1 && list_2) {
    56.         if (list_1.val < list_2.val) {//先将小的节点加入
    57.             p.next = list_1;
    58.             list_1 = list_1.next;
    59.         } else {
    60.             p.next = list_2;
    61.             list_2 = list_2.next;
    62.         }
    63.         p = p.next;
    64.     }
    66.     p.next = list_1 ? list_1 : list_2;//遍历完成还有节点剩余
    67.     return dummyNode.next;
    68. };

    （此文章只是为了记笔记，为了尊重作者原文详细请参考如下链接，谢谢！）
    参考资源：