leetcode Linked List Cycle II

Given a linked list, return the node where the cycle begins. If there is no cycle, return null.

Follow up:
Can you solve it without using extra space?

A fast pointer (hare) moves two steps every turn while the slow pointer (tortoise) moves only one step. If there is a circle, the slow pointer and the fast pointer will meet. 

If the circle begins at k steps from the head and the circle length is m. So the tortoise moves k + a*m +c, the hare moves k + b*m + c, i.e., 2*(k + a*m + c) == k + b*m +c, so k+c mod m == 0. If the tortoise returns to the starting point after meeting, the second meeting point is the circle-starting point. 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
 public:
  ListNode *detectCycle(ListNode *head) {
    ListNode *slow = head, *fast = head;
    do {
      if (fast != NULL && fast->next != NULL && fast->next->next != NULL) 
        fast = fast->next->next;
      else
        return NULL;
      slow = slow->next;
    } while (fast != slow);
    slow = head;
    while (slow != fast) {
      slow = slow->next;
      fast = fast->next;
    }
    return slow;
  }
};

Another AC version:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
 public:
  ListNode *detectCycle(ListNode *head) {
    if(head == NULL || head->next == NULL)
      return NULL;
    ListNode *fast = head, *slow = head;
    while (fast != NULL && fast->next != NULL) {
      fast = fast->next->next;
      slow = slow->next;
      if (fast == slow)
        break;
    }
    if (fast == slow) {
      fast = head;
      while (fast != slow) {
        fast = fast->next;
        slow = slow->next;
      }
      return fast;
    }
    else
      return NULL;
  }
};

Giving a glimpse of the WA version helps AC ONCE!!! WA version1:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
 public:
  ListNode *detectCycle(ListNode *head) {
    if(head == NULL || head->next == NULL)
      return head;
    ListNode *fast = head, *slow = head;
    while (fast != NULL && fast->next != NULL && fast != slow) {
      fast = fast->next->next;
      slow = slow->next;
    }
    if (fast == slow) {
      fast = head;
      while (fast != slow) {
        fast = fast->next;
        slow = slow->next;
      }
      return fast;
    }
    else
      return NULL;
  }
};