swift算法：合并两个有序链表

1、描述

将两个有序链表合并为一个新的有序链表并返回，新链表是通过拼接给定的两个链表的所有节点组成的

例：输入：1->2->4，1->3->4

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

2、算法

思想：迭代/递归

解法1）类似归并排序的合并过程，通过遍历链表比较大小，生成新链表的有序排列，多出来的部分直接加入新链表

func mergeTwoLists(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
        //创建新链表节点
        var result = ListNode.init(0)
        //p代表新链表的头节点
        var p = result
        var l1 = l1
        var l2 = l2
        
        //遍历两个链表
        while (l1 != nil) && (l2 != nil) {
            //如果l1的值比l2的值小，则将l1节点加入新链表，并更新l1的节点，反之则将l2加入新链表，更新l2的节点
            if l1!.val < l2!.val {
                result.next = l1
                l1 = l1?.next
            }else{
                result.next = l2
                l2 = l2?.next
            }
            result = result.next!
        }
        //如果l1先比l2遍历完，则l2剩余的节点直接加入新链表，反之一样
        if l1 == nil {
            result.next = l2
        }else{
            result.next = l1
        }
        
        return p.next
    }

 解法2）新建立一个链表，其头部为head，每次取出两个链表中最小的值给head，进行递归

（1）在原有链表基础上递归

    func mergeTwoLists1(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
        
        //原链表递归
        if l1 == nil {
            return l2
        }
        if l2 == nil {
            return l1
        }
        //每次取出两个链表中中最小的值给head
        if l1!.val < l2!.val {
            l1?.next = mergeTwoLists1(l1!.next, l2)
            return l1
        }else{
            l2?.next = mergeTwoLists1(l1, l2!.next)
            return l2
        }
        
        

    }

（2）新建链表递归

func mergeTwoLists1(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
        //1、新建链表递归
        guard let l1 = l1 else{
            return l2
        }
        guard let l2 = l2 else{
            return l1
        }
        var result : ListNode? = (l1.val < l2.val) ? l1 : l2
        if l1.val < l2.val {
            result?.next = mergeTwoLists1(l1.next, l2)
        }else{
            result?.next = mergeTwoLists1(l1, l2.next)
        }

        return result
}