剑指Offer-题52（Java版）：两个链表的第一个公共结点

参考自：《剑指Offer——名企面试官精讲典型编程题》

题目：两个链表的第一个公共结点
输入两个单向链表，找出它们的第一个公共结点。

主要思路：为了同时到达第一个公共结点，先分别计算两个链表的长度；然后，让较长的链表先走两者长度之差的步数；最后，每走一步，都比较它们的节点是否相同，第一个相同的结点就是所求的结点。由于是单向链表，所以从第一个公共结点开始，两个链表的结点都是重合的。因此，它们的长度之差肯定是由于前面非重合节点造成的，即两个链表的长度之差小于等于非重合节点的长度，可推出较长链表不会由于先出发，而先越过第一个公共结点。

关键点：链表长度之差，同步

时间复杂度：O(n)

public class FirstCommonNode {
    public static void main(String[] args) {
        //int[] data1 = {1, 2, 3, 4, 5, 7};
        //int[] data2 = {8, 9, 5, 7};
        int[] data1 = {3, 4, 5, 7};
        int[] data2 = {5, 7};
        ListNode pHead1 = generateDataByArray(data1);
        ListNode pHead2 = generateDataByArray(data2);
        ListNode result = findFirstCommonNode(pHead1, pHead2);
        ListNode result1 = findFirstCommonNode1(pHead1, pHead2);
        //5
        System.out.println(result.val);
        //5
        System.out.println(result1.val);
    }

    private static ListNode generateDataByArray(int[] data) {
        ListNode head = new ListNode(data[0]);
        ListNode currentNode = head;
        for (int i = 1; i < data.length; i++) {
            ListNode next = new ListNode(data[i]);
            currentNode.next = next;
            currentNode = next;
        }
        return head;
    }

    private static ListNode findFirstCommonNode(ListNode head1, ListNode head2) {
        if (head1 == null || head2 == null) {
            return null;
        }
        //获取长度
        int length1 = ListNode.getLength(head1);
        int length2 = ListNode.getLength(head2);
        //长度之差
        int diffLength = length1 - length2;
        ListNode longNode = head1;
        ListNode shortNode = head2;

        if (diffLength < 0) {
            diffLength = length2 - length1;
            longNode = head2;
            shortNode = head1;
        }

        //较长链表先走长度之差的步数
        for (int i = 0; i < diffLength; i++) {
            longNode = longNode.next;
        }
        //再同步移动
        while (longNode != null && shortNode != null) {
            //找到公共节点
            if (longNode.val == shortNode.val) {
                return longNode;
            }
            longNode = longNode.next;
            shortNode = shortNode.next;
        }
        return null;
    }

    /**
     * 交换遍历，查找两个链表的第一个公共结点
     *
     * @param pHead1 the p head 1
     * @param pHead2 the p head 2
     * @return the list node
     */
    private static ListNode findFirstCommonNode1(ListNode pHead1, ListNode pHead2) {
        ListNode p1 = pHead1;
        ListNode p2 = pHead2;
        while (true) {
            //长度相同有公共结点，第一遍就同时到达公共结点；
            //长度不同有公共结点，第一遍获取长度差值，第二遍一起到公共结点；
            //若没有公共结点，则一起走到结尾null
            if (p1 == null && p2 == null) {
                break;
            }
            if (p1 != null && p2 != null && p1.val == p2.val) {
                break;
            }
            //交换遍历
            p1 = (p1 == null ? pHead2 : p1.next);
            p2 = (p2 == null ? pHead1 : p2.next);
        }
        return p1;
    }
}

class ListNode {
    public int val;
    public ListNode next = null;

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

    /**
     * 获取链表长度
     *
     * @param head
     * @return
     */
    public static int getLength(ListNode head) {
        int count = 0;
        ListNode curNode = head;
        while (curNode != null) {
            curNode = curNode.next;
            count++;
        }
        return count;
    }

}