探究单向链表逆置转向及检查成环的问题

假设链表节点的数据结构为：

typedef struct node 
{
  int data;
  struct node* next;
}ListNode，*pListNode;

要求实现将一个单向链表逆置并检测如果链表成环返回FALSE,从参数返回新的链表头。

BOOL Reverse(pListNode& head);

这个问题看似简单，实际上太能发挥了。首先因为是单向链表，next不能简单的改变方向，要记录下即将被断开的节点，而即将被断开的节点它的next也是同样的问题。再者就是要如何检测有环。

单看逆置问题，通常的方法应该要用到3个指针：当前的p，下一个q，下一个的下一个head。 记下第三个指针，用第二个指向第一个，然后后移一步重复动作直到q没有下一个，再封口。

{
  if (head != NULL && head->next != NULL)
  {
    pListNode p = head;
    pListNode q = head->next;
    p->next = NULL;
    while (q->next != NULL)
    {
      head = q->next;
      q->next = p;
      p = q;
      q = head;
    }
    head->next = p;
  }
  return;   //此法未处理成环问题
}

单看检测成环问题，需要两个指针，一个向后一次移动一步，一个向后一次移动两步。假如他们能够相遇就是成环，他们任意一个走完链表都不成环。

{
  if( head==NULL)return;
  pListNode step1 = head;
  pListNode step2 = head;
  while(step1->next)
  {
    step1 = step1->next;
    if(step2->next)step2 = step2->next;
    else return TRUE;  //不成环
    if(step2->next)step2 = step2->next;
    else return TRUE;  //不成环
    if(step1==step2)return FALSE;
  }
  return TRUE; //不成环
}

以上两种方法都单独解决了部分问题，能不能同时解决两个问题呢?
于是我想到了递归。且不说它的弊端，单就解决问题而言是可行的。

BOOL Reverse(pListNode& head)  //不能处理成环检测
{
    pListNode p = head;
    if(p->next)
    {
      head = p->next;
      Reverse(head);
      p->next->next = p;
    }
    else
    {
      return FALSE;
    }
    return FALSE;
}

这个方法的问题是没法处理成环的问题。 在递归的背景下，解决成环的思路就想到如何标记一下处理过的node。于是我想到一个另类的做法。使用一个辅助结构体记录前后两个节点，把节点本身的next标为’1’,如果处理过程中发现next为1就是成环啦。

struct aid
{
  struct node* left;
  struct node* next;
};
BOOL Reverse(pListNode& head) //同时处理逆置和环检测
{
    if(!head)return FALSE;
    pListNode p = head;
    if(p->next)
    {
      if(p->next==1)return TRUE;  //成环
      aid *a = new aid;
      a->left = p;
      a->right = p->next;
      head = p->next;
      p->next = 1;
      if(Reverse(head)==TRUE)
      {
        delete a;
        return TRUE;
      }
      a->right->next = a->left;
      a->left->next = 0;
      delete a;
    }
    else
    {
      return FALSE;
    }
    return FALSE;
}

注意，以上代码都没有实测！请以思路为主自行参考尝试实现。