合并两个有序链表

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

//一类递归题  值得关注：最后一次递归通过递归结束条件返回结果，然后前一次递归返回新的结果（关联到最后一次递归）
public class mergingTwoOrderchain {
    public ListNode Merge(ListNode list1,ListNode list2) {
        if(list1==null)
            return list2;
        if(list2 == null)
            return list1;
        ListNode head=null;
        if(list1.val<=list2.val) {
            head = list1;
            head.next=Merge(list1.next,list2);
        }
        if(list1.val>list2.val) {
            head=list2;
            head.next=Merge(list1,list2.next);
        }
        return head;
    }

        //另一类递归，只有遍历到最底层才能得到结果，并且将结果依次向前传
    public boolean VerifySquenceOfBST(int [] sequence) {
        if(sequence == null ||sequence.length <=0) //基准情况,正常情况下递归终止条件
            return false;
        int root = sequence[sequence.length-1];
        int i=0;
        for(;i<sequence.length-1;i++) {
            if(sequence[i]>root)
                break;
        }
        int j=i;
        for(;j<sequence.length-1;j++) { //基准条件 ，递归终止条件
            if(sequence[j]<root)
                return false;
        }
        boolean left=true;
        boolean right =true;
        if(i>0)    //递归演进，判断什么情况下终止递归
            left = VerifySquenceOfBST(Arrays.copyOfRange(sequence, 0, i));
        if(j==sequence.length-2)
            right = VerifySquenceOfBST(Arrays.copyOfRange(sequence, i, sequence.length-1));
        return (left && right);  //返回结果


    }
    //另一类递归题目：每一次得不到结果，只有层层传递，最总得到结果 如：二分查找
    int binary_search(int[] array,int start,int end,int target) {
        if(end<start)           //基准情况,递归终止条件
            return -1;

        int mid = (start+end)/2;
        int index=0;
        if(array[mid]==target)
            return mid;
        else if(array[mid]>target) { //递归演进，我们思考的过程，如何推进
            index = binary_search(array,start,mid-1,target);
        }else {
            index = binary_search(array,mid+1,end,target);
        }
        return index; //不做重复的事情，返回值
    }

}