LeetCode_8 合并两个有序的链表

题目：

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

示例：

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

一看就会，一写就废？

一般思维方式：

1. 两重循环，比较值
2. l1.val > l2.val,则追加l2的node，l2跳至下一节点继续和l1比较
3. 否则和步骤2相反

public ListNode mergeTwoSorted(ListNode l1, ListNode l2){
    ListNode preHread = new ListNode(-1);
    ListNode tmp = preHread;
    while (l1 != null){
        while (l2 != null){
            if (l1.val > l2.val){
                tmp.next = new ListNode(l2.val);
                tmp = tmp.next;
                l2 = l2.next;
            }else {
                tmp.next = new ListNode(l1.val);
                tmp = tmp.next;
                l1 = l1.next;
                break;
            }
        }
    }
    if (l1 == null) tmp.next = l2;
    if (l2 == null) tmp.next = l1;
    return preHread.next;
}

暴力解法：

1. 创建空集合数组ArrayList存放两个链表
2. 将两个链表的元素分别循环加入到数组
3. 调用Collections的sort方法将数组排序
4. 遍历数组，创建有序链表

代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
public ListNode mergeTwoSorted(ListNode l1, ListNode l2){
 	List<Integer> list = new ArrayList();
    while (l1 != null){
        list.add(l1.val);
        l1 = l1.next;
    }
    while (l2 != null){
        list.add(l2.val);
        l2 = l2.next;
    }
    Collections.sort(list);
    if (list.size() < 1) return null;
    ListNode headNode = new ListNode(list.get(0));
    ListNode tmp = headNode;
    for (int i = 1;i < list.size();++i){
        tmp.next = new ListNode(list.get(i));
        tmp = tmp.next;
    }
    return headNode;
}

迭代解法：

1. 定义一个节点（val设为-1）preHead
2. 再定义一个临时节点tmp用来存储结果链表
3. 较小的值存储在tmp的next，同时此链表指针向后移动
4. 如果一个链表为空之后另一个不为空，直接加到后面
5. 最后返回preHead的next

public ListNode mergeTwoSorted(ListNode l1, ListNode l2){
    ListNode preHead = new ListNode(-1);
    ListNode tmp = preHead;
    while(l1 != null && l2 != null){
        if(l1.val < l2.val){
            tmp.next = l1;
            l1 = l1.next;
        }else {
            tmp.next = l2;
            l2 = l2.next;
        }
        tmp = tmp.next;
    }
    tmp.next = l1 == null ? l2 : l1;
    return preHead.next;
}

递归解法：

1. 如果l1为空时，返回l2，l2为空时返回l1
2. 如果l1的值小于l2的值，则l1.next作为新的l1递归调用
3. 否则l2.next作为新的l2递归调用
4. 达到终止条件，从最后一次递归结果挨个返回结果

public ListNode mergeTwoSorted(ListNode l1, ListNode l2){
    if(l1 == null) return l2;
    if(l2 == null) return l1;
    if(l1.val < l2.val){
        l1.next = mergeTwoSorted(l1.next, l2);
        return l1;
    }
    l2.next = mergeTwoSorted(l1, l2.next);
    return l2;
}