单链表是否有环和两个链表是否有公共节点问题

1、单链表是否有环

题目描述：有一个单链表，其中可能有一个环，也就是某个节点的next指向的是链表中在它之前的节点，这样在链表的尾部形成一环。问题：
1、如何判断一个链表是不是这类链表？
2、如果链表为存在环，如何找到环的入口点？

一、判断链表是否存在环
设置两个指针(fast, slow)，初始值都指向头，slow每次前进一步，fast每次前进二步，如果链表存在环，则fast必定先进入环，而slow后进入环，两个指针必定相遇。(当然，fast先行头到尾部为NULL，则为无环链表）。

boolean isExsitLoop() {
    Node<T> slow = head;
    Node<T> fast = head;

    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;

        if (slow == fast)
            return true;
    }
    return false;
}

二、找到环的入口点
当fast若与slow相遇时，slow肯定没有走遍历完链表，而fast已经在环内循环了n圈(1<=n)。假设slow走了s步，则fast走了2s步（fast步数还等于s 加上在环上多转的n圈），设环长为r，则：
2s = s + nr
s= nr
设整个链表长L，入口环与相遇点距离为x，起点到环入口点的距离为a。
a + x = nr
a + x = (n – 1)r +r = (n-1)r + L - a
a = (n-1)r + (L – a – x)
(L – a – x)为相遇点到环入口点的距离，由此可知，从链表头到环入口点等于(n-1)循环内环+相遇点到环入口点。于是我们从链表头、与相遇点分别设一个指针，每次各走一步，两个指针必定相遇，且相遇第一点为环入口点。

Node<T> getLoopEntry() {
    Node<T> slow = head;
    Node<T> fast = head;

    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;

        if (slow == fast)
            break;
    }

    if (fast == null || fast.next == null)
        return null;

    // slow指向链表头节点
    // fast指向slow和fast相遇的节点
    slow = head;

    while (slow != fast) {
        slow = slow.next;
        fast = fast.next;
    }

    return fast;
}

2、两个链表是否相交

题目描述：给出两个单向链表的头指针（如下图所示），

比如h1、h2，判断这两个链表是否相交。

      直接循环判断第一个链表的每个节点是否在第二个链表中。但，这种方法的时间复杂度为O(Length(h1) * Length(h2))。显然，我们得找到一种更为有效的方法，至少不能是O（N^2）的复杂度。

1. 针对第一个链表直接构造hash表，然后查询hash表，判断第二个链表的每个结点是否在hash表出现，如果所有的第二个链表的结点都能在hash表中找到，即说明第二个链表与第一个链表有相同的结点。时间复杂度为为线性：O(Length(h1) + Length(h2))，同时为了存储第一个链表的所有节点，空间复杂度为O(Length(h1))。是否还有更好的方法呢，既能够以线性时间复杂度解决问题，又能减少存储空间？
2. 进一步考虑“如果两个没有环的链表相交于某一节点，那么在这个节点之后的所有节点都是两个链表共有的”这个特点，我们可以知道，如果它们相交，则最后一个节点一定是共有的。而我们很容易能得到链表的最后一个节点，所以这成了我们简化解法的一个主要突破口。那么，我们只要判断俩个链表的尾指针是否相等。相等，则链表相交；否则，链表不相交。
   所以，先遍历第一个链表，记住最后一个节点。然后遍历第二个链表，到最后一个节点时和第一个链表的最后一个节点做比较，如果相同，则相交，否则，不相交。这样我们就得到了一个时间复杂度，它为O((Length(h1) + Length(h2))，而且只用了一个额外的指针来存储最后一个节点。这个方法时间复杂度为线性O（N），空间复杂度为O（1），显然比解法三更胜一筹。
3. 上面的问题都是针对链表无环的，那么如果现在，链表是有环的呢?还能找到最后一个结点进行判断么?上面的方法还同样有效么?显然，这个问题的本质已经转化为判断链表是否有环。那么，如何来判断链表是否有环呢?

所以，事实上，这个判断两个链表是否相交的问题就转化成了：
1、先判断带不带环。
2、如果都不带环，就判断尾节点是否相等。
3、如果都带环，判断一链表上俩指针相遇的那个节点（问题1中的相遇节点），在不在另一条链表上。如果在，则相交，如果不在，则不相交。

这里为了简化问题，我们假设两个链表均不带环。

一、判断两链表链表是否有公共点

如果都不带环，就判断尾节点是否相等即可。如果都带环，判断一链表上俩指针相遇的那个节点，在不在另一条链表上。

static boolean isCommonNode(LinkList<Integer> link, LinkList<Integer> link2) {
    Node<Integer> last;
    Node<Integer> last2;
    // 两链表均无环
    if (link.isExsitLoop() == false && link2.isExsitLoop() == false) {
        // 获取最后一个节点
        last = (Node<Integer>) link.getLastNode();
        last2 = (Node<Integer>) link2.getLastNode();
        System.out.println("链表1的最后一个节点为:"+last.value+"   链表2的最后一个节点为:"+last2.value);
        return last.value == last2.value;
    }
    //一个有环，一个无环
    else if(link.isExsitLoop()!=link2.isExsitLoop())
    {
        return false;
    }
    //两个都有环，判断环里的节点是否能到达另一个链表环里的节点
    else
    {
        // 相遇节点
        Node<Integer> meetNode = link.getMeetNode();
        Node<Integer> meetNode2 = link2.getMeetNode();
        Node<Integer> p = meetNode.next;

        // 环中遍历
        while(p!=meetNode)
        {
            if(p == meetNode2)
                return true;
            p = p.next;
        }
        return false;
    }
}

二、求两个链表相交的第一个节点

        如果两个尾结点是一样的，说明它们有重合；否则两个链表没有公共的结点。 在上面的思路中，顺序遍历两个链表到尾结点的时候，我们不能保证在两个链表上同时到达尾结点。 这是因为两个链表不一定长度一样。但如果假设一个链表比另一个长L个结点，我们先在长的链表上遍历L个结点，之后再同步遍历，这个时候我们就能保证同时到达最后一个结点了。
        由于两个链表从第一个公共结点开始到链表的尾结点，这一部分是重合的。因此，它们肯定也是同时到达第一公共结点的。于是在遍历中，第一个相同的结点就是第一个公共的结点。

static Node<Integer> getFirstCommonNode(LinkList<Integer> link, LinkList<Integer> link2)
{
    Node<Integer> l = link.getHeadNode();
    Node<Integer> s = link2.getHeadNode();
    int len1 = link.getLength();
    int len2 = link2.getLength();
    int diff = len1 - len2;

    if(len1<len2)
    {
        l = link2.getHeadNode();
        s = link.getHeadNode();
        diff = len2 - len1;
    }

    // 长的先走diff长度
    for(int i = 0; i < diff; i++ )
        l = l.next;

    while(l!=null&&s!=null&&l.value!=s.value)
    {
        l = l.next;
        s = s.next;
    }

    Node<Integer> comNode = null ;
    if(l.value==s.value)
        comNode = l;
    return comNode;
}

具体代码为：

class Node<T> {
    T value;
    Node<T> next = null;

    public boolean equals(Node<T> node) {
        if (value.equals(node.value)) {
            return true;
        }
        return false;
    }

    public int hashCode() {
        return value.hashCode();
    }

    public String toString() {
        if (value == null)
            return "-1";
        return value.toString();
    }
}

class LinkList<T> {
    private Node<T> head;
    private int len;

    public LinkList() {
        initLinkList();
    }

    private void initLinkList() {
        head = new Node<T>();// 空链表
        len = 0;

        head.next = null;
    }

    // 链表插入操作
    void insertAfterHead(Node<T> node) {
        node.next = head.next;
        head.next = node;
        len++;
    }

    void insertAtLast(Node<T> node) {
        Node<T> p = getLastNode();

        node.next = p.next; // null
        p.next = node;
        len++;

    }

    // 产生环
    void insertFormLoop(Node<T> node) {
        Node<T> p = getLastNode();

        node.next = p; // 产生环
        p.next = node;
        len++;
    }

    Node<T> getHeadNode() {
        return head;
    }

    Node<T> getLastNode() {
        Node<T> p = head;
        // 获取最后一个节点
        while (p.next != null) {
            p = p.next;
        }
        return p;
    }

    int getLength() {
        return len;
    }

    // 遍历
    void traversal() {
        Node<T> node = head.next;
        while (node != null) {
            System.out.print(node + "-->");
            node = node.next;
        }
        System.out.println();
    }

    /* http://www.cppblog.com/humanchao/archive/2008/04/17/47357.html
     设置两个指针(fast, slow)，初始值都指向头，slow每次前进一步，fast每次前进二步，如果链表存在环，则fast必定先进入环，而slow后进入环，两个指针必定相遇。
     (当然，fast先行头到尾部为NULL，则为无环链表)*/
    // 判断是否有环
    boolean isExsitLoop() {
        Node<T> slow = head;
        Node<T> fast = head;

        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;

            if (slow == fast)
                return true;
        }
        return false;
    }

    // 有环的情况下，获取相遇节点
    Node<T> getMeetNode()
    {
        Node<T> slow = head;
        Node<T> fast = head;

        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;

            if (slow == fast)
                return slow;
        }
        return null;
    }

    // 找出环的入口
    /*
     * 当fast若与slow相遇时，slow肯定没有走遍历完链表，而fast已经在环内循环了n圈(1<=n)。假设slow走了s步，则fast走了2s步（fast步数还等于s 加上在环上多转的n圈），设环长为r，则：
       2s = s + nr
       s= nr
       设整个链表长L，入口环与相遇点距离为x，起点到环入口点的距离为a。
       a + x = nr
       a + x = (n – 1)r +r = (n-1)r + L - a
       a = (n-1)r + (L – a – x)
       (L – a – x)为相遇点到环入口点的距离，由此可知，从链表头到环入口点等于(n-1)循环内环+相遇点到环入口点，于是我们从链表头、与相遇点分别设一个指针，每次各走一步，两个指针必定相遇，且相遇第一点为环入口点。
     * */
    Node<T> getLoopEntry() {
        Node<T> slow = head;
        Node<T> fast = head;

        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;

            if (slow == fast)
                break;
        }

        if (fast == null || fast.next == null)
            return null;

        // slow指向链表头节点
        // fast指向slow和fast相遇的节点
        slow = head;

        while (slow != fast) {
            slow = slow.next;
            fast = fast.next;
        }

        return fast;
    }

}

public class LinkBasic {
    // java内部类的初始化
    class StaticInnerTest {
        void innerClass() {
            System.out.println("java内部类测试，innerClass");
        }
    }

    /* http://blog.csdn.net/v_JULY_v/article/details/6447013
       判断是否有公共点
       1、两个链表都无环的情况:判断尾节点是否相等
       2、如果都带环，判断一链表上俩指针相遇的那个节点，在不在另一条链表上。
    */
    static boolean isCommonNode(LinkList<Integer> link, LinkList<Integer> link2) {
        Node<Integer> last;
        Node<Integer> last2;
        // 两链表均无环
        if (link.isExsitLoop() == false && link2.isExsitLoop() == false) {
            // 获取最后一个节点
            last = (Node<Integer>) link.getLastNode();
            last2 = (Node<Integer>) link2.getLastNode();
            System.out.println("链表1的最后一个节点为:"+last.value+"   链表2的最后一个节点为:"+last2.value);
            return last.value == last2.value;
        }
        //一个有环，一个无环
        else if(link.isExsitLoop()!=link2.isExsitLoop())
        {
            return false;
        }
        //两个都有环，判断环里的节点是否能到达另一个链表环里的节点
        else
        {
            // 相遇节点
            Node<Integer> meetNode = link.getMeetNode();
            Node<Integer> meetNode2 = link2.getMeetNode();
            Node<Integer> p = meetNode.next;

            // 环中遍历
            while(p!=meetNode)
            {
                if(p == meetNode2)
                    return true;
                p = p.next;
            }
            return false;
        }
    }

    // 求两个链表相交的第一个节点
    /*
     * 思路：如果两个尾结点是一样的，说明它们有重合；否则两个链表没有公共的结点。
        在上面的思路中，顺序遍历两个链表到尾结点的时候，我们不能保证在两个链表上同时到达尾结点。
    这是因为两个链表不一定长度一样。但如果假设一个链表比另一个长L个结点，我们先在长的链表上遍历L个结点，
    之后再同步遍历，这个时候我们就能保证同时到达最后一个结点了。
        由于两个链表从第一个公共结点开始到链表的尾结点，这一部分是重合的。因此，它们肯定也是同时到达第一公共结点的。
    于是在遍历中，第一个相同的结点就是第一个公共的结点。
     * */

    static Node<Integer> getFirstCommonNode(LinkList<Integer> link, LinkList<Integer> link2)
    {
        Node<Integer> l = link.getHeadNode();
        Node<Integer> s = link2.getHeadNode();
        int len1 = link.getLength();
        int len2 = link2.getLength();
        int diff = len1 - len2;

        if(len1<len2)
        {
            l = link2.getHeadNode();
            s = link.getHeadNode();
            diff = len2 - len1;
        }

        // 长的先走diff长度
        for(int i = 0; i < diff; i++ )
            l = l.next;

        while(l!=null&&s!=null&&l.value!=s.value)
        {
            l = l.next;
            s = s.next;
        }

        Node<Integer> comNode = null ;
        if(l.value==s.value)
            comNode = l;
        return comNode;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LinkBasic.StaticInnerTest test = new LinkBasic().new StaticInnerTest();
        test.innerClass();

        /************************
         * 形成初始单链表
         * **********************/
        LinkList<Integer> link = new LinkList<Integer>();
        LinkList<Integer> link2 = new LinkList<Integer>();
        int[] arr = { 1, 2, 3, 4, 5, 6 };
        int[] arr2 = { 7, 1, 2, 3, 6, 8, 9, 10 };
        for (int i = 0; i < arr.length; i++) {
            Node<Integer> node = new Node<Integer>();
            node.value = arr[i];
            link.insertAfterHead(node);
        }

        for (int i = 0; i < arr2.length; i++) {
            Node<Integer> node = new Node<Integer>();
            node.value = arr2[i];
            link2.insertAfterHead(node);
        }

        /************************
         * 在链表尾部插入新的结点
         * **********************/
        Node<Integer> node = new Node<Integer>();
        node.value = 7;
        link.insertAtLast(node);

        System.out.println("链表1长度：" + link.getLength());
        System.out.println("链表1表头信息：" + link.getHeadNode().value);
        System.out.println("链表1遍历结果：");
        link.traversal();

        System.out.println("链表2长度：" + link2.getLength());
        System.out.println("链表2遍历结果：");
        link2.traversal();

        /************************
         * 判断两个链表是否有公共节点
         * **********************/
        System.out.println("是否存在公共节点："+isCommonNode(link,link2));
        System.out.println("第一个公共节点为："+getFirstCommonNode(link,link2).value);

        /************************
         * 在链表尾部插入结点，形成环
         *
         * 即在链表的最后一个元素p后插入节点node，使node的next指针域指向p，形成环结构
         * **********************/
        Node<Integer> node2 = new Node<Integer>();
        node2.value = 19;
        link.insertFormLoop(node2);
        if (link.isExsitLoop()) {
            System.out.println("单链表存在环。");
            System.out.println("环的入口节点:" + link.getLoopEntry().value);
        }

    }

}

参考资料：

1、《编程之美》

2、程序员编程艺术：第九章、闲话链表追赶问题

3、判断单链表是否存在环，判断两个链表是否相交问题详解

4、找含单链表的环入口点

5、程序员面试题精选100题