判断链表是否有环及两链表是否相交

单向链表是最常用的数据结构之一，因此总结其常见的问题及其解决方案是很有意义的。

 

问题1：如何判断一个单向链表是否有环？如果有，如何找到其入口节点的指针？

 

              算法思想：用两个指针p1,p2同时指向链表的头部，p1一次移动一步，p2一次移动两步，如果最终p1和p2重合则说明链表有环，如果p2走到空指针（链表的结尾）则说明链表无环； 如果最终p1和p2重合，使p2重新指向链表的头结点，然后p1和p2同时一次移动一步，当p1和p2再次重合时该节点指针就是环的入口节点指针。

              算法实现：

             

[cpp] view plain copy print ?

1. struct Node    
2. {    
3.     int value;    
4.     Node *next;        
5. };    
6. /*判断链表是否有环，如果有环则返回环的首结点指针，否则返回NULL值*/    
7. Node* findCircle(Node *head)    
8. {    
9.     if(head==NULL)    
10.         return NULL;    
11.     Node *p1=head;    
12.     Node *p2=head;    
13.     /*判断链表是否有环，当p1=p2时说明链表有环，程序跳出循环。如果p2一直走到链表尽头则说明没有环。*/    
14.     do{    
15.         if(p1->next!=NULL&&p2->next!=NULL&&p2->next->next!=NULL)    
16.         {    
17.             p1=p1->next;    
18.             p2=p2->next->next;       
19.         }    
20.         else    
21.             return NULL;    
22.     }    
23.     while(p1!=p2);    
24.         
25.     /*求出环的起点节点，并将其返回*/    
26.     p2=head;    
27.     while(p1!=p2)    
28.     {    
29.         p1=p1->next;    
30.         p2=p2->next;        
31.     }    
32.     return p1;           
33. }    

struct Node  
{  
    int value;  
    Node *next;      
};  
/*判断链表是否有环，如果有环则返回环的首结点指针，否则返回NULL值*/  
Node* findCircle(Node *head)  
{  
    if(head==NULL)  
        return NULL;  
    Node *p1=head;  
    Node *p2=head;  
    /*判断链表是否有环，当p1=p2时说明链表有环，程序跳出循环。如果p2一直走到链表尽头则说明没有环。*/  
    do{  
        if(p1->next!=NULL&&p2->next!=NULL&&p2->next->next!=NULL)  
        {  
            p1=p1->next;  
            p2=p2->next->next;     
        }  
        else  
            return NULL;  
    }  
    while(p1!=p2);  
      
    /*求出环的起点节点，并将其返回*/  
    p2=head;  
    while(p1!=p2)  
    {  
        p1=p1->next;  
        p2=p2->next;      
    }  
    return p1;         
}  

 

问题2：假定两个单向链表均无环。如何判定该两个链表相交？如果相交，如何找到首个相交点的指针？

        

   

               

           算法思想：判断两个单向链表是否相交，有两个方法：一是利用其充要条件，即，相交的充要条件是两个链表最后一个表元为同一表元；二是将第二个链表接在第一个链表后面，然后判断第一个链表是否有环，如果有，则他们必然相交，否则不相交。   如何找到相交的首个节点呢？其实也就是第一个链表的环的入口节点。

            

            算法实现：

          

[cpp] view plain copy print ?

1. struct Node    
2. {    
3.     int value;    
4.     Node *next;        
5. };    
6. /*判断两个链表是否交叉，如果交叉返回交叉节点，否则返回NULL。*/    
7. Node* findCross(Node* head1,Node* head2)    
8. {    
9.     if(head1==NULL||head2==NULL)    
10.         return NULL;    
11.     /*将第二个链表变成有环链表*/    
12.     Node* tail2=head2;    
13.     while(tail2->next!=NULL)    
14.         tail2=tail2->next;    
15.     tail2->next = head2;    
16.            
17.     Node* temp = findCircle(head1);    
18.     if(temp!=NULL)    
19.         return temp;    
20.     else    
21.         return NULL;    
22.               
23. }    

struct Node  
{  
    int value;  
    Node *next;      
};  
/*判断两个链表是否交叉，如果交叉返回交叉节点，否则返回NULL。*/  
Node* findCross(Node* head1,Node* head2)  
{  
    if(head1==NULL||head2==NULL)  
        return NULL;  
    /*将第二个链表变成有环链表*/  
    Node* tail2=head2;  
    while(tail2->next!=NULL)  
        tail2=tail2->next;  
    tail2->next = head2;  
         
    Node* temp = findCircle(head1);  
    if(temp!=NULL)  
        return temp;  
    else  
        return NULL;  
            
}  

 

 注意：上面两个例子中，均默认有哑节点，即head代表哑节点。

http://blog.csdn.net/kevinzhangyang/article/details/6637503