编程判断俩个链表是否相交

 

个人认为，算法永远是王道。此处将截取编程之美这本书上经典的算法题，以飨各位。

同时，除了旁征博引之外，也会加入我个人的思考。所写之处，望不吝赐教。

July  2010年10月。

------------------------------------------

 

1.编程判断俩个链表是否相交

给出俩个单向链表的头指针，比如h1，h2，判断这俩个链表是否相交。

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

 

 

问题扩展：

1.如果链表可能有环列?

2.如果需要求出俩个链表相交的第一个节点列?

 

 

 

以下是算法实现部分：

如何判断一个单链表是有环的？（注意不能用标志位，最多只能用两个额外指针）
一种O（n）的办法就是

用两个指针，一个每次递增一步，一个每次递增两步，如果有环的话两者必然重合，反之亦然：
bool check(const node* head)
{
    if(head==NULL) return false;
    node *low=head, *fast=head->next;
    while(fast!=NULL && fast->next!=NULL)
    {
        low=low->next;
        fast=fast->next->next;
        if(low==fast) return true;
    }
    return false;
}

 

 

扩展1：如果链表可能有环，则如何判断两个链表是否相交
思路：链表1 步长为1，链表2步长为2 ，如果有环且相交则肯定相遇，否则不相交

list1 head: p1
list2 head: p2
while( p1 != p2 && p1 != NULL && p2 != NULL )  //因为当链表有环但不相交时，此处是死循环。!
{

      p1 = p1->next;
      if ( p2->next )
         p2 = p2->next->next;
      else
         p2 = p2->next;
}
if ( p1 == p2 && p1 && p2) //相交
else //不相交

//July：如果链表带环 但不相交列? 此算法，还可行么?

于此，还得好好总结下，问题得这样解决：

1.先判断带不带环

2.如果都不带环，就判断尾节点是否相等

3.如果都带环，那么一个指针步长为1遍历一链表，

另一指针，步长为2，遍历另一个链表。

但第3点，如果带环 但不相交，那么程序会陷入死循环。。

所以，此方法只适用于带环且相交的情况下才有用。

 

问题解决之道：

我们在判断链表带环的时候，用俩指针遍历其中一条链表，若带环则此俩指针将相遇于一节点，

即，据此节点，看在不在另一条链表上。如果在，则相交，如果不在，则不相交。

至此，问题，方才得到较圆满解决。!

1.先判断带不带环

2.如果都不带环，就判断尾节点是否相等

3.如果都带环，判断一链表上俩指针相遇的那个节点，在不在另一条链表上。

如果在，则相交，如果不在，则不相交。

July  2010年10月

-------------------------------

July(786165179) 20:28:53
ei，以俩指针 分别遍历俩个链表时，
俩指针 各自相遇的点，应该可以处在 同一个点吧 
July(786165179) 20:30:41
好比，AB一快一慢跑一有圈的跑道
     CD 一快一慢也跑一有圈的跑道
如果，这俩跑道 是相同的距离列?
那么 AB  CD 相遇的点就一定在同一坐标点了...对吧 
July(786165179) 20:31:39
那么，只要找出AB 相遇的点 P，
然后再判断 这个点 P在不在另一条链表上，即ok了。

 

 

------------

扩展2：求两个链表相交的第一个节点
思路：在判断是否相交的过程中要分别遍历两个链表，同时记录下各自长度。

Node* step( Node* p, Node* q)
{
  if ( !p || !q ) return NULL;
  int pLen = 1;
  int qLen = 1;
  bool result = false;
  while( p->next )
  {
    pLen++;

    p = p->next;
  }
  while( q->next )
  {
    qLen++;

    q = q->next;
  }
  result = ( p == q );
  if ( result )
  {
    int steps = abs( pLen - qLen);
    Node* head = pLen > qLen ? p : q;
    while ( steps ) //对齐处理
   {
     head = head->next, steps--;
    }
    pLen > qLen ? p = head : q = head;
    while ( p != q )
   {
     p = p->next, q = q->next;
    }
    reutrn p;
  }
  return NULL;
}