剑指offer第12天 合并两个有序链表递归、两个链表第一个公共结点

1、合并两个有序链表，迭代法 大家都会

贴个代码

Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummyHead = new ListNode();
        ListNode tail = dummyHead;// 尾插法
        while(l1 != null && l2 != null){
            if(l1.val < l2.val){
                tail.next = l1;
                l1 = l1.next;
            }else{
                tail.next = l2;
                l2 = l2.next;
            }
            tail = tail.next;

        }
        tail.next = l1 == null ? l2 : l1;
        return dummyHead.next;

    }
}

 递归：

递归的定义两个有序链表的合并操作，(暂时忽略边界情况，)

if  list1[0] < list2[0] 

 list1[0] + merge( list1[ 1 : ] , list2] )

else

list2[0] + merge( list2[1 : ] ,  list1) 

也就是说两个链表头部较小的一个结点 与剩下元素的 merge 操作结果合并。

建模过程：考虑边界，

如果 l1 和 l2 一开始是空链表，则不没有任何操作需要合并，只需返回非空链表。否则就要判断 

l1 和 l2 的值，选择小的值，然后递归的决定下一个添加到结果里的结点。如果两个链表有一个为空，则结束递归。

public ListNode mergeTwoListsRecursion(ListNode list1, ListNode list2){
    if(list1 == null){
        return list2;
    }else if(list2 == null){
        return list1;
    }else{
        if(list1.val < list2.val){
            list1.next = mergeTwoListsRecursion(list1.next, list2);
            return list1;
        }else{
            list2.next = mergeTwoListsRecursion(list1, list2.next);
            return list2;
        }
    }

}

Offer52 两个链表的第一个公共结点

输入两个链表，找出它们的第一个公共节点。

如下面的两个链表：

在节点 c1 开始相交。

示例 1：

 

 思路：

两个指针 Pa 和 Pb，同时开始扫描，判断两个指针是否指向同一个结点，如果 链表 A B在相交的结点前 有同样的结点个数，那个 两个指针 Pa 和Pb， 会同时到达相交处，即指向同一个结点。

如图，两个指针不会，同时到达相交处。继续扫描，当Pa 为走到头 ，即Pa = null时，将Pa 指向链表B的头结点（即 Pa = B），两个指针继续走，Pb 走到头时， Pb = A。（即让两个指针，走过两个链表所有的结点， 如果有交点，则它们会在同一个位置停下。 若没有交点它们会同时为空）

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
class Solution {
    ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null){
            return null;
        }
        ListNode tempA = headA;
        ListNode tempB = headB;
        
        while(tempA != tempB){
            if(tempA == null){
                tempA = headB;
            }else{
                tempA = tempA.next;
            }
            if(tempB == null){
                tempB = headA;
            }else{
                tempB = tempB.next;
            }
            
        }
        return tempA;
        
    }
}

 (leetcode 官方题解)

下面提供双指针方法的正确性证明。考虑两种情况，第一种情况是两个链表相交，第二种情况是两个链表不相交。

情况一：两个链表相交

链表 headA  和 headB 的长度分别是  m 和 n。假设链表 headA 的不相交部分有 a 个节点，链表 headB 的不相交部分有 b 个节点，两个链表相交的部分有 c 个节点，则有 a+c=m  ，b+c=n。如果 a=b，则两个指针会同时到达两个链表的第一个公共节点，此时返回两个链表的第一个公共节点；

如果 a≠b，则指针 pA 会遍历完链表 headA，指针 pB 会遍历完链表 headB，两个指针不会同时到达链表的尾节点，然后指针pA 移到链表 headB 的头节点，指针 pB移到链表 headA的头节点，然后两个指针继续移动，在指针 pA 移动了 a+c+b 次、指针 pB 移动了 b+c+a 次之后，两个指针会同时到达两个链表的第一个公共节点，该节点也是两个指针第一次同时指向的节点，此时返回两个链表的第一个公共节点。

情况二：两个链表不相交

链表 headA\ 和 headB的长度分别是 m和 n。考虑当 m=n 和 m≠n 时，两个指针分别会如何移动：

如果 m=n，则两个指针会同时到达两个链表的尾节点，然后同时变成空值 null，此时返回 null；

如果 m≠n，则由于两个链表没有公共节点，两个指针也不会同时到达两个链表的尾节点，因此两个指针都会遍历完两个链表，在指针 pA 移动了 m+n 次、指针 pB 移动了 n+m次之后，两个指针会同时变成空值 null，此时返回 null。