题目1519：合并两个排序的链表

题目1519：合并两个排序的链表

时间限制：1 秒

内存限制：128 兆

特殊判题：否

提交：2069

解决：937

题目描述：

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
(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

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.StringTokenizer;


public class Main {
    public static void main(String[] args) {
	    new Task().solve() ;  	
	}
}

class Task{
	InputReader in = new InputReader(System.in) ;
	PrintWriter out = new PrintWriter(System.out) ;
	
	class Node{
	   int value ;
	   Node next ;
	   Node(int value){
		   this.value = value ;
		   next = null ;
	   }
	}
	
	Node buildNode(int n){
		Node head = null , now = null ;
	    for(int i = 1 ; i <= n ; i++){
	    	Node node = new Node(in.nextInt()) ;
	    	if(head == null) now = head = node ;
	    	else{
	    		now.next = node ;
	    		now = node ;
	    	}
	    }
		return head ; 
	}
	
	Node merge(Node first , Node second){
		Node head = null , now = null ;
		while(first != null && second != null){
			Node node = null ;
			if(first.value <= second.value){
				node = new Node(first.value) ;
				first = first.next ;
			}
			else{
				node = new Node(second.value) ;
				second = second.next ;
			}
			if(head == null) now = head = node ;
			else{
				now.next = node ;
				now = now.next ;
			}
		}
		while(first != null){
			Node node = new Node(first.value) ;
			first = first.next ;
			if(head == null) now = head = node ;
			else{
				now.next = node ;
				now = now.next ;
			}
		}
		while(second != null){
			Node node = new Node(second.value) ;
			second = second.next ;
			if(head == null) now = head = node ;
			else{
				now.next = node ;
				now = now.next ;
			}
		}
		return head ; 
	}
	
	void printNode(Node head){
		if(head == null){
			out.println("NULL") ;
			return ;
		}
		else{
			Node now = head ;
			while(now != null){
				out.print(now == head ? "" : " ") ;
				out.print(now.value) ;
				now = now.next ;
			}
			out.println();
		}
	}
	
	void solve(){
		while(in.hasNext()){
			int n = in.nextInt() ;
			int m = in.nextInt() ;
			Node first = buildNode(n) ;
			Node second = buildNode(m) ;
			printNode(merge(first, second)) ;
		//	out.flush();
		}
		out.flush();
	}
}


class InputReader {  
    public BufferedReader reader;  
    public StringTokenizer tokenizer;  
  
    public InputReader(InputStream stream) {  
        reader = new BufferedReader(new InputStreamReader(stream), 32768);  
        tokenizer = new StringTokenizer("");  
    }  
  
    private void eat(String s) {  
        tokenizer = new StringTokenizer(s);  
    }  
  
    public String nextLine() {  
        try {  
            return reader.readLine();  
        } catch (Exception e) {  
            return null;  
        }  
    }  
  
    public boolean hasNext() {  
        while (!tokenizer.hasMoreTokens()) {  
            String s = nextLine();  
            if (s == null)  
                return false;  
            eat(s);  
        }  
        return true;  
    }  
  
    public String next() {  
        hasNext();  
        return tokenizer.nextToken();  
    }  
  
    public int nextInt() {  
        return Integer.parseInt(next());  
    }  
  
    public long nextLong() {  
        return Long.parseLong(next());  
    }  
  
    public double nextDouble() {  
        return Double.parseDouble(next());  
    }  
  
    public BigInteger nextBigInteger() {  
        return new BigInteger(next());  
    }  
  
}