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

最近在学c++和数据结构，做几道题目来练习一下，使用语言c++

题目
输入两个链表，找出它们的第一个公共节点。
如下面的两个链表：

在节点 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 个节点。

示例 2：

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

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
解释：这两个链表不相交，因此返回 null。

遇到的坑：
其实这道题我一开始不是很理解它是什么意思，就是比较简单的一道题，被这题目搞得挺复杂的样子。
一开始不理解的地方:
就比如说示例二来说，明明从1开始就相等了，为什么结点要从8开始。
解决：
后来我发现它比较的不是值，而且地址，后面我也去验证了一下。
当取到两个链表1的时候的地址，我们获取它的地址发现是这样的：

发现地址是不相等的。
当取到两个链表8时候的地址，我们获取它的地址发现是这样的：

发现地址是相等的。

所以他们比较的是地址，而不是值，其实主要是题目没怎么说清楚，不过可能也是一个坑吧。而且这道题目的很多数据都是无用的，主要就是它那两个链表的值有点用。

解题思路：
其实我的解题思路就是获取两个链表的长度，然后把两个链表变成一样长，依次进行比较头结点指向结点是否相等；如果不相等，两个链表都的表头都向后面移一位，直到链表为空为止；当两个链表相等时，直接弹出，获取所求值。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *p,*q;
        p=headA;
        q=headB;
        int i=0,j=0;
        while(p!=NULL){
            i++;
            p=p->next;
        }
        cout<<i<<endl;

        while(q!=NULL){
            j++;
            q=q->next;
        }

        cout<<j<<endl;
        int t=0;
        if(i>j){
            t=i-j;
            while(t){
                t--;
                headA=headA->next;
            } 
            while(headA!=NULL){
                if(headA==headB){
                    break;
                }
                headA=headA->next;
                headB=headB->next;
            }
        }else{
            t=j-i;
            while(t){
                t--;
                headB=headB->next;
            } 
            while(headA!=NULL){
            	//比较的是结点地址，不能直接比较headA->val和headB->val，因为值相同，可能不同地址存储的值相同。
                if(headA==headB){
                    cout<<headA<<endl;
                    cout<<headB<<endl;
                    break;
                }
                headA=headA->next;
                headB=headB->next;
            }
        }   
        return headA;
    }
};

我的步骤还是比较麻烦的，看了大佬的题目之后发现有更简化的步骤

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
       /*
       当我们走完各自的路 重新回到对方最初的地方
        如果我们的缘分不是两条平行的线
        那么一定会在第一次有交集的地方重新相遇
        */
        ListNode *node1 = headA;
        ListNode *node2 = headB;
        while(node1 != node2) {
            node1 = node1 != NULL ? node1->next : headB;
            node2 = node2 != NULL ? node2->next : headA;
        }
        return node1;
    }
};