題目：將兩個有序的單向連結串列整合成一個新的有序單向連結串列。

以小到大有序基準的單向連結串列，演算法原理：
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;
    }
}

輸出結果: