swift算法：合并k个排序链表

1、描述

合并k个排序链表，返回合并后的排序链表

例：输入：[1->4->5, 1->3->4, 2->6]

        输出：1->1->2->3->4->4->5->6

 

2、实现

1）懒方法

将链表的值往一个数组里放，并将数组排序，最后再转换成链表

func mergeKLists(_ lists: [ListNode?]) -> ListNode? {
        var lists = lists
        var result : [Int] = []
        
        //遍历链表数组，将每个链表的val直接加入数组中
        for i in lists {
            var item = i
            while item != nil {
                result.append((item?.val)!)
                item = item?.next
            }
        }
        if result.count == 0 {
            return nil
        }
        //链表val值的数组排序
        result = result.sorted()
        //将排好序的数组重新合成一个链表
        var head = ListNode(0)
        var p = head
        
        for i in result {
            p.next = ListNode(i)
            p = p.next!
        }
        return head.next
    }

2）归并方法

利用合并两个链表的方法递归，返回新链表

func mergeKLists(_ lists: [ListNode?]) -> ListNode? {
        var lists = lists
        
        switch lists.count {
        case 0:
            return nil
        case 1:
            return lists[0]
        case 2:
            return mergeTwoLists(lists[0], lists[1])
        default:
            let mid = lists.count/2
            return mergeTwoLists(mergeKLists(Array(lists[0...mid])), mergeKLists(Array(lists[(mid+1)...(lists.count-1)])))
        }
    }
    
    func mergeTwoLists(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
        //原链表递归
        if l1 == nil {
            return l2
        }
        if l2 == nil {
            return l1
        }
        //每次取出两个链表中中最小的值给head
        if l1!.val < l2!.val {
            l1?.next = mergeTwoLists(l1!.next, l2)
            return l1
        }else{
            l2?.next = mergeTwoLists(l1, l2!.next)
            return l2
        }
    }