判断两个单链表是否相交、并求交点详解

开门见山，今天解决的问题就是：如何判断两个链表是否相交？如果相交，则需要得到交点。（下面一步步跟着博主仔细想就会明白了~）

首先构建链表节点信息：

//链表节点
public class DataNode {

    private int data;
    private DataNode next;

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public DataNode getNext() {
        return next;
    }

    public void setNext(DataNode next) {
        this.next = next;
    }

    public DataNode(int data) {
        this.data = data;
    }
    
}

1.两个链表都不存在环

对于这种情况，如果两个链表相交，又都不存在环，那么不难想象这两个链表共同构成了一个Y型。因此，只要分别遍历这两个链表，找到尾端节点，判断尾端节点是否相同即可确认是否相交。
如果要求这种情况的交点，由于相交部分全部都相同，因此，只需要先得到两个链表的差，用两个指针分别指向这两个链表P1,P2假定P1与P2相差为N，那么将P1移动N个节点后，才能使得P1与P2同在一个起跑线，接着同时出发，第一个相等的节点即为交点。

/**
     * 无环情况下，判断两个链表是否相交，只需要遍历链表，判断尾节点是否相等即可。
     * @param h1
     * @param h2
     * @return
     */
    public static boolean isJoinNoLoop(DataNode h1,DataNode h2) {
        DataNode p1 = h1;
        DataNode p2 = h2;
        while(null != p1.getNext())
            p1 = p1.getNext();
        while(null != p2.getNext())
            p2 = p2.getNext();
        return p1 == p2;
    }
    
    /**
     * 无环情况下找到第一个相交点
     * 方法： 算出两个链表的长度差为x,长链表先移动x步，之后两链表同时移动，直到相遇的第一个交点。
     * @param h1
     * @param h2
     * @return
     */
    public static DataNode getFirstJoinNode(DataNode h1,DataNode h2) {
        int length1 = 0;
        int length2 = 0;
        while(null != h1.getNext()) {
            length1 ++;
            h1 = h1.getNext();
        }
        while(null != h2.getNext()) {
            length1 ++;
            h2 = h2.getNext();
        }
        return length1>=length2?getNode(h1,length1,h2,length2):getNode(h2,length2,h1,length1);
    }

 

以上是最乐观的一种情况，但是还需要考虑链表上存在环的情况。那么还需要添加一个方法，判断链表上是否存在环。对于如何判断链表上是否存在环，解决办法是采用快慢指针，两个指针P1、P2分别指向同一个链表的头节点，之后，P1一次前进两个节点，P2一次前进一个节点。如果最终P1和P2能重合，则说明一定存在交点；反之如果最终P1或者P2存在一个为空的情况，则说明这两个链表不相交。

/**
     * 判断是否存在环  
     * 步骤：设置两个指针同时指向head，其中一个一次前进一个节点（P1），另外一个一次前进两个节点(P2)。
     * p1和p2同时走，如果其中一个遇到null，则说明没有环，如果走了N步之后，二者指向地址相同，那么说明链表存在环。
     * @param h
     * @return
     */
    public static boolean isLoop(DataNode h) {
        DataNode p1 = h;
        DataNode p2 = h;
        while(p2.getNext() != null && p2.getNext().getNext()!=null){
            p1 = p1.getNext();
            p2 = p2.getNext().getNext();
            if(p1 == p2) 
                break;
        }
        return !(p1==null||p2==null);
    }

因此上述问题还有另外一个解法，将其中一个链表首尾相连，检测另外一个链表是否存在环，如果存在（该环就是首尾相连的链表），则两个链表相交，而检测出来的依赖环入口即为相交的第一个点。需找出环的入口，设置p1,p2两个指针，同样一个走一步一个走两步，两者相遇则必在环上某一点相遇，记下此位置p1=p2，在p1和p2重合后，设置一个p3指向表头，然后p1和p3每次同时行走一步，每步前进一个节点，等到p1和p3重合时，重合的位置就是环的入口。

图示：

设L1为无环长度，L2为环长，a为两指针相遇时慢速指针在环上走过的距离，而且a一定小于环总长L2（这是因为当慢速指针刚进入环时，快速指针已经在环中，且距离慢速指针的距离最长为L2-1，需要追赶的距离为L2-1，即刚好在慢速指针的下一个节点，需要几乎一整圈的距离来追赶，赶上时，慢速指针也不能走完一圈）。此时设慢速指针走过的节点数为N，则可列出：
快速指针走过的节点数为： 2N = L1 + k * L2 + a； （这里快速指针走过的节点数一定是慢速指针走过的2倍）。
慢速指针走过的节点数为： N = L1 + a；
则相减可得， N = k * L2 , 于是得到 k * L2 = L1 + a; 即， L1 = (k-1) * L2 + (L2 - a) （这里k至少是大于等于1的，因为快速指针至少要多走一圈）。
即 L1的长度 = 环长的整数倍 + 相遇点到入口点的距离， 此时设置头结点p3, 与p1同时，每次都走一步，相遇点即为入口点。

 

    /**
     *  方法二： 将其中一个链表首尾相连 从另外一个链表开始，检测是否存在环，如果存在，则说明二者相交。
     *  如果需要找出环的入口，则设P1 P2 两个指针，P1一次走两步，P2一次走一步，两者在环上某一点相遇。记下此位置。
     *  此时设置一个指针P3指向表头，然后P1和P3每次同时行走一步，每步前进一个节点。等到P1、P3重合时，则重合位置即使环入口。
     * @param h1
     * @param h2
     * @return
     */
    public  DataNode entryNoLoop(DataNode h1,DataNode h2) {
        DataNode p = h1;
        while(null != p.getNext()){
            p = p.getNext();
        }
        p.setNext(h1);
        return entryLoop(h2);
    }
    
    /**
     * 获取环的入口点
     * @param h
     * @return
     */
    public DataNode entryLoop(DataNode h) {
        DataNode p1 = h;
        DataNode p2 = h;
        DataNode p3 = h;
        
        while(null != p2.getNext() && null != p2.getNext().getNext()){
            p1 = p1.getNext();
            p2 = p2.getNext().getNext();
            if(p1 == p2)
                break;
        }
        while(p3 != p1) {
            p1 = p1.getNext();
            p3 = p3.getNext();
        }
        return p3;
    }
    

2.两个链表均存在环

 对于连个链表均存在环的情况，相交点要么在环上，要么在环外。

 无论上述何种情况，均需要首先分别找到各自到环的入口点。解法可以即使上述entryLoop方法。在得到环的入口点之后，各自判断环的入口点是否相同，如果如口点相同，则为左图描述情况，因此只需计算着两个链表到入口点部分长度之差，然后用长的部分减去差，再同时与短的部分同步前进，如果节点相同，则为相交点。反之如果入口点不同，则相交点为这两个链表的任意一个入口点。

/**
     * 
     * @param h1
     *            链表1的头节点
     * @param l1
     *            链表1的环入口
     * @param h2
     *            链表2的头节点
     * @param l2
     *            链表2的头节点
     * @return
     */
    public static DataNode bothLoop(DataNode h1, DataNode l1, DataNode h2, DataNode l2) {
        DataNode p1 = null;
        DataNode p2 = null;
        if (l1 == l2) {
            p1 = h1;
            p2 = h2;
            int n = 0;
            while (p1 != l1) {
                n++;
                p1 = p1.getNext();
            }
            while (p2 != l2) {
                n--;
                p2 = p2.getNext();
            }
            p1 = n > 0 ? h1 : h2;
            p2 = p1 == h1 ? h2 : h1;
            n = Math.abs(n);
            while (n != 0) {
                n--;
                h1 = h1.getNext();
            }
            while (p1 != p2) {
                p1 = p1.getNext();
                p2 = p2.getNext();
            }
            return p1;
        } else {
            p1 = l1.getNext();
            while (p1 != l1) {
                if (p1 == l2) {
                    return l1;
                }
            }
            return null;
        }
    }

    /**
     * 
     * @param h1
     * @param h2
     * @return
     */
    public DataNode getJoinNode(DataNode h1, DataNode h2) {
        if (null == h1 || null == h2)
            return null;
        DataNode l1 = entryLoop(h1);
        DataNode l2 = entryLoop(h2);
        if (null == l1 && null == l2)
            return getFirstJoinNode(h1, h2);
        if (null != l1 && null != l2)
            return bothLoop(h1,l1,h2,l2);
        return null;
    }

至此，单链表的相交问题就讲解完毕了~有错误或想不明白的地方欢迎留言提问或指正。