输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

package com.dixin.temp;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collections;

/**
 * Created by admin on 2017/10/25.
 * 输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
 */
public class H {
    class ListNode {//内部类节点类
        int val;
        ListNode next = null;

        ListNode(int val) {
            this.val = val;
        }
    }
    //@1 最开始想法，空间复杂度较高,也就我这种小白想的到
    public ListNode Merge(ListNode list1,ListNode list2) {
        ArrayList<Integer> list=new ArrayList<Integer>();//值
        ArrayList<ListNode> result=new ArrayList<ListNode>();//节点
        if(list1==null) {
            return list2;
        }
        if(list2==null) {
            return list1;
        }
        while(list1!=null) {
            list.add(list1.val);
            list1=list1.next;
        }
        while(list2!=null) {
            list.add(list2.val);
            list2=list2.next;
        }
        Collections.sort(list);
        for(int i=0;i<list.size();i++) {
            ListNode tmp=new ListNode(list.get(i));
            result.add(tmp);//遍历将值加入到节点中
        }
        for(int i=0;i<list.size()-1;i++) {//将节点中的next关系对应好
            result.get(i).next=result.get(i+1);
        }
        return result.get(0);
    }
    //@2 递归法
    public ListNode Merge2(ListNode list1,ListNode list2) {
        if(list1==null) {
            return list2;
        }
        if(list2==null) {
            return list1;
        }
        ListNode list=null;
        if(list1.val<list2.val) {//反复比较节点的大小值添加到list中
            list=list1;
            list.next=Merge2(list1.next,list2);
        }
        if(list2.val<=list1.val) {
            list=list2;
            list.next=Merge2(list1,list2.next);
        }
        return list;
    }
    //@3 第一种想法的改进版
    public ListNode Merge3(ListNode list1,ListNode list2) {
        ListNode head=new ListNode(-1);//新建一个头节点用来存合并的链表
        head.next=null;
        ListNode root=head;
        while(list1!=null&&list2!=null) {
            if(list1.val<list2.val) {
                head.next=list1;
                head=list1;
                list1=list1.next;
            } else {
                head.next=list2;
                head=list2;
                list2=list2.next;
            }
        }
        //把未结束的链表连接到合并后链表的尾部
        if(list1!=null) {
            head.next=list1;
        }
        if(list2!=null) {
            head.next=list2;
        }
        return root.next;
    }


    @Test
    public void test() {
        ListNode list1=new ListNode(1);
        list1.next=new ListNode(3);
        list1.next.next=new ListNode(5);
        ListNode list2=new ListNode(2);
        list2.next=new ListNode(4);
        list2.next.next=new ListNode(6);
        Merge3(list1,list2);
    }
}

———-做这道题的过程还真是纠结