java如何确定一个链表有环及入口节点

如何确定一个链表有环,入口节点是什么?

1.首先定义一个单链表;

var ,next,是单链表中的属性,分别表示节点值和下一个节点的指向;
代码如下:

//定义一个链表
  class  List{
    public  int var;
    public  List next;
//有参构造
    public List(int var) {
        this.var = var;
    }
//无参构造
    public List() {

    }
    //创建一个带环的链表
    public  List Create(){
        List a = new List(1);
        List b = new List(2);
        List c = new List(3);
        List d = new List(4);
        List e = new List(5);
        List f = new List(6);
        a.next = b;
        b.next =c;
        c.next = d;
        d.next =e;
        e.next = f;
        f.next =d;
        return  a;
    }

2.编写判断是否存在环

如果存在,则返回这个节点,如果不存在则返回null,定义快慢指针,如果快的追上了慢的指针,那么这个链表必存在环,如果没有追上,或者都为null,那么这个链表没有环;
代码如下:

//判断是否有环,并找到相遇的节点
public  List MeetingNode(List node){
    List slow = new List();
    List fast = new List();
    if(node==null) return  null;
    slow = node.next;
    if(slow==null) return  null;
    fast=slow.next;
    while (fast!=null && slow!=null){
        if (fast==slow){
            return fast; //fast追上了slow,确定是一个有环的链表;
        }
        slow = slow.next;
        fast = fast.next;
        if(fast!=null){
            fast = fast.next;
        }
    }
   return null;
}

3.寻找入口节点

先让快指针先走环的节点的个数步,在让慢指针开始走,如果两个指针相遇的话,那么相遇的节点必然是环的入口节点
代码如下:

  public  List Enterdear(List node){
        if(node==null) return null;
        if(MeetingNode(node)==null) return null;
        int count =1;
        List res2;
        List res1 = MeetingNode(node);
        while (res1.next!=MeetingNode(node)){
            res1 = res1.next;
            count++;
        }
        res1 = node;
        for(int i = 0;i<count;i++){
            res1 =res1.next;
        }
        res2 = node;
        while (res1!=res2 && res1!=null && res2!=null){
            res1 = res1.next;
            res2 = res2.next;
        }
        return res1;
    }
}

main函数测试;

ublic class Deom {

    public static void main(String[] args) {
       List SB = new List();
       List res = SB.Create();
       List dear= SB.Enterdear(res);
       System.out.println(dear.var);

    }

}

以上就是java如何确定一个链表有环及入口节点的详细内容,更多关于java链表及入口节点的资料请关注我们其它相关文章!

(0)

相关推荐

  • Java双向链表按照顺序添加节点的方法实例

    分析过程: 首先需要比较待添加的节点编号与已有的节点编号的大小,若待添加的节点编号已经存在,则不能加入.为防止出现空指针的情况,需要对节点的位置进行判断. 示例代码: package linkedlist; public class DoubleLinkedListDemo { public static void main(String[] args) { // 测试 System.out.println("双向链表的测试"); // 创建节点 Node node1 = new No

  • Java数据结构之链表(动力节点之Java学院整理)

    单链表: insertFirst:在表头插入一个新的链接点,时间复杂度为O(1) deleteFirst:删除表头的链接点,时间复杂度为O(1) find:查找包含指定关键字的链接点,由于需要遍历查找,平均需要查找N/2次,即O(N) remove:删除包含指定关键字的链接点,由于需要遍历查找,平均需要查找N/2次,即O(N) public class LinkedList { private class Data{ private Object obj; private Data next =

  • Java输出链表倒数第k个节点

    问题描述 输入一个链表,输出该链表中倒数第k个结点.(尾结点是倒数第一个) 结点定义如下: public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } } 思路1: 先遍历链表,计算其长度length; 然后计算出倒数第k个结点就是正数第length - k + 1. 最后再遍历链表,找到所求结点 时间复杂度O(2n),需要遍历两次链表 代码如下: public List

  • Java编程删除链表中重复的节点问题解决思路及源码分享

    一. 题目 在一个排序的链表中,存在重复的结点,请删除该链表中重复的结点,重复的结点不保留,返回链表头指针. 二. 例子 输入链表:1->2->3->3->4->4->5 处理后为:1->2->5 三. 思路 个人感觉这题关键是注意指针的指向,可以定义一个first对象(值为-1,主要用于返回操作后的链表),first.next指向head,定义一个last同样指向first(主要用于操作记录要删除节点的前一个节点),定义一个p指向head,指向当前节点.

  • Java实现双链表互相交换任意两个节点的方法示例

    本文实例讲述了Java实现双链表互相交换任意两个节点的方法.分享给大家供大家参考,具体如下: 概述: 双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱.所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点.一般我们都构造双向循环链表. 思路: 1.确定两个节点的先后顺序 2.next.prev互相交换顺序以及将换向前方的节点与之前的节点对接.(1.prev.next = 2) 3.判断是否相邻 实现代码: 链表类: publi

  • java如何确定一个链表有环及入口节点

    如何确定一个链表有环,入口节点是什么? 1.首先定义一个单链表: var ,next,是单链表中的属性,分别表示节点值和下一个节点的指向: 代码如下: //定义一个链表 class List{ public int var; public List next; //有参构造 public List(int var) { this.var = var; } //无参构造 public List() { } //创建一个带环的链表 public List Create(){ List a = new

  • PHP实现找出链表中环的入口节点

    本文实例讲述了PHP实现找出链表中环的入口节点.分享给大家供大家参考,具体如下: 问题 一个链表中包含环,请找出该链表的环的入口结点. 解决思路 第一步,找环中相汇点.分别用p1,p2指向链表头部,p1每次走一步,p2每次走二步,直到p1==p2找到在环中的相汇点. 第二步,找环的入口.接上步,当p1==p2时,p2所经过节点数为2x,p1所经过节点数为x,设环中有n个节点,p2比p1多走一圈有2x=n+x; n=x;可以看出p1实际走了一个环的步数,再让p2指向链表头部,p1位置不变,p1,p

  • Java通过索引值实现约瑟夫环算法

    问题描述:N个人围成一圈,从第一个人开始报数,报到m的人出圈, 剩下的人继续从1开始报数,报到m的人出圈:如此往复,直到所有人出圈 很多实现是使用链表结构,让元素构成一个圈,而我使用底层是数组的ArrayList集合实现,并且不需要遍历搜索,依靠数组特性:索引值,通过数学计算,让索引值构成一个圈,每次算出来的索引值,对应的那个元素一定是下一个出局的元素 这样的话,有n个元素,就只需要计算n次,删除n次,无需搜索,最大程度优化了程序的时间 import java.util.ArrayList; i

  • Java 利用递归实现链表的归并排序

    利用归并排序,我们可以将时间复杂度降至O(nlogn), 并且我们是对链表进行排序,可以通过修改引用来更改节点顺序,无需像数组一样开辟而外的空间. 利用递归实现链表的归并排序有两个环节: 分割cut环节: 我们可以利用fast, slow快慢双指针实现链表的分割, fast一次移动两位, slow一次移动一位,当fast移动到末尾时,slow移动到中间位置. 利用变量为tmp = slow.next记录后链表的头节点,并将slow.next = null将前后链表断开. ListNode sor

  • Java用单向环形链表来解决约瑟夫环Josepfu问题

    简单介绍 如果把单链表的最后一个节点的指针指向链表头部,而不是指向NULL,那么就构成了一个单向循环链表,通俗讲就是让尾节点指向头结点. 单向环形链表应用场景:Josephu(约瑟夫.约瑟夫环)问题: 设编号为1, 2, - n的n个人围坐一圈,约定编号为k (1<=k<=n)的人从1开始报数,数到m的那个人出列,它的下一位又从1开始报数,数到m的那个人又出列,依次类推,直到所有人出列为止,由此产生一个出队编号的序列. 代码实现 节点类 //节点类 class JNode { private

  • Java语言实现反转链表代码示例

    问题描述 定义一个函数,输入一个链表的头结点,反转该链表并输出反转后的链表的头结点.链表结点如下: public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } } 思路1: 要想反转链表,对于结点i,我们要把它的next指向它的前趋,因此我们需要保存前趋结点,同时,如果我们已经把i的next重新赋值,会无法找到i的后继,因此,在重新赋值之前,我们要保存i的后继. 代码:

  • java基于双向环形链表解决丢手帕问题的方法示例

    本文实例讲述了java基于双向环形链表解决丢手帕问题的方法.分享给大家供大家参考,具体如下: 问题:设编号为1.2--n的几个小孩围坐一圈,约定编号为k(1=<k<=n)的小孩从1开始报数,数到m的那个出列,他的下一位又从1开始报数,数到m的那个人又出列,直到所有人出列为止,由此产生一个出队编号的序列. 我们现在用一个双向环形链表来解这一问题.先来看看下面这幅图: 圆圈代表一个结点,红色的指针指向下一个元素,紫色的指针指向上一个元素.first指针指向第一个元素,表明第一个元素的位置,curs

  • 浅谈Java如何实现一个基于LRU时间复杂度为O(1)的缓存

    LRU:Least Recently Used最近最少使用,当缓存容量不足时,先淘汰最近最少使用的数据.就像JVM垃圾回收一样,希望将存活的对象移动到内存的一端,然后清除其余空间. 缓存基本操作就是读.写.淘汰删除. 读操作时间复杂度为O(1)的那就是hash操作了,可以使用HashMap索引 key. 写操作时间复杂度为O(1),使用链表结构,在链表的一端插入节点,是可以完成O(1)操作,但是为了配合读,还要再次将节点放入HashMap中,put操作最优是O(1),最差是O(n). 不少童鞋就

  • java实现简单单链表

    本文实例为大家分享了java实现简单单链表的具体代码,供大家参考,具体内容如下 一.定义: 单链表是一种链式存取的数据结构,用一组地址任意的存储单元存放线性表中的数据元素.链表中的数据是以结点来表示的,每个结点的构成:元素(数据元素的映象) + 指针(相当于JAVA中的引用,指示后继元素存储位置,),元素就是存储数据的存储单元,指针就是连接每个结点的地址数据. 二.结构: 如图所示,data就是当前节点的数据,next是指针,指针存放的是内存地址,是当前结点的下一结点内存地址,顺着这个地址就能找

随机推荐