目标：将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
例如输入以下两个链表：
链表1：1->2->4,
链表2： 1->3->4
输出：1->1->2->3->4->4

1. 递归
   比较两个链表的当前节点，当前值较小的作为返回的节点加入新链表，并将该节点的Next节点和另一个链表的当前节点递归比较作为新链表的Next节点。

func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
    if l1 == nil {
        return l2
    } else if l2 == nil {
        return l1
    }
    var l *ListNode
    if l1.Val < l2.Val {
        l = l1
        l.Next = mergeTwoLists(l1.Next, l2)
    } else {
        l = l2
        l.Next = mergeTwoLists(l1, l2.Next)
    }
    return l
}

2. 迭代
   比较两个链表的当前节点，值较小的加入新链表，并将该节点指向Next，直至两个链表都遍历到终点。

• 注意：迭代开始前要保存root节点作为返回值

func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
    if l1 == nil {
        return l2
    } else if l2 == nil {
        return l1
    }
    var root, l *ListNode
    if l1.Val < l2.Val {
        root = l1
        l1 = l1.Next
    } else {
        root = l2
        l2 = l2.Next
    }
    l = root
    for l1 != nil || l2 != nil {
        if l1 == nil {
            l.Next = l2
            l2 = l2.Next
        } else if l2 == nil {
            l.Next = l1
            l1 = l1.Next
        } else if l1.Val < l2.Val {
            l.Next = l1
            l1 = l1.Next
        } else {
            l.Next = l2
            l2 = l2.Next
        }
        l = l.Next
    }
    return root
}

3. 循环并重排序
   逻辑上比较简单，遍历两个链表将所有节点保存在数组中，将数组升序排序，循环数组并重新设定每个节点的Next节点。

• 注意：数组中最后一个节点的Next要指向nil，否则会形成链表循环。

func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
    if l1 == nil {
        return l2
    } else if l2 == nil {
        return l1
    }
    nodes := append(getNodes(l1), getNodes(l2)...)
    sort.Slice(nodes, func(i int, j int) bool {
        return nodes[i].Val < nodes[j].Val
    })
    for i := 1; i < len(nodes); i++ {
        nodes[i-1].Next = nodes[i]
    }
    nodes[len(nodes)-1].Next = nil
    return nodes[0]
}

func getNodes(l *ListNode) []*ListNode {
    nodes := make([]*ListNode, 0)
    for l != nil {
        nodes = append(nodes, l)
        l = l.Next
    }
    return nodes
}