剑指offer（第二版）——两个链表的第一个公共节点

本文链接：https://blog.youkuaiyun.com/qq_41866626/article/details/120551959

PS：《剑指offer》是很多同学找工作都会参考的一本面试指南，同时也是一本算法指南（为什么它这么受欢迎，主要应该是其提供了一个循序渐进的优化解法，这点我觉得十分友好）。现在很多互联网的算法面试题基本上可以在这里找到影子，为了以后方便参考与回顾，现将书中例题用Java实现（第二版），欢迎各位同学一起交流进步。

GitHub： https://github.com/Uplpw/SwordOffer。

剑指offer完整题目链接： https://blog.youkuaiyun.com/qq_41866626/article/details/120415258

1 题目描述

输入两个链表，找出它们的第一个公共节点。
在这里插入图片描述

leetcode链接： 两个链表的第一个公共节点（以下代码已测试，提交通过）

2 测试用例

一般是考虑功能用例，特殊（边缘）用例或者是反例，无效测试用例这三种情况。甚至可以从测试用例寻找一些规律解决问题，同时也可以让我们的程序更加完整鲁棒。

（1）功能用例：两个链表有共同节点，两个链表没有共同节点。

（2）边缘用例：单节点链表。

（3）无效用例：链表为空。

3 思路

分析：

根据题目以及示例内容，我们可以知道，如果两个链表有共同节点部分，那么两个链表的构成则是，每个链表的前面部分加上共同节点部分（如果两个链表是同一个链表，则前面部分为空）

因此有以下解决方法。

解法1：暴力求解

双重循环遍历两个链表，判断第一个链表的节点是否在第二个链表里面，比较简单，不再赘述。

时间空间复杂度： $O (m n) ， O (1)$

解法2：利用栈

将两个链表分别存入两个栈，然后出栈判断两个节点是否是同一个节点，如果是继续弹出节点判断，否则终止。

时间空间复杂度： $O (m + n) ， O (m + n)$

解法3：转化为等长链表

根据一开始的分析，长链表头部多出的那几个节点一定不会是两链表的公共节点。则可以让长链表先行|n-m|步，这样就转化为求长度相同的两个链表的第一个公共节点，直接对应节点判断即可。

时间空间复杂度： $O (m + n) ， O (1)$

解法4：双指针

我们使用两个指针 node1，node2 分别指向两个链表 headA，headB 的头结点，然后同时分别逐结点遍历，当 node1 到达链表 headA 的末尾时，重新定位到链表 headB 的头结点；当 node2 到达链表 headB 的末尾时，重新定位到链表 headA 的头结点。

这样，当它们相遇时，所指向的结点就是第一个公共结点。

借用别人很形象的比喻（程序员还是有浪漫天赋的）：

这不是《你的名字》的剧情么？

你变成我，走过我走过的路。
我变成你，走过你走过的路。
然后我们便相遇了..

4 代码

链表结构：

public class ListNode {
    int val;
    ListNode next;

    public ListNode(int val) {
        this.val = val;
        this.next = null;
    }
}

算法实现：

import java.util.Stack;

public class CommonNodesInLists {
    // 解法2：使用两个栈实现，不断出栈完成
    public static ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode node1 = headA;
        ListNode node2 = headB;
        Stack<ListNode> stack1 = new Stack();
        Stack<ListNode> stack2 = new Stack();
        while (node1 != null) {
            stack1.push(node1);
            node1 = node1.next;
        }
        while (node2 != null) {
            stack2.push(node2);
            node2 = node2.next;
        }
        ListNode node = null;
        while (!stack1.isEmpty() && !stack2.isEmpty()) {
            if (stack1.peek() == stack2.peek()) {
                node = stack1.peek();
                stack1.pop();
                stack2.pop();
            } else break;
        }
        return node;
    }

    // 解法3：删除长链表的前面节点使得其与链表相等，然后两个链表同时往下走进行判断
    public static ListNode getIntersectionNodeByCount(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode node1 = headA;
        ListNode node2 = headB;
        int count1 = 0;
        int count2 = 0;
        while (node1 != null) {
            count1++;
            node1 = node1.next;
        }
        while (node2 != null) {
            count2++;
            node2 = node2.next;
        }
        node1 = headA;
        node2 = headB;
        if (count1 > count2) {
            int subtract = count1 - count2;
            for (int i = 0; i < subtract; i++) {
                node1 = node1.next;
            }
        } else if (count1 < count2) {
            int subtract = count2 - count1;
            for (int i = 0; i < subtract; i++) {
                node2 = node2.next;
            }
        }
        ListNode node = null;
        while (node1 != null) {
            if (node1 == node2) {
                node = node1;
                break;
            }
            node1 = node1.next;
            node2 = node2.next;
        }
        return node;
    }

    // 解法4：双指针
    public static ListNode getIntersectionNodeByTwoPoint(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode node1 = headA;
        ListNode node2 = headB;
        while (node1 != node2) {
            node1 = node1 == null ? headB : node1.next;
            node2 = node2 == null ? headA : node2.next;
        }
        return node1;
    }

    public static void main(String[] args) {
        // 1->2->3->6->7
        //    4->5↗
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);

        ListNode node4 = new ListNode(4);
        ListNode node5 = new ListNode(5);
        ListNode node6 = new ListNode(6);
        ListNode node7 = new ListNode(7);
        // head1
        node1.next = node2;
        node2.next = node3;
        node3.next = node6;

        // head2
        node4.next = node5;
        node5.next = node6;

        // common
        node6.next = node7;

        System.out.println(getIntersectionNode(node1, node4).val);
        System.out.println(getIntersectionNodeByCount(node1, node4).val);
        System.out.println(getIntersectionNodeByTwoPoint(node1, node4).val);
    }
}