Interview----判断两个链表是否相交？

题目描述：

判断两个单链表是否相交？假设链表没有环。

假如链表有环呢？

1.  假如没有环

那么如果两个链表相交的话，必然最后的节点一定是同一个节点。所以只需要各自扫描一遍链表，找到最后一个节点，比较是否相同即可。

O ( M + N)

// version 1
// test whether two lists are intersected
// assume each list has no circle
bool IsIntersectedNoCircle(ListNode *lhs, ListNode *rhs)
{
  if(lhs == NULL || rhs == NULL)
    return false;

  ListNode *tail1(lhs);
  for(; tail1->next; tail1 = tail1->next);

  ListNode *tail2(lhs);
  for(; tail2->next; tail2 = tail2->next);

  return tail1 == tail2;
}

2. 可能有环

首先，如何判断是否有环？

采用快慢指针，一个指针一次走两步，一个指针一次走一步，如果链表有环的话，必然最后慢指针会赶上快指针。

复杂度同样是 O （ M + N）。

如果还要求求出 进入环的那个节点： 可以用两个指针，一个从链表head 出发，另一个从刚刚快慢指针的相遇点出发，速度相同。

可以证明，两指针必定在入口处第一次相遇。

// test whether list has a circle
// if true, return the enter node
// if not,  return NULL
ListNode* HasCircle(ListNode *list)
{
  if(list == NULL || list->next == NULL)
    return NULL;

  // fast/slow pointer method
  // if circled, slow pointer will catch up with fast one
  ListNode *fast(list), *slow(list);

  while(fast)
  {
    fast = fast->next;
	if(fast == NULL) return NULL;
	fast = fast->next;
	slow = slow->next;

	if(fast == slow)
	  break;
  }
  assert(fast == NULL || slow == fast); 

  if(fast == NULL)
    return NULL;

  // list definitely has a circle
  // find the enter node
  // fast and enter will meet at the enter node
  ListNode *enter(list);

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

  return enter;
}

根据是否有环，可以分为以下三个 case:

case 1: 都没有环：已经分析

case 2: 都有环： 注意到如果相交，这两个环必定是一模一样的。所以，只要判断是否有一个节点在另一个环中即可。

case 3: 一个有环，一个没有环： 一定不相交

// version 2
// assume lists may have a circle inside
bool IsIntersectedCircle(ListNode *lhs, ListNode *rhs)
{
  ListNode *enter1(NULL), *enter2(NULL);

  enter1 = HasCircle(lhs);
  enter2 = HasCircle(rhs);

  // case 1: both lists have no circles
  if(enter1 == NULL && enter2 == NULL)
  {
    return IsIntersectedNoCircle(lhs, rhs);
  }
  // case 2: each have a circle
  else if(enter1 && enter2)
  {
    ListNode *node(enter1->next); 

	while(node != enter1 && node != enter2){
	  node = node->next;
	}
	return node == enter2;
  }
  // case 3: one has a circle, while the other not
  else
  {
    return false;
  }
}

完整代码如下：

// copyright @ L.J.SHOU Feb.27, 2014
// test whether two lists are intersected
#include <iostream>
#include <cassert>
using namespace std;

struct ListNode{
  int val;
  ListNode *next;
  ListNode(int x)
    :val(x), next(NULL){}
};

ListNode* HasCircle(ListNode*);
bool IsIntersectedCircle(ListNode*, ListNode*);

// version 1
// test whether two lists are intersected
// assume each list has no circle
bool IsIntersectedNoCircle(ListNode *lhs, ListNode *rhs)
{
  if(lhs == NULL || rhs == NULL)
    return false;

  ListNode *tail1(lhs);
  for(; tail1->next; tail1 = tail1->next);

  ListNode *tail2(lhs);
  for(; tail2->next; tail2 = tail2->next);

  return tail1 == tail2;
}

// version 2
// assume lists may have a circle inside
bool IsIntersectedCircle(ListNode *lhs, ListNode *rhs)
{
  ListNode *enter1(NULL), *enter2(NULL);

  enter1 = HasCircle(lhs);
  enter2 = HasCircle(rhs);

  // case 1: both lists have no circles
  if(enter1 == NULL && enter2 == NULL)
  {
    return IsIntersectedNoCircle(lhs, rhs);
  }
  // case 2: each have a circle
  else if(enter1 && enter2)
  {
    ListNode *node(enter1->next); 

	while(node != enter1 && node != enter2){
	  node = node->next;
	}
	return node == enter2;
  }
  // case 3: one has a circle, while the other not
  else
  {
    return false;
  }
}

// test whether list has a circle
// if true, return the enter node
// if not,  return NULL
ListNode* HasCircle(ListNode *list)
{
  if(list == NULL || list->next == NULL)
    return NULL;

  // fast/slow pointer method
  // if circled, slow pointer will catch up with fast one
  ListNode *fast(list), *slow(list);

  while(fast)
  {
    fast = fast->next;
	if(fast == NULL) return NULL;
	fast = fast->next;
	slow = slow->next;

	if(fast == slow)
	  break;
  }
  assert(fast == NULL || slow == fast); 

  if(fast == NULL)
    return NULL;

  // list definitely has a circle
  // find the enter node
  // fast and enter will meet at the enter node
  ListNode *enter(list);

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

  return enter;
}

// destroy list
ListNode* Destroy(ListNode *list)
{
  ListNode *next(NULL);

  while(list)
  {
    next = list->next;
	delete list;
	list = next;
  }

  return NULL;
}

int main(void)
{
  ListNode *list(NULL);

  // testing case 1: both have no circles
  list = new ListNode(1);
  list->next = new ListNode(2);
  list->next->next = new ListNode(3);

  ListNode *list2 = list->next;
  cout << IsIntersectedCircle(list, list2) << endl;

  // testing case 2: both have circles
  list2 = new ListNode(1);
  list2->next = new ListNode(2);
  list2->next->next = list->next;

  list->next->next->next = list->next;
  cout << IsIntersectedCircle(list, list2) << endl;

  list->next->next->next = NULL;
  list2->next->next = NULL;

  // testing case 3: only one has a circle
  list->next->next->next = list->next;
  cout << IsIntersectedCircle(list, list2) << endl;
  list->next->next->next = NULL;

  list = Destroy(list);
  list2 = Destroy(list2);

  return 0;
}