JZ25 合并两个排序的链表

题目：输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。

解法一：排序法
思路：先构造一个集合，存储两个链表的值，然后对该集合排序，遍历排序后的集合构造新链表
最容易想到，当然时间复杂度空间复杂度也最高

public ListNode Merge(ListNode list1, ListNode list2) {
        if(list1==null){
            return list2;
        }
        if(list2==null){
            return list1;
        }
        ArrayList<Integer> list = new ArrayList<>();
        while(list1!=null){
            list.add(list1.val);
            list1=list1.next;
        }
        while(list2!=null){
            list.add(list2.val);
            list2=list2.next;
        }
        Collections.sort(list);
         ListNode result = new ListNode(list.get(0));
         ListNode temp = result;
        for(int i=1;i<list.size();i++){
            temp.next=new ListNode(list.get(i));
            temp=temp.next;
        }
        return result;
    }

复杂度分析：假设两个链表的长度之和为k
时间复杂度：O(klogk)，各遍历链表一次，一次快排，遍历集合一次O(k)+O(klogk)+O(k)
空间复杂度：O(klogk)，集合存储遍历的k个链表节点,一次快排O(k)+O(klogk)

解法二：迭代

构造一个新链表，然后在循环中对两个链表的头结点进行比较，将值较小的链表追加到新链表的末尾，同时将值较小的链表和新链表向后迭代。一个链表遍历结束后，剩余的链表都大于新链表的最大值，即将剩余的链表追加到新链表末尾即可。

public ListNode Merge(ListNode list1, ListNode list2) {
        if (list1 == null || list2 == null) {
            return list1 == null ? list2 : list1;
        }
        ListNode result = new ListNode(0);
        ListNode temp = result;
        while (list1 != null && list2 != null) {
            if (list1.val < list2.val) {
                temp.next = list1;
                list1 = list1.next;
            } else {
                temp.next = list2;
                list2 = list2.next;
            }
            temp = temp.next;
        }
        if (list1 == null || list2 == null) {
            temp.next = list1 == null ? list2 : list1;
        }
        return result.next;
    }

复杂度分析：假设两个链表的长度之和为k
时间复杂度：O(k)，各遍历链表一次O(k)
空间复杂度：O(1)，不涉及额外内存空间

解法三：递归

比较两个链表的头结点，然后对链表的下一个节点进行递归，递归的返回值作为链表的下一个节点。

public ListNode Merge(ListNode list1, ListNode list2) {
        if (list1 == null || list2 == null) {
            return list1 == null ? list2 : list1;
        }
        if (list1.val < list2.val) {
            list1.next = Merge(list1.next, list2);
            return list1;
        } else {
            list2.next = Merge(list1, list2.next);
            return list2;
        }
    }

代码执行过程分析：
假设list1=1,3,list2=2,4
第一次递归list1.next = Merge(3, (2,4));
第二次递归list2.next = Merge(3,4);
第三次递归list1.next = Merge(null,4)
返回的是4，即list2,回到第三次递归，即list1.next=4，list当前节点为3。返回链表为(3,4)。
回到第二次递归，list2.next =(3,4),当前list2=(2,4),操作过后list2=(2,3,4)
返回第一次递归，list1.next =(2,3,4),当前list1=(1,3)，操作之后list1=(1,2,3,4),返回list1

复杂度分析：假设两个链表的长度之和为k
时间复杂度：O(k)，各遍历链表一次O(k)
空间复杂度：O(1)，不涉及额外内存空间

总结：
涉及数据结构：链表、集合
涉及算法：迭代、递归