剑指offer之编程（十二）

题目描述：

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

思路：

由于两个链表是递增的，所以，在合并成一个单调不递减的链表的时候，可以使用如下算法进行：每次都比较这两个链表的头结点，把小的节点拿出形成新的链表，在原来的链表上去掉这个节点。这时就又有两个链表，再使用上述方法进行即可，显然，这是一个递归的问题。（这里同样注意程序健壮性的问题，如：这两个链表是否为空）

代码如下：

import java.util.*;

public class Main18 
{

	public static void main(String[] args) 
	{
		//初始化链表  
        Scanner s = new Scanner(System.in);  
        
        int n1 = s.nextInt();  
        ListNode firstRoot = new ListNode(1);  
        ListNode node = firstRoot;  
        for(int i=1;i<n1;i++)  
        {  
            node.next = new ListNode(i+1);  
            node = node.next;  
        }
        
        int n2 = s.nextInt();  
        ListNode secondRoot = new ListNode(1);  
        ListNode nodes = secondRoot;  
        for(int i=1;i<n2;i++)  
        {  
            nodes.next = new ListNode(i+1);  
            nodes = nodes.next;  
        }
        
        ListNode ls = getAll(firstRoot, secondRoot);
        
        for(int i=0;i<(n1+n2);i++)  
        {  
            System.out.println(ls.val);  
            ls = ls.next;  
        }
        
        
	}
	
	public static ListNode getAll(ListNode firstRoot,ListNode secondRoot)
	{
		if(firstRoot==null)
			return secondRoot;
		else if(secondRoot==null)
			return secondRoot;
		
		ListNode allRoot = null;  //最后形成的链表
		
		if(firstRoot.val<secondRoot.val)
		{
			allRoot = firstRoot;   
			allRoot.next = getAll(firstRoot.next, secondRoot);
		}
		else
		{
			allRoot = secondRoot;
			allRoot.next = getAll(firstRoot, secondRoot.next);
		}
		
		return allRoot;
	}
	
	private static class ListNode  //链表节点类
	{
		int val;
		ListNode next;
		
		public ListNode(int val)
		{
			this.val = val;
		}
	}

}

本人经验，仅供参考！