递归实现合并单链表（java）

题目描述：

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
(hint: 请务必使用链表。)

输入：

输入可能包含多个测试样例，输入以EOF结束。
对于每个测试案例，输入的第一行为两个整数n和m(0<=n<=1000, 0<=m<=1000)：n代表将要输入的第一个链表的元素的个数,m代表将要输入的第二个链表的元素的个数。
下面一行包括n个数t(1<=t<=1000000)：代表链表一中的元素。接下来一行包含m个元素，s(1<=t<=1000000)。

输出：

对应每个测试案例，
若有结果，输出相应的链表。否则，输出NULL。

样例输入：

5 2
1 3 5 7 9
2 4
0 0

样例输出：

1 2 3 4 5 7 9
NULL!

如下图所示：现有两个有序单链表，链表1和链表2，合并链表1和链表2生成有序的单链表3。

分析两个链表的合并过程。我们的分析从合并两个链表的头结点开始，链表1的头结点小于链表2 的头结点，所以链表1的头结点将会成为合并链表后的头结点。

当我们得到两个链表中最小的头结点，并将它链接到已合并的链表中。剩下的两个链表依然是两个有序的单链表，因此合并的步骤和先前的步骤是一样的。这就是一个典型的递归过程。

public static Node Merge(Node pHeader1,Node pHeader2){
            if(pHeader1 == null)
                return pHeader2;
            if(pHeader2 == null)
                return pHeader1;
            Node mergeHeader = null;
            if(pHeader1.getValue()<pHeader2.getValue()){
                mergeHeader = pHeader1;
                mergeHeader.setNextNode(Merge(pHeader1.getNextNode(),pHeader2));
            }else{
                mergeHeader = pHeader2;
                mergeHeader.setNextNode(Merge(pHeader1,pHeader2.getNextNode()));                
            }
            return mergeHeader;
        }

实现代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
class Node {     
    private int value; 
    private Node nextNode;     
    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
    }
    public Node getNextNode() {
        return nextNode;
    }
    public void setNextNode(Node nextNode) {
        this.nextNode = nextNode;
    }
    public Node(int value,Node nextNode) {     
        this.value = value;  
        this.nextNode = null;
    }          
}   
public class MergeList{
        public static Node Merge(Node pHeader1,Node pHeader2){
            if(pHeader1 == null)
                return pHeader2;
            if(pHeader2 == null)
                return pHeader1;
            Node mergeHeader = null;
            if(pHeader1.getValue()<pHeader2.getValue()){
                mergeHeader = pHeader1;
                mergeHeader.setNextNode(Merge(pHeader1.getNextNode(),pHeader2));
            }else{
                mergeHeader = pHeader2;
                mergeHeader.setNextNode(Merge(pHeader1,pHeader2.getNextNode()));                
            }
            return mergeHeader;
        }
        public static void main(String[] args) throws IOException {
        StreamTokenizer cin = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        while(cin.nextToken() != cin.TT_EOF){
            int n = (int)cin.nval;
            cin.nextToken();
            int m = (int)cin.nval;
            if(n==0 && m==0){
                System.out.println("NULL");
                continue;
            }
            cin.nextToken();
            Node pHeader1 = new Node((int)cin.nval,null),current=pHeader1;
            for(int i=0;i<n-1;i++){
                cin.nextToken();
                current.setNextNode(new Node((int)cin.nval,null));
                current = current.getNextNode();
            }
            cin.nextToken();
            Node pHeader2 = new Node((int)cin.nval,null);
            current=pHeader2;
            for(int i=0;i<m-1;i++){
                cin.nextToken();
                current.setNextNode(new Node((int)cin.nval,null));
                current = current.getNextNode();
            }
            Node mergeHeader = Merge(pHeader1,pHeader2);
            StringBuilder str = new StringBuilder();
            while(mergeHeader != null){
                str.append(mergeHeader.getValue()+" ");
                mergeHeader = mergeHeader.getNextNode();
            }
            System.out.println(str.substring(0, str.length()-1));
        }
    }
}