一、     题目

给定一个链表。确定它是否有一个环。不使用额外的空间？

二、     分析

1. 空链表不成环

2. 一个节点自环

3. 一条链表完整成环

思路:使用两个指针，一个每次往前走2步，一个每次往前走1步。两指针一定会相遇，假设两个指针相遇，即说明链表有环存在。时间复杂度为O(N)，空间复杂度为O(1)。

/**

 * Definition for singly-linked list.

 * struct ListNode {

 *     int val;

 *     ListNode *next;

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

 * };

 */

class Solution {

public:

    bool hasCycle(ListNode *head) {

        if(head==NULL||head->next==NULL) return false;

        if(head->next==head) return true;

        ListNode* node1=head->next;

        ListNode* node2=head->next->next;

        while(node1!=NULL&&node2!=NULL){

        	node2=node2->next;

        	if(node2==NULL) break;

        	node2=node2->next;

        	node1=node1->next;

        	if(node1==node2) break;

        }

        return node1==node2;

    }

};

/**

 * Definition for singly-linked list.

 * struct ListNode {

 *     int val;

 *     ListNode *next;

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

 * };

 */

class Solution {

public:

    bool hasCycle(ListNode *head) {

        if(head==NULL||head->next==NULL) return false;

        ListNode* node=head->next;

        while(node!=NULL&&node->next!=NULL){

        	//一个每次往前走2步，一个每次往前走1步。两个相遇，

			//即链表有环。时间复杂度为O(N)。空间复杂度为O(1)。

if(node==head||node->next==head) return true;

        	node=node->next->next;

        	head=head->next;

        }

        return false;

    }

};

/**

 * Definition for singly-linked list.

 * struct ListNode {

 *     int val;

 *     ListNode *next;

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

 * };

 */

class Solution {

public:

    bool hasCycle(ListNode *head) {

        struct ListNode* fast = head;

        struct ListNode* slow = head;

        while (fast != NULL && fast->next != NULL) {

            fast = fast->next->next;

            slow = slow->next;

            if (fast == slow)

                return true;

        }

        return false;

    }

};