精华内容
下载资源
问答
  • 判断一个链表是否有环 思路:我们定义一个快指针,一个慢指针;都从头结点开始走,快指针每次走两步,慢指针一次走一步,则: 如果一个链表有环,那么两个指针在一直走的过程中一定会相遇。 如果链表没有环,那么快...

    判断一个链表是否有环

    思路:我们定义一个快指针,一个慢指针;都从头结点开始走,快指针每次走两步,慢指针一次走一步,则:

    • 如果一个链表有环,那么两个指针在一直走的过程中一定会相遇。
    • 如果链表没有环,那么快指针一定会先走完链表,指向null。
      在这里插入图片描述
    /**
     * Definition for singly-linked list.
     * class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) {
     *         val = x;
     *         next = null;
     *     }
     * }
     */
    public class Solution {
        public boolean hasCycle(ListNode head) {
            ListNode fast = head;
            ListNode slow = head;
            while(fast != null && fast.next != null){
                fast = fast.next.next;
                slow = slow.next;
                if(slow == fast){
                    return true;
                }
            }
            return false;
        }
    }
    
    展开全文
  • 如何判断一个链表是否有环

    千次阅读 2019-02-09 19:58:10
    如何判断一个链表是否有环 问题陈述 ​ 如何判断一个链表是否有环,如果有,则返回第一个进入环的节点,没有则返回null。 思路 ​ 如果一个链表无环,那么遍历链表一定可以遇到链表的终点;如果链表有环,那么遍历...

    如何判断一个链表是否有环

    问题陈述

    ​ 如何判断一个链表是否有环,如果有,则返回第一个进入环的节点,没有则返回null。

    思路

    ​ 如果一个链表无环,那么遍历链表一定可以遇到链表的终点;如果链表有环,那么遍历链表就永远在环内转下去。具体如下:

    ​ 1.设置快慢指针分别为fast和slow。开始,slow和fast都指向链表的头节点head。然后slow每次移动一步,fast每次移动两部,在链表中遍历。

    ​ 2.如果链表无环,fast指针在移动过程一定先遇到终点,直接返回null,表示链表无环。

    ​ 3.如果有环,fast和slow一定在环中相遇。相遇时,fast重新回到head位置,slow不动。接下来,fast指针每次移动一步,slow依然每次移动一步,继续遍历。

    ​ 4.fast和slow指针一定会再次相遇,并在第一个入环的节点处相遇,证明略。

    代码

    public Node getLoopNode(Node head){
        if (head == null || head.next == null || head.next.next == null){
            return null;
        }
        Node n1 = head.next; //n1 -> slow
        Node n2 = head.next.next; // n2 -> fast
        while (n1 != n2){
            if (n2.next == null || n2.next.next == null){
                return null;
            }
            n2 = n2.next.next;
            n1 = n1.next;
        }
        n2 = head; // n2 -> walk again from head
        while (n1 != n2){
            n1 = n1.next;
            n2 = n2.next;
        }
        return n1;
    }
    
    展开全文
  • 链表的分类 链表主要分为三类: 单向链表只能从表头到表尾的顺序,每个节点中保存了指向下一个节点的指针; 双向链表则可以反向遍历,...一个比较经典的问题,判断个链表是否相交,如果相交找出他们的交点。 解...

    链表的分类

    链表主要分为三类:
    单向链表只能从表头到表尾的顺序,每个节点中保存了指向下一个节点的指针;
    双向链表则可以反向遍历,因为节点中既保存了向后节点的指针,又保存了向前节点的指针。
    循环链表指的是在单向链表和双向链表的基础上,将两种链表的最后一个结点指向第一个结点从而实现循环。

    判断两个链表是否相交并找出交点

    问题描述:

    一个比较经典的问题,判断两个链表是否相交,如果相交找出他们的交点。

    解决方法:

    判断两个链表是否相交并找出交点主要分两种情况

    两个链表均不含有环
    		1.直接法:第一个链表节点是否在两个中
    		2.hash计数法:链表A的节点地址进行hash排序,建立hash表,判断另一节点地址是否在hash表中
    		3.转换链表,查看是否又环
    链表中有环时
    		1.切断链表中的环,判断第二个链表是否又环
    		2.直接判断:一个链表有环,一个链表无环,一定没交点
    
    情况一:两个链表均不含有环

    1、直接法

    采用暴力的方法,遍历两个链表,判断第一个链表的每个结点是否在第二个链表中,**时间复杂度为O(len1len2),耗时很大。

    2、hash计数法

    如 果 两个链表相交,则两个链表就会有共同的结点;而结点地址又是结点唯一标识。因而判断两个链表中是否存在地址一致的节点,就可以知道是否相交了。可以对第一 个链表的节点地址进行hash排序,建立hash表,然后针对第二个链表的每个节点的地址查询hash表,如果它在hash表中出现,则说明两个链表有共 同的结点。
    这个方法的时间复杂度为:O(max(len1+len2);但同时还得增加O(len1)的存储空间存储哈希表。这样减少了时间复杂度,增加 了存储空间

    3.转换链表,查看是否又环
    第三种思路是比较奇特的。先遍历第一个链表到他的尾部,然后将尾部的next指针指向第二个链表(尾部指针的next本来指向的是null)。这样两个链表就合成了一个链表,判断原来的两个链表是否相交也就转变成了判断新的链表是否有环的问题了:即判断单链表是否有环

    情况二:链表中有环时

    1.切断链表中的环,判断第二个链表是否又环

    当两个链表中有环时,相交的判断:
    如果链表有环且相交,那么这两个链表都是有环的。

    找到第一个链表的环点,然后将环断开(当然不要忘记了保存它的下一个节点),然后再来遍历第二个链表,如果发现第二个链表从有环变成了无环,那么他们就是相交的嘛,否则就是不相交的了。

    2.直接判断:一个链表有环,一个链表无环,一定没交点
    当一个链表中有环,一个链表中没有环时,两个链表必不相交。

    其他详细博客

    判断一个链表是否有环

    在这里插入图片描述
    有一个单向链表,链表当中有可能出现“环”,就像题图这样。如何用程序判断出这个链表是有环链表?

    不允许修改链表结构。
    时间复杂度O(n),空间复杂度O(1)。
    
    方法一、穷举遍历

    方法一:首先从头节点开始,依次遍历单链表的每一个节点。每遍历到一个新节点,就从头节点重新遍历新节点之前的所有节点,用新节点ID和此节点之前所有节点ID依次作比较。如果发现新节点之前的所有节点当中存在相同节点ID,则说明该节点被遍历过两次,链表有环;如果之前的所有节点当中不存在相同的节点,就继续遍历下一个新节点,继续重复刚才的操作。

    例如这样的链表:A->B->C->D->B->C->D, 当遍历到节点D的时候,我们需要比较的是之前的节点A、B、C,不存在相同节点。这时候要遍历的下一个新节点是B,B之前的节点A、B、C、D中恰好也存在B,因此B出现了两次,判断出链表有环。

    假设从链表头节点到入环点的距离是D,链表的环长是S。那么算法的时间复杂度是0+1+2+3+….+(D+S-1) = (D+S-1)*(D+S)/2 , 可以简单地理解成 O(N * N)。而此算法没有创建额外存储空间,空间复杂度可以简单地理解成为O(1)。

    方法二、哈希表缓存

    首先创建一个以节点ID为键的HashSet集合,用来存储曾经遍历过的节点。然后同样是从头节点开始,依次遍历单链表的每一个节点。每遍历到一个新节点,就用新节点和HashSet集合当中存储的节点作比较,如果发现HashSet当中存在相同节点ID,则说明链表有环,如果HashSet当中不存在相同的节点ID,就把这个新节点ID存入HashSet,之后进入下一节点,继续重复刚才的操作。

    这个方法在流程上和方法一类似,本质的区别是使用了HashSet作为额外的缓存。

    假设从链表头节点到入环点的距离是D,链表的环长是S。而每一次HashSet查找元素的时间复杂度是O(1), 所以总体的时间复杂度是1*(D+S)=D+S,可以简单理解为O(N)。而算法的空间复杂度还是D+S-1,可以简单地理解成O(N)。

    方法三、快慢指针

    首先创建两个指针1和2(在java里就是两个对象引用),同时指向这个链表的头节点。然后开始一个大循环,在循环体中,让指针1每次向下移动一个节点,让指针2每次向下移动两个节点,然后比较两个指针指向的节点是否相同。如果相同,则判断出链表有环,如果不同,则继续下一次循环。

    例如链表A->B->C->D->B->C->D,两个指针最初都指向节点A,进入第一轮循环,指针1移动到了节点B,指针2移动到了C。第二轮循环,指针1移动到了节点C,指针2移动到了节点B。第三轮循环,指针1移动到了节点D,指针2移动到了节点D,此时两指针指向同一节点,判断出链表有环。

    此方法也可以用一个更生动的例子来形容:在一个环形跑道上,两个运动员在同一地点起跑,一个运动员速度快,一个运动员速度慢。当两人跑了一段时间,速度快的运动员必然会从速度慢的运动员身后再次追上并超过,原因很简单,因为跑道是环形的。

    /**
     * 判断单链表是否存在环
     * @param head
     * @return
     */
    public static <T> boolean isLoopList(ListNode<T> head){
        ListNode<T> slowPointer, fastPointer;
    
        //使用快慢指针,慢指针每次向前一步,快指针每次两步
        slowPointer = fastPointer = head;
        while(fastPointer != null && fastPointer.next != null){
            slowPointer = slowPointer.next;
            fastPointer = fastPointer.next.next;
    
            //两指针相遇则有环
            if(slowPointer == fastPointer){
                return true;
            }
        }
        return false;
    }
    

    假设从链表头节点到入环点的距离是D,链表的环长是S。那么循环会进行S次(为什么是S次,有心的同学可以自己揣摩下),可以简单理解为O(N)。除了两个指针以外,没有使用任何额外存储空间,所以空间复杂度是O(1)

    展开全文
  • 给定一个链表判断链表中是否有环。 为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环。 示例 1: 输入:head = [3,2,0,-4], ...

    题目:

    给定一个链表,判断链表中是否有环。
    
    为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环。
    
    示例 1:
    
    输入:head = [3,2,0,-4], pos = 1
    输出:true
    解释:链表中有一个环,其尾部连接到第二个节点。

    思路:给的pos啥意思?又不作为参数,写来干什么

    使用快慢指针,慢指针一次走一步,快指针一次走二步,如果链表有环,必然相交

     public boolean hasCycle(ListNode head) {
            if(head==null||head.next==null){
                return false;
            }
            ListNode left=head,right=head.next;
            while(left!=null &&right!=null&&right.next!=null){
                if(left==right){
                    return true;
                }
                left=left.next;
                right=right.next.next;
            }
            return false;
     }

    但是我个人认为此题的作用太小,我们可以将目光放大一点,我们不仅要判断是否有环,而且还要返回入环的第一个节点

    public  ListNode process(ListNode head) {
    		ListNode fast = head;
    		ListNode slow = head;
    		while (slow!=fast) {
    			if(fast.next==null||fast.next.next==null) {
    				return null;
    			}
    			slow = slow.next;
    			fast = fast.next.next;
    		}
    		fast = head;
    		while (fast != slow) {
    			fast = fast.next;
    			slow = slow.next;
    		}
    		return fast;
    }

     

    展开全文
  • * 判断一个链表是否有环, * 思路是快慢指针法,通过判断两个节点是否==, * 即内存地址相同则证明链表有环存在 */ public class LinkedListCycle { /** * 给定一个链表,判断链表中是否有环。 * 为了表示...
  • 在这个算法中,如果没有环就会返回NULL: //基本数据类型定义: ...//判断一个链表是否有环并找到其入口 #define MaxSize 100 LNode* FindRange(LinkList &L) { LNode *p=L; int i=0; LNode* array[MaxSize];
  • 给出两个单向链表的头指针,判断这两个链表是否相交,如果相交给出相交的第一个结点 一、两个链表均不含有  方法一:直接法  直接判断一个链表的每个结点是否在第二个链表中,时间复杂度为O(len1*len...
  • 如何判断一个链表是否存在环?  一般思路就是设置两个指针,都指向头结点,不同的是指针的速度不同,一个走的快,定义为快指针,一个走的慢定义为慢指针。倘若存在环形结构,快指针终将与慢指针相遇。 判断...
  • 问:怎样判断一个链表是否有环 答:可以利用两个指针(快慢指针)。从链表头出发,指针1每次走一步,指针2每次走二步。若指针1与指针2相遇,则说明链表有环。 问:怎样判断环连接点在哪里? 答:设链表头到...
  • [算法]判断一个链表是否有环

    千次阅读 2016-05-06 21:05:43
    如何判断一个链表是否有环解题思路: 定义两个指针fast和slow,其中fast是快指针,slow是慢指针,二者的初始值都指向链表头,slow每前进一步,fast每次前进两步,两个指针同时向前移动,快指针每移动一次都要和慢...
  • 设计一个算法完成以下功能:判断一个链表是否有环,如果有,找出换的入口且返回,否则返回NULL 解题思路 根据题意分析第一次相遇的情况,如图所示:(首先假设是有环的,因无环的情况不会相遇,可直接排除) soft...
  • 判断一个单链表是否有环及环的链接点(转) (2011-09-16 10:24:10) 转载▼   分类: 学习笔记 给定一个单链表,只给出头指针h: 1、如何判断是否存在环? 2、如何知道环的长度? 3、...
  • 给出一个链表判断链表是否有环 2. 我们可以使用一种比较经典的方式来进行处理,就是使用两个指针来进行移动,一个为快指针,一个为慢指针,快指针一次移动两步,慢指针一次移动一步,假如链表有环的话那么这两个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,050
精华内容 1,620
关键字:

判断一个链表是否有环