算法通关村第一关——链表经典问题之两个链表公共子节点

第一个公共子节点问题

剑指 Offer 52. 两个链表的第一个公共节点

难度简单

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

如下面的两个链表：

在节点 c1 开始相交。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Reference of the node with value = 8 输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

做题方法：

1. 将常用数据结构和常用算法思想都想一遍，看看哪些能解决问题。
2. 常用的数据结构有数组、链表、队、栈、Hash、集合、树、堆。常用的算法思想有查找、排序、双指针、递归、迭代、分治、贪心、回溯和动态规划等等。

误区：

1. 比较时用链表的值去比较，链表的值是有可能重复的，应该直接比较节点

做题思路：

1.暴力解法：

遍历两个链表，比较节点是否相等，返回相等的节点

ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    ListNode currA = headA;
    while(currA != null) {
        ListNode currB = headB;
        while(currB != null) {
            if(currA == currB) {
                return currA;
            }
            currB = currB.next;
        }
        currA = currA.next;
    }
    return null;
}

2.集合和哈希

可以将一条链表存到hash中，然后另一条进行检测当前节点是否在hash中在则返回当前节点

public ListNode findFirstCommonNodeBySet(ListNode headA, ListNode headB) {
    Set<ListNode> set = new HashSet<>();
    while (headA != null) {
        set.add(headA);
        headA = headA.next;
    }
    
    while (headB != null) {
        if (set.contains(headB))
            return headB;
        headB = headB.next;
    }
    return null;
}

3.栈

因为有交点的两条链表交点后的节点必然相同，所以将链表压入两个栈中，找出最后一组相同的节点返回

ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    Stack<ListNode> stackA = new Stack<>();
    Stack<ListNode> stackB = new Stack<>();
    ListNode res = null;

    while (headA != null) {
        stackA.push(headA);
        headA = headA.next;
    }

    while (headB != null) {
        stackB.push(headB);
        headB = headB.next;
    }

    while (stackA.size() > 0 && stackB.size() > 0) {
        if (stackA.peek() == stackB.peek()) {
             res = stackA.pop();
             stackB.pop();
        } else {
            break;
        }
    }
    return res;
}

4.拼接字符串

先看下面的链表A和B：

A: 0-1-2-3-4-5

B: a-b-4-5

如果分别拼接成AB和BA会怎么样呢？

AB：0-1-2-3-4-5-a-b-4-5

BA：a-b-4-5-0-1-2-3-4-5

我们假定A和B有相交的位置，以交点为中心，可以将两个链表分别分为left_a和right_a，left_b和right_b这样四个部分，并且right_a和right_b是一样的，这时候我们拼接AB和BA就是这样的结构：

因为right_a = right_b,所以只需要遍历两个链表就可以找到交点了

这里还可以进一步优化，如果建立新的链表太浪费空间了，我们只要在每个链表访问完了之后，调整到一下链表的表头继续遍历就行了，于是代码就出来了：

 ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        // p1表示AB p2表示BA
        ListNode p1 = headA;
        ListNode p2 = headB;
        while(p1 != p2) {
            p1 = p1.next;
            p2 = p2.next;
            //避免出现没有交点死循环
            if(p1 != p2) {
                if(p1 == null) {
                    p1 = headB;
                }
                if(p2 == null) {
                    p2 = headA;
                }
            }
        }
        return p1;
    }

5.差和指针

先统计两个链表的长度la/lb,比较两个长度，然后让长的链表先走la-lb步，让它们长度相等，然后两个链表再一起走，节点一样的就是公共节点了

  ListNode getIntersectionNode(ListNode headA, ListNode headB) {
       if (headA == null || headB == null) {
            return null;
        }
        ListNode currentA = headA;
        ListNode currentB = headB;
        int la = 0;
        int lb = 0;
        //获取链表长度
        while (currentA != null) {
            currentA = currentA.next;
            la++;
        }
        while (currentB != null) {
            currentB = currentB.next;
            lb++;
        }
        currentA = headA;
        currentB = headB;
        int sub = la > lb ? la - lb : lb -la;
        //a长a先走
        currentA = headA;
        currentB = headB;
         if(la > lb){
           int a = 0;
           while(a < sub){
            currentA = currentA.next;
            a++;
        }   
       }
        if (lb > la) {
            int times = 0;
            while (times < sub) {
                currentB = currentB.next;
                times++;
            }
        }
        while (currentA != currentB) {
            currentA = currentA .next;
            currentB = currentB.next;
        }
        return currentA;
    }