常见和链表相关的算法

一、 链表排序
    链表排序和数组排序的思路类似，只是链表操作起来比较麻烦，因为不能随机访问，所以只能借助于类似于前置或后置插入，添加等概念来完成。下面给出了链表排序的几种方法。
辅助代码:
//单链表节点的定义
typedef struct LinkNode{
    int val;
    struct LinkNode* next;
}LinkNode;
 
 
//由一个数组创建单链表
LinkNode* CreateList(int A[], int count)
{
    if(NULL == A)
        return NULL;
 
    LinkNode* head = (LinkNode*)malloc(sizeof(LinkNode));
    head->val = A[0];
    head->next = NULL;
    LinkNode* p = head;
   
    for (int i = 1; i < count; ++i)
    {
        p->next = (LinkNode*)malloc(sizeof(LinkNode));
        p->next->val = A[i];
        p->next->next = NULL;
        p = p->next;
    }
 
 
    return head;
}
 
 
//显示该单链表
void ShowList(LinkNode* L)
{
    LinkNode* p = L;
    printf("%d", p->val);
 
 
    while(p->next)
    {
        p = p->next;
        printf("-->%d", p->val);
    }
 
 
    printf("\n");
}
 
 
1. 插入排序（以从小到大排序为例）
    链表排序最容易想到的是插入排序，它的基本想法是从第一个节点开始，每次将一个节点放到结果链表，并保证每个节点加入到结果链表前后，结果链表都是有序的。每个节点在被链入结果链表时有三种情况：
1）该节点值比结果链表中的所有元素值都大，则将该节点追加到结果链表的最后；
2）该节点值比结果链表中的所有元素值都小，则将该节点插入到结果链表最前面；
3）该节点值在结果链表中处于中间位置，则将该节点插入到合适位置。
    下面是该算法思路的流程图：
 image
   
    代码实现如下：
 
LinkNode* SortLinkListInsertion(LinkNode* head)
{
    //链表空或链表只有一个节点，不必排序，直接返回原头结点
    if (NULL == head || NULL == head->next)
    {
        return head;
    }
 
 
    //我们从第二个节点进行处理，第一个节点作为结果链表的初始节点
    LinkNode* r = head->next;
    LinkNode* tmp;
    head->next = NULL; //将结果链表末尾标记为结束
 
 
    while(NULL != r) //依次处理每一个节点
    {
       
        if (r->val < head->val)
        {
            //将该节点插到结果链表最前，并修改链表头，同时注意辅助变量的使用
            tmp = r->next;
            r->next = head;
            head = r;
            r = tmp;
        }
        else
        {
            //否则从链表头部开始搜索，注意这里搜索结束的条件是当前被搜索节点不是最后一个节点
            LinkNode* p = head;
            while(NULL != p->next)
            {
                //注意只有当节点严格小于被搜索节点的下一节点的值是，才将其插入到被搜索节点后
                //这样能保证排序是稳定的！
                if (r->val < p->next->val)
                {
                    tmp = r->next;
                    r->next = p->next;
                    p->next = r;
                    r = tmp;
                    continue; //注意跳出，开始处理下一个节点
                }
                else
                {
                    p = p->next;
                }
            }
 
 
 
            //此时，p是结果链表中的末尾节点，将被处理节点追加到其后
            if (NULL == p->next)
            {
                tmp = r->next;
                r->next = NULL;
                p->next = r;
                r = tmp;
            }
        }//end else
    }//end while(NULL != r)
 
 
    return head;
}
 
2.  选择排序（以从小到大排序为例）
    选择排序的基本思想是每次从源链表中选取并移除一个最小的元素，追加到结果链表的尾部，直到源链表变空为止。因此本算法的关键点在于如何从源链表中选取并移除一个最小的元素。考虑到一般情况下，我们在移除链表中的某个元素时，需要知道它的前一个节点的指针（我知道你在想那个trick，但我想我们还是用正统的方法吧），于是我们可以按照最小元素的出现位置分为两种情况：最小元素是链表头部节点和最小元素不是链表头部节点。我们先找出链表中除头结点外的最小值节点，然后再和头节点的值比较，然后进行处理。寻找除头结点外的最小值节点的代码可以很简洁，这也是为什么要分成这两部分处理的原因。
 
 image
 
    代码实现如下：
LinkNode* SortLinkListSelection2(LinkNode* head)
{
    //我们这里即使不进行特殊情况处理，代码也能正常工作，可以代入检查
    //if (NULL == head || NULL == head->next)
    //{
    //    return head;
    //}
 
    LinkNode* p = NULL; //遍历辅助变量
    LinkNode* pminpre = NULL; //指向源链表中除头结点外的最小值节点的前驱节点
    LinkNode L = {0, NULL}; //我们这里用了一个哑节点，它能简化后面的代码
    LinkNode* Ltail = &L;  //Ltail用于指向结果链表的最后一个节点
 
    while (NULL != head && NULL != head->next) //循环处理源链表中节点个数不小于2个的情况
    {
        pminpre = head;
        p = head->next;
        while(NULL != p && NULL != p->next) //找出源链表中除头结点外的最小值节点的前驱节点
        {
            if (p->next->val < pminpre->next->val) //严格小于时才改变pminpre
                pminpre = p;
            p = p->next;
        }
        if (head->val <= pminpre->next->val) //和头结点值进行比较处理，值相等时，取头结点
        {
            Ltail = Ltail->next = head;
            head = head->next;
        }
        else
        {
            Ltail = Ltail->next = pminpre->next;
            pminpre->next = pminpre->next->next;
        }
    }
 
    Ltail = Ltail->next = head; //最后一个节点直接追加到结果链表的尾部
    Ltail->next = NULL; //设置结果链表的结束标记
 
    return L.next;
}
 
注意上面if语句中的 < 和 <= 判断，他们能使得链表的选择排序是稳定的排序。
 
3.  冒泡排序（以从小到大排序为例）
    链表的冒泡排序不太好想，主要是不太好控制比较边界。这里我们用一个标记指针end表示边界，每完成一趟冒泡后，end会被向前移一下，直到完成N-1趟冒泡。冒泡需要比较并交换相邻的节点，因此我们在实现中使用了pre，cur，n等指针分别表示当前处理节点的前驱，当前处理节点和下一节点。
 image
    链表冒泡排序的实现如下：
 
//asscending sort link list
LinkNode* SortLinkListBubble(LinkNode* head)
{
    if (NULL == head)
    {
        return head;
    }
 
 
    //init end pointer
    LinkNode* end = NULL;
 
 
    while(true)
    {
        LinkNode* n = head->next;
        if (n == end)
            break;
 
 
 
        //这里单独处理头结点和第二个节点的比较，这是没有哑头节点的链表的一个劣势
        if (n->val < head->val)
        {
            head->next = n->next;
            n->next = head;
            head = n;
        }
 
 
        LinkNode* pre = head;
        LinkNode* cur = head->next;
        LinkNode* tmp;
        n = cur->next;
 
 
        while(n != end)
        {
            if (n->val < cur->val)
            {
                tmp = n->next;
                cur->next = n->next;
                n->next = cur;
                pre->next = n;
                n = tmp;
            }
            else
            {
                n = n->next;
            }
            pre = pre->next;
            cur = cur->next;
        }
 
 
        end = cur;
    }
 
 
    return head;
}
 
4.  快速排序（从小到大排序）
    知道链表还可以快速排序是在笔试某公司时才发现的，当时只看到了个QsortList什么的，而且是个填空题，当时没有思路，也没有做出来，只记得那个QsortList带了3个参数，还返回了个链接点指针。回来后细想了一阵，发现原理和数组的快速排序是一样的，只是链表在处理指针时比较麻烦，而且要保证排序后链表还是有序地链接在一起，不能出现掉链等情况，有些绕人。
    思路这样，从链表中选取一个节点（一般简单地取头结点），将其值作为pivot，将链表中剩余的节点分成两个子链表，其中一个中的所有值都小于pivot，另一个中的所有值都不小于pivot，然后将这两条链表分别链接到pivot节点的两端。然后对于子链表分别进行递归该过程，直到子链表中只有一个节点为止。
    下面给出了链表快速排序的一种实现方法，该实现没有返回参数，链表头也是通过引用方式传入的。
void QsortList(LinkNode*& head, LinkNode* end)
{
    if(head == NULL || head == end)
        return;
    LinkNode* pivot = head;
    LinkNode* p = head->next;
    LinkNode* head1 = NULL, *tail1 = NULL;
    LinkNode* head2 = NULL, *tail2 = NULL;
    while(p != end)
    {
        if(p->val < pivot->val)
        {
            if(head1 == NULL)
            {
                head1 = tail1 = p;
            }
            else
            {
                tail1->next = p;
                tail1 = p;
            }
        }
        else
        {
            if(head2 == NULL)
            {
                head2 = tail2 = p;
            }
            else
            {
                tail2->next = p;
                tail2 = p;
            }
        }
        p = p->next;
    }
    if (tail1)
        tail1->next = pivot;
    if (head2)
        pivot->next = head2;
    else
        pivot->next = end;
    if (tail2)
        tail2->next = end;
    if (head1)
        head = head1;
    else
        head = pivot;
    QsortList(head, pivot); //这里是传入head, 而不能传入head1，因为head还可能被子调用修改
   
    //同样这里传入pivot->next而非head2，这样才能保证最后链表是有序链在一起的    
    QsortList(pivot->next, end);
}
调用QsortList时采用这样的方式QsortList(L, NULL);
数组的快速排序是不稳定的，原因是其实现时采用了交换的机制；而链表的快速排序则是稳定的，其原因是，被扫描的节点是有序地依次添加到子链表的末尾，保证了两个等值节点的相对位置不变。
 
 
二、关于链表的其他笔试面试题
    很多公司都考这个东西，其实考来考去本质就是那几道题，比较基础的东西，弄懂了其他类似的稍微变一下就行了。
1. 单链表倒置
    就是倒插法了，假想现在有一个空链表（这是链表的一个很好的优点，定义一个指针，你就可以声称创建了一个链表了，很节省空间），对输入的链表，从头到尾进行扫描，把每个节点都插入到假想链表的头部，然后返回假想的链表就可以，唯一需要注意的就是，边界情况和结束标记的NULL指针。
下面是一种实现：
Node* reverse(Node *head)
{
         if(NULL == head)
                   return head;
         Node *p = head->next;
         head->next = NULL;
         Node *tmp;
         while(NULL != p){
                   tmp = p->next;
                   p->next = head;
                   head = p;
                   p = tmp;
         }
         return head;
}
关于单链表的倒置，还有个递归的算法，虽然该算法在实际工作中没有任何作用，除了应付某些考试或仅仅作为一种谈资之外（当然，也可以说是在启发思维）：
Node *reverse(Node *head, Node *pre) {
    Node *p = head->next;
head->next = pre;
if(p)
    return reverse(p, head);
else 
    return head;
}
调用方式：reverse(head, NULL);
 
2. 求链表的倒数第K个节点，如果K大于链表长度则返回NULL。
    这也是某公司的笔试题之一，出题者的意图是不想让做题者遍历两次链表，即你不能先数链表中到底有几个节点。在不知道链表到底有几个节点的前提下找到倒数第K个节点，嗯，听起来很酷，虽然可以先数数到底有多少个，做做减法，再去找顺数第多少个（实际上这个笨笨的方法和那个酷酷的方法进行的机器操作数的差别基本可以忽略，只是在链表非常长，而K值很小的情况下，笨方法需要再从头来过，而酷方法可以每个节点过两次，因而占到了局部性原理的便宜）。说了这么多，还是看看实现吧，看了就明白了。
Node* BackKth(Node* head, int K)
{
    if(NULL == head || K <= 0)
        return NULL;
   
    Node* pK = head;
    while(NULL != pK && K > 1) //Note that head is the first Node
    {
        pK = pK->next;
        K--;
}
 
 
if(NULL == pK)          //K > LengthOfList
    return NULL;
 
Node* p = head;
 
 
while(NULL != pK->next) //Not the last Node
{
    p = p->next;
    pK = pK->next;
}
    return p;
}
 
3.  求链表的第K个节点
    “搞笑么？哪个公司会出这样的题啊？”呵呵，没有公司会出这样的题，我自己想的。只是为了下面可能用到，高手请跳过。
Node* KthNode(Node* head, int K)
{
    if(K <= 0)
        return NULL;
 
 
 
   
Node* p = head;
    while(NULL != p && K > 1)
    {
        p = p->next;
        K--;
    }
   
    return p;
}
 
4.  不知道单链表节点前驱的情况下，删除该节点
    被问到过这样的问题，我笑而不语。这只能算一个小小的trick，其方法就是将该节点的后继结点中的值数据拷到本节点中，然后删掉后继节点。要是节点中的数据很多很庞大，而且还需要深拷贝呢？=。=!
 
5.  求单链表的中间节点，偶数个节点时返回中间两个节点的前一个
    这是一个很经典的问题。当然也可以先数数链表中有多少个节点，然后遍历一半，这很直接，但是不够巧妙，相信也不会是提问者想要的答案。我们可以这样考虑，设想两个人跑步，一个人的速度是另外一个人的两倍，当速度快的人到达了终点，速度慢的人就在赛程的正中间。同样地，我们设置两个游动的指针，慢的指针移动步长为1，快的指针移动的步长为2。一开始都指向链表的头部，当遍历开始时，进行这样的操作：如果快的指针可以向前移动两步并且没有到达链表的尾部的话，快指针就向前移动2个节点，同时慢的指针向前移动1个节点；否则退出，返回慢指针。该算法的实现如下，注意区别链表长度为偶数和奇数的情况：
Node *FindMid(Node* head)
{
    if(NULL == head || NULL == head->next)
        return head;
        
    Node* p1 = head;
    Node* p2 = head;
    while(NULL != p2->next && NULL != p2->next->next)
    {
        p1 = p1->next;
        p2 = p2->next->next;
    }
    return p1;
}
 
现在把问题稍微改变一下，变成偶数个节点时返回中间两个节点的后一个。上面的算法中的循环需要稍微调整一下。前面的算法中，快指针p2每次都移动2步，而本问题中，我们需要改变下策略，变成：只要快指针p2能向前移动一步，那么快指针和慢指针就都同时向前移动一步，再看看快指针是否还能补上一步，如果能补上一步，那么就补上，然后进行下一轮循环，否则就表示到达了链表尾部，返回慢指针即可。实现如下：
Node* FindMin2(Node* head)
{
    if(NULL == head || NULL == head->next)
        return head;
        
    Node* p1 = head;
    Node* p2 = head;
        
    while(NULL != p2->next)
    {
        p2 = p2->next;
        p1 = p1->next;
        if(NULL == p2->next)
            return p1;
        else
            p2 = p2->next;
    }
 
 
    return p1;
}
这种步长法的想法很巧妙，后面的题中还会使用。
 
6. 判断单链表是否有环，并求出环开始的节点，参考[1]。如果没有环，就返回NULL。如下图中所示，该单链表环开始的节点是3。
 image
    首先，我们判断单链表是否有环，这里我们也借用了步长法，即指针p1，p2都指向链表头，然后开始遍历，p1每次移动一步，p2每次移动两步，然后判断p2有没有遇到p1。如果遇到了p1，说明链表有环；如果遇到之前，p2就已经到达链表尾部（值为NULL），说明链表没有环。判断单链表是否有环算法的实现如下：
BOOL FindCirleStart(LinkNode* L)
{
    LinkNode* p1 = L;
    LinkNode* p2 = L;
 
 
 
    while (NULL != p2->next)
    {
        p2 = p2->next;
 
 
        if(NULL == p2->next) //Not a cyclic link list
        {
            return FALSE;
        }
 
 
        p2 = p2->next;
        p1 = p1->next;
 
 
        if (p1 == p2)
        {
           return TRUE;
        }
    }
 
 
    return FALSE;
}
如何证明这个算法的正确性？p2最多要绕环转几圈才能追上p1？关于这一点可以参考[1]中的证明，这里也再转述下。
clip_image002
    上面的图是链表有环时的示意图，原作者没有把它化成链表结构，而只是以连续的线条代替，我们在考虑问题的时候需要注意到它们是离散的节点。下面就详细分析该算法的思路：
a. 如果链表无环，我们的算法是能得到正确的结果的；
b. 这里我们考虑链表有环的情况。按照算法的流程，当慢指针p1，到达环开始节点A时，此时快节点必定在环中的某个节点，我们假设为B。这里我们只是随便假设B而已，B可能在环中的任意位置，也有可能就是节点A（那样的话，算法就直接得到结果了）。我们假设指针以顺时针方向在环中移动，B距离A的长度为y个节点，可以认为B处的快指针p2落后于A处的快指针p1的距离为y（0 <= y < LengthOfCircle）个节点。现在开始赛跑，每轮循环快指针p2向前跑2个节点，慢指针p1向前跑1个节点，两者综合起来的效果就是快指针和慢指针的距离减少1个节点，因此经过y轮循环之后，两指针将相遇，且相遇点为A向前y个节点的M点。因此证明了上述算法是正确的。
 
下面我们再来看看作者是怎样求出环开始的节点A，顺便计算出环的长度的。
在前面的证明中，我们是从慢指针到达A点开始证明的，而忽略了前面从链表头到A点的x个距离。现在假设慢指针从链表头head到达A点时，快指针p2已经移动到了B点，设环长为s个节点，那么有关系式：2x = x + n * s + s - y。即x = (n+1)s–y。当慢指针p1和快指针p2同时到达M点时，即到达前面证明的最后时，我们再增加下面一些操作：另起一个指针p从链表头head开始移动，每次移动一个节点，同样慢指针p1也继续从M点向前移动。当p经过x步到达A时，p1也经过n*s + s - y到达A点，和p相遇，这样我们就找到了A点。在此过程中，我们可以同时记下p1反复经过M点的次数n，然后利用s = (x + y)/ (n + 1)计算环的长度。注意，我们无法直接单独得到x或y的值，但却能统计从head开始到慢指针p1和快指针p2第一次在M点相遇时经过的循环次数x + y。下面的实现中体现了这一点：
LinkNode* FindCirleStart(LinkNode* L, int &nCircleLen)
{
    LinkNode* p1 = L;
    LinkNode* p2 = L;
 
 
    int xy = 0; //x + y
 
 
    while (NULL != p2->next)
    {
        p2 = p2->next;
 
 
        if(NULL == p2->next) //Not a cyclic link list
        {
            return NULL;
        }
 
 
        p2 = p2->next;
        p1 = p1->next;
        xy++;
 
 
        if (p1 == p2)
        {
            LinkNode* M = p2;
            LinkNode* p = L;
            int n = 0;
            while (p != p1)
            {
                p = p->next;
                p1 = p1->next;
                if (p1 == M)
                {
                    n++;
                }
            }
 
 
            nCircleLen = xy/(n+1);
            return p; //此时的p即为A点
        }
    }
 
 
    return NULL;
}
 
另一种求环长的方法：当p1和p2第一次在M相遇时，我们已经知道了链表是有环的了，所以还可以通过一种简单的计数方法求环的长度，即用指针遍历环一圈，直到重新回到M点。只是这样，我们是无法得到环开始的节点A的。
 
不难证明，以上算法的复杂度是线性的。下面给出一个引申的问题，该问题也是类似，可以在线性时间内解决：
如果一个单链表可能有环，如何计算该链表的长度？
可以通过前面的方法判断是否有环，找到环开始节点A，并求出环长度。然后再计算从链表头head到A的距离，然后做计算。
 
7.  判断两个单链表是否相交，如果相交则返回交点的指针，否则返回NULL。
    这是《编程之美》上面的一个题，关于这个问题，一般的讨论都是基于无环单链表的，即第1）种情况，这里我们也讨论第2）种情况，即单链表存在环的情况，最后我们也讨论下，不知道到底属于那种情况下的解决方法。
1）无环情况
 image无交点
 image
有交点
    如上两图中分别显示了两单链表无环的情况下，无交点和有交点的情况。无环情况的判断和求交点都比较简单。判断的思路如下：分别找到L1链表和L2链表的最后一个节点，判断它们是不是同一个节点，如果是同一个节点，那么就两链表就是相交的；如果是不同的两节点，就是不相交的。求交点思路有些巧妙：在判断是否存在交点遍历两链表的时候，我们可以顺便分别计算两链表的长度，然后计算其长度差d，再分别从短链表和长链表的第d个节点开始遍历并判断两者是否相等，第一个相等的节点指针就是交点指针。实现如下：
//Return NULL if there no crossing node
Node* FindCrossingNodeNoLoop(Node* head1, Node* head2)
{
         if(NULL == head1 || NULL == head2)
                   return NULL;
 
 
         int Len1 = 1;
         Node* p1 = head1;
         while(NULL != p1->next){
                   Len1++;
                   p1 = p1->next;
         }
 
 
         int Len2 = 1;
         Node* p2 = head2;
         while(NULL != p2->next){
                   Len2++;
                   p2 = p2->next;
         }
 
 
         if(p1 != p2)         //Different ending Node, no crossing node
                  return NULL;
        
         p1 = head1;
         p2 = head2;
         if(Len1 > Len2){
                   int K = Len1 – Len2;
                   while(K > 0){
                            p1 = p1->next;
                            K--;
                   }
         }
         else if (Len1 < Len2){
                   int K = Len2 – Len1;
                   while(k > 0){
                            p2 = p2->next;
                            K--;
                   }
         }
        
         while(p1 != p2){
                   p1 = p1->next;
                   p2 = p2->next;
         }
        
         return p1;
}
 
2） 有环情况
    无交点情况（1）和无交点情况（2）分别显示了一条及两条链表有环时，不相交的情况，这两种情况在设计算法时需要做一些考虑。
 image 无交点情况（1）
 image 无交点情况（2）
   
    有交点情况（1）显示了环在交点后面的情况。
 image
有交点情况（1）
    有交点情况（2）显示了交点是环开始的节点的情况。
 image
有交点情况（2）
    有交点情况（3）显示了链表交点在环中间的情况。这种情况比较复杂，此时我们既可以认为交点是A节点，也可以认为交点是B节点。如果我们把环看成是L2的，那么就是L1交L2于A点；如果我们把环看成L1的，那么就是L2交L1于B点。实际上，这个环也是L1和L2共有的。因此此种情况下A和B都是链表的交点，我们只能通过距离远近来分辨了。距离L1较近的交点是A，距离L2较近的焦点是B。这个问题具有对称性，后面我们会利用该性质。
 image
有交点情况（3）
   
    如何判断有环情况下链表是否存在交点，并求出交点，这个问题似乎比较复杂，我们不能直接使用无环情况下的算法了，因为我们无法进行链表结束判断。不过，如果我们将其转化无环情况的话，就能使用已有的算法了。想想我们之前找到有环链表的环开始节点，以及求环长度的算法，这里我们可以直接利用。知道环开始节点和环长度后，我们就可以找到环的末节点（理论上，环是没有末节点的，这里的末节点就是环开始节点的前驱节点），然后断开环。下面是有交点情况（1）和（2）断开环后的示意图，实际上除了环开始节点和交点的相对位置不同外，这两种情况可以归为一种类型：两链表环开始节点相同。image
有交点情况（1）断开后
 image
有交点情况（2）断开后
    对于有交点情况（3），它属于另一种类型：两链表的环开始节点不同。对于该种类型，我们有两种断开方法，一种是选择断开L1的环，另一种选择是断开L2的环。实际上，由于两链表是共享环的，所以随便从哪个链表断开环，另外一个链表中的环也就自动断开了。下面是分别从L1和L2断开环的情况：
 image 有交点情况（3），从L1断开环
 image
有交点情况（3），从L2断开环
    这里我再给出有交点情况（3）的另一种表达方式，它和前面的图没有什么区别，只是可能看起来舒服些：
 image 有交点情况（3）的等效图
    因此我们不难看出，既可以说L1交L2于A，也可以说L2交L1于B。如果我们选择断开L1，那么所求的交点为B，如果我们从L2断开，那么所求交点为A。
    另外一点需要注意的是，我们再断开环后，还要在适当的时候对其进行还原，即重置End的指针为Start节点的地址。
    基于问题的全面性考虑，下面是无交点情况下经过断开处理后的示意图：
 image
无交点情况（1）断开后
 image
无交点情况（2）断开后
    最后给出有环情况下的求链表交点的算法，注意该算法的前提是链表有环：
Node* FindCrossingNodeLoop(Node* L1, Node* L2)
{
    int nCircleLen1;
    Node* Start1 = FindCircleStart(L1, nCircleLen1);
    Node* Last1 = NULL;
    Node* cNode = NULL; //crossing node
 
    if(NULL == Start1)       
    {
        //L1中不存在环，结合前提，L2中必存在环，那么L1和L2肯定不相交，参考无交点情况（1）
        return NULL;
    }
    else
    {
        Last1 = KthNode(Start1, nCircleLen1); //找到环的末节点，这是前面的一个小算法
        Last1->next = NULL;  //断开L1中的环
    }
   
    //执行到这里时，说明L1中存在环，并且已经被断开了   
 
    int nCircleLen2;
    Node* Start2 = FindCircleStart(L2, nCircleLen2);
    Node* Last2 = NULL;
    if(NULL != Start2)       
    {
        //L2中仍然存在环路，那么必然是不同的环，L1和L2也肯定不相交，参考无交点情况（2）
        goto end;
    }
            
    //从L1的末尾断掉环，按(1)处理
    cNode = FindCrossingNodeNoLoop(L1, L2);
 
end:
    Last1->next = Start1;  //注意还原环
    return cNode;
}
    此函数是断开第一条链表，以上面的有交点情况（3）为例子，如果我们调用FindCrossingNodeLoop(L1, L2)，那么我们将得到B节点；如果我们调用FindCrossingNodeLoop(L2, L1)，那么将得到A点。对于有交点情况（1）和（2），两种调用得到的A和B将为同一个点。
 
3） 不知道是否有环情况
    FindCrossingNodeNoLoop和FindCrossingNodeLoop是分别已知链表无环和有环情况下对应的解决方法。如果我们事先并不确定链表是否有没有环，那么我们该如何写FindCrossingNode函数呢？我们可以用下面的方法解决：
Node* FindCrossingNode(Node* L1, Node* L2)
{
    int nCircleLen1;
    Node* Start1 = FindCircleStart(L1, nCircleLen1);
    Node* Last1 = NULL;
    int nCircleLen2;
    Node* Start2 = FindCircleStart(L2, nCircleLen2);
    Node* Last2 = NULL;
    Node* cNode = NULL; //crossing node
 
    if(NULL == Start1 && NULL == Start2)
    {
        //L1和L2都无环
        return FindCrossingNodeNoLoop(L1, L2);
    }
   
    if(NULL != Start1)
    {
        Last1 = KthNode(Start1, nCircleLen1);
        Last1->next = NULL;//断开L1的环
        Start2 = FindCircleStart(L2, nCircleLen2);
        if(NULL != Start2)
            goto end; //仍然能找到环，那就属于有环无交点情况（2）
        cNode = FindCrossingNodeNoLoop(L1, L2);
    }
    else
    {
        //根据判断条件，此时必然是L1中无环，L2中有环，此时两链表不可能相交
        //这里我们可以什么都不做
    }
 
end:
    if(NULL != Last1)
        Last1->next = Start1;
    if(NULL != Last2)
        Last2->next = Start2;
   
    return cNode;
}
   
    以上是算法的初步实现，相信该算法还可以做一些化简和调整方面的工作，不过暂时我就写到这里吧。
 
参考：
[1] 判断单链表是否有环，求环长和环路起始节点 http://tan1019.spaces.live.com/blog/cns!1880820F8EF99DDA!466.entry?wa=wsignin1.0&sa=185164612