链表相交

 

给定两个单链表，表头分别为head1和head2.判断两个链表是否相交，如果不相交返回null，如果相交，则给出相交的第一个交点。

对题目进行简单分析后不难得出，因为链表的特殊存储结构，使得其在存储结构上如果交叉则一定为“Y”型或者为“V”型，不可能为“X”型。所以相交只需求出第一个交点。

算法具体实现可以如下

public Node FindSameNode(Node head1, Node head2)
        {
            if (head1 == null || head2 == null)
            {
                return null;
            }
            //两个Node用于托管两个Linkedlist，这样在操作时候不会破坏原有Node地址。
            Node tNode1 = head1;
            Node tNode2 = head2;

            //用于记录两个链表的长度。
            int lHead1 = 0, lHead2 = 0;

            //用于求出连个链表的长度，
            while (tNode1 != null)
            {
                tNode1 = tNode1.next;
                lHead1++;
            }

            while (tNode2 != null)
{
                tNode2 = tNode2.next;
                lHead2++;
            }
            //到最后都没有相交，必然没有相交。
            if (tNode1 != tNode2)
            {
                return null;
            }
            //相交了，这时还可以继续从参数提取俩链表首地址。
            else
            {
                tNode1 = head1;
                tNode2 = head2;//没有这两个赋值，他们的next都为null了。

                //先假设两个链表长度不一样，求出他们的长度差。
                int f = System.Math.Abs(lHead1 - lHead2);

                //先判断后循环，小优化。
                if (lHead1 > lHead2)
                {
                    //使长的链表将长的一部分走完，之后就能一起走到交点。当循环结束，两个链表指针到末尾的长度一样了。
                    for (int k = 0; k < f; k++)
                    {
                        tNode1 = tNode1.next;
                    }
                    while (tNode1 != tNode2)
                    {
                        tNode1 = tNode1.next;
                        tNode2 = tNode2.next;
                    }
                    //两个指针一样了，返回谁都一样。
                    return tNode1;

                }
                else
                {
                    //长度相等会进此分支，只不过第一个循环不执行。其余，类似逻辑，只不过判断在外，这样代码多了，但是快一些。
                    for (int k = 0; k < f; k++)
                    {
                        tNode2 = tNode2.next;
                    }
                       while (tNode1 != tNode2)
                    {
                        tNode1 = tNode1.next;
                        tNode2 = tNode2.next;
                    }

                    return tNode1;
                }
            }
        }

扩展：如果链表可能有环呢

判断单链表是否存在环，判断两个链表是否相交问题详解
有一个单链表，其中可能有一个环，也就是某个节点的next指向的是链表中在它之前的节点，这样在链表的尾部形成一环。

问题：

1、如何判断一个链表是不是这类链表？
2、如果链表为存在环，如何找到环的入口点？

解答：

一、判断链表是否存在环，办法为：

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

bool IsExitsLoop(slist *head)
{
    slist *slow = head, *fast = head;

    while ( fast && fast->next ) 
    {
        slow = slow->next;
        fast = fast->next->next;
        if ( slow == fast ) break;
    }

    return !(fast == NULL || fast->next == 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)循环内环+相遇点到环入口点，于是我们从链表头、与相遇点分别设一个指针，每次各走一步，两个指针必定相遇，且相遇第一点为环入口点。程序描述如下：

slist* FindLoopPort(slist *head)
{
    slist *slow = head, *fast = head;

    while ( fast && fast->next ) 
    {
        slow = slow->next;
        fast = fast->next->next;
        if ( slow == fast ) break;
    }

    if (fast == NULL || fast->next == NULL)
        return NULL;

    slow = head;
    while (slow != fast)
    {
         slow = slow->next;
         fast = fast->next;
    }

    return slow;
}