【Leetcode长征系列】Linked List Cycle

最新推荐文章于 2018-12-14 09:16:52 发布

LadyFeline

最新推荐文章于 2018-12-14 09:16:52 发布

阅读量435

点赞数

分类专栏： Algorithms

本文链接：https://blog.csdn.net/u010239096/article/details/37812997

版权

Algorithms 专栏收录该内容

76 篇文章 0 订阅

订阅专栏

原题：

Given a linked list, determine if it has a cycle in it.

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

解题思路：

网上有个说法是，每扫描到一个点，让该节点的next指向头结点。这个想法很巧妙，只可惜会破坏链表本身的结构，而且这个是有问题的。因为你不确定这个环究竟是在头结点出现还是在后面的普通节点中出现。

所以，我用的方法是基于以上做法的改进：我们每经历一个点，就一直往后扫，看是否有任何的点和它产生回路。当扫到最后以后，回到第二个点，继续按照第一个的方法，扫描接下来所有的点是否和该点有回路。以此类推，最后我们会把所有的点之间的关系检查一边。quite cool。

产生回路应该有两种情况：1. 自身的点指向自身。2. 后面的点指向了前面的点。

代码：

class Solution {
public:
    bool hasCycle(ListNode *head) {
        if (head==NULL||head->next==NULL) return false;
        
        ListNode *q = head;
        while (q!=NULL){
            ListNode *p = q->next;
            while(p!=NULL){
                if(p->next==q)  return true;
                p = p->next;
            }
            q = q->next;
        }
        return false;
    }
};

这个代码一直报错runtime error。下面的改动考虑了节点指向自己的情况。

/**
 * 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 *q = head;
        while (q!=NULL){
            ListNode *p = q->next;
            while(p!=NULL){
               //here is the change！
                if(p==q)  return true;
                p = p->next;
            }
            q = q->next;
        }
        return false;
    }
};

如上图所示，我没搞懂为什么会这样…If u know, plz do tell me!!!!!!

我这个算法的思想源自于以下代码的算法的思想：

class Solution {  
public:  
   
    bool find(ListNode *head, ListNode *testpNode)  
    {  
        ListNode *p = head;  
        while (p != testpNode->next)  
        {  
            if(p == testpNode)  
                return false;  
            p = p->next;  
        }  
        return true;  
    }  
   
   
    bool hasCycle(ListNode *head) {  
        // IMPORTANT: Please reset any member data you declared, as  
        // the same Solution instance will be reused for each test case.  
        if(head == NULL)  
            return false;  
   
        ListNode *cur = head;  
        while(cur != NULL)  
        {  
            if(find(head, cur))  
                return true;  
            cur = cur->next;  
        }  
        return false;  
    }  
};

这个程序AC了，但是速度很慢哦。

然后又看到了一个超级精简的方式，快慢指针法，算是方法2吧。

class Solution {
public:
bool hasCycle (ListNode *head){
    if(head==NULL||head->next==NULL)return false;
    ListNode *pFast,*pSlow;
    pFast=head;
    pSlow=head;
    while(pFast&&pFast->next){
        pSlow=pSlow->next;
        pFast=pFast->next->next;
        if(pFast==pSlow)return true;
    }
    return false;
}
};

AC了，并且很快！