将两个有序的单向链表整合成一个有序单向链表

题目：将两个有序的单向链表整合成一个新的有序单向链表。

以小到大有序基准的单向链表，算法原理：
1、取链表A，链表B 各自头节点进行比较，确定新链表的头节点。
2、若取的是链表A的节点，取出链表A该节点的下一节点与B链表当前节点比较，新链表的节点指向比较得出的小节点。
3、循环步骤2，直至链表A，B其中一个到达结尾，将新链表尾节点指向未到达结尾的链表当前节点，算法结束。

将有序单向链表转向输出：
1、将下一节点指向前一节点。
2、由于需从原链表尾节点开始执行，所以进行递归。

public class Test {
    public static void main(String[] args) {
        Node a = new Node(1);
        Node b = new Node(3);
        Node d = new Node(5);
        a.next = b;
        b.next = d;

        Node A = new Node(2);
        Node B = new Node(3);
        Node C = new Node(4);
        Node D = new Node(6);

        A.next = B;
        B.next = C;
        C.next = D;

        print(a);
        print(A);

        print(sortNodeBigFirstFromSmallFirst(a, A));
    }

    public static void print(Node a){
        Node tmp = a;
        StringBuffer sb = new StringBuffer();
        while (tmp != null) {
            sb.append(tmp.val);
            sb.append(' ');
            tmp = tmp.next;
        }
        System.out.println(sb);

    }

    /**
     * 按小到大单向链表
     * @param a
     * @param b
     * @return
     */
    public static Node sortNodeSmallFirst(Node a, Node b) {
        Node ret = null;

        if(a == null)
            ret = b;
        else if(b == null)
            ret = a;
        else{
            Node tmp;
            if(a.val < b.val){
                tmp = a;
                a = a.next;
            }else{
                tmp = b;
                b = b.next;
            }
            ret = tmp;//确定头节点
            while(a != null && b != null){
                if(a.val < b.val){
                    tmp.next= a;
                    a = a.next;
                }else{
                    tmp.next = b;
                    b = b.next;
                }
                tmp = tmp.next;

            }
            tmp.next = (a == null?b:a);
        }
        return ret;
    }

    /**
     * 将按小到大单向链表转成反向链表
     * @param a
     * @param b
     * @return
     */
    public static Node sortNodeBigFirstFromSmallFirst(Node a, Node b) {
        Node sortNodeSmall= sortNodeSmallFirst(a, b);
        print(sortNodeSmall);
        Node ret = reverse(sortNodeSmall);
        return ret;
    }

    public static Node reverse(Node src){
        Node ret = null;

        if(src.next != null){
            ret = reverse(src.next);
            src.next.next = src;
            src.next = null;
        }else
            ret = src;

        return ret;
    }
}

class Node {
    Node next;
    public int val;

    public Node(int i) {
        val = i;
    }
}

输出结果: