算法（7）--链表（4）相交链表 力扣160

分析

        这道题看似是求两个链表的相交节点，其实是想让我们试图消除两个链表在相交前的链表长度差，如果知道链表长度差后，我们就可以把长的链表先循环到和短的链表同一个起始位置，然后一起往下遍历节点，当他俩的节点相同时，这个节点就是相交链表的相交点，这也是法一的思路。

三种方法

        1、求出两个链表的长度，消除链表长度差；

        2、走到尽头看不到你，我把你的路重走一遍直到遇见了你，二者相加等于他们两条链表的总长度,把差值补上了

        3、利用递归,一直递归b链表然后每次都只动a链表一次，直到他们相等

法一

        先求出链表的总长度，下图是《代码随想录》里的图

   

        移动长链表，直到和短链表在同一个起始位置

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //分析题目：两个来链表的差别是在相交之前，也就是说他们的长度是差在相交之前
        //思路一：遍历出总长度然后求出他们的长度差
        int len1 = 0;
        int len2 = 0;
        ListNode a = headA;
        ListNode b = headB;
        //求出链表的总长度
        while(a!=null){
            len1++;
            a = a.next;
        }
        while(b!=null){
            len2++;
            b = b.next;
        }
        //两个链表的差值
        int cha = Math.abs(len1-len2);
        //判断哪段长，然后循环达到同一个起点
        if(len1 > len2){
            while(cha != 0){
                headA = headA.next;
                cha--;
            }
        }else if(len2 > len1){
            while(cha != 0){
                headB = headB.next;
                cha--;
            }
        }
        //从同一个起点开始遍历，直到遍历到相交点
        while(headA != null && headB != null){
            if(headA == headB){
                return headA;
            }
            headA = headA.next;
            headB = headB.next;
        }
        return null;
    }

法二

        当链表a走到最后时，在赋值到链表b的起点重走一遍b的链表，b链表也是如此操作，到最后，两个链表的指针走得长度是a链表+b链表，消除了长度差，这也是力扣里的解法

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //分析题目：两个来链表的差别是在相交之前，也就是说他们的长度是差在相交之前
        //思路二：走到尽头看不到你，我把你的路重走一遍直到遇见了你，二者相加等于他们两条链表的总长度,把差值补上了

        ListNode p1 = headA;
        ListNode p2 = headB;
        while(headA != null || headB != null){

            //链表a的指针走完了链表，把p2（headB）赋值给这个指针
            if(headA == null){
                headA = p2;
            }

            //链表b的指针走完了链表，把p1（headA）赋值给这个指针
            if(headB == null){
                headB = p1;
            }
            //找到两个链表的相交节点
            if(headA == headB){
                return headA;
            }

            headA = headA.next;
            headB = headB.next;
        }
        return null;

法三

        用递归容易使内存溢出，我用java跑的时候栈内存溢出了，但c语言似乎可以用

        这个递归的方法就是，先固定住headA指针的指向，然后递归headB，如果没有找到相交节点，就使headA指针指向next节点，然后重复上面的步骤，直到找到相交节点或这两个链表根本没有相交节点返回null。

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //思路三:利用递归,一直递归b链表然后每次都只动a链表一次，直到他们相等
        return getIntersectionNode2(headA,headB,headB);
    }
    public ListNode getIntersectionNode2(ListNode headA,ListNode headB,ListNode preHeadB){
        if(headA == headB){
            return headB;
        }
        if(headA != null && headB != null){
            
            return getIntersectionNode2(headA,headB.next,preHeadB);
        }else if(headB == null && headA!=null){
            return getIntersectionNode2(headA.next,preHeadB,preHeadB);
        }else{
            return null;
        }
    }

--------------------------------------------------------------------------------------------------------------------------------

本人是刷《代码随想录》这本书时记录一下自己的学习笔记