算法与数据结构-链表

最新推荐文章于 2024-07-13 08:21:27 发布
最新推荐文章于 2024-07-13 08:21:27 发布
阅读量177 收藏
点赞数 1
分类专栏： 算法与数据结构 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Al_tair/article/details/124571303
版权

算法与数据结构-链表

链表

单链表

概述

  1. 链表是以结点的方式进行存储
  2. 每个结点包含data域，next域：指向下一个结点
  3. 存储位置是无序的 and 未知的，但是存储的数据是有序的
  4. 链表分带头结点和不带头结点的链表，根据实际需求来

提问：数组和单链表有什么区别？

image-20211210200819665

  • 数组的存储位置是连续的，链表的存储位置是不连续的

  • 数组访问数据速度快，但是增加和删除数据的效率低；链表则与其相反

  • 数组存储内容就是数据，而链表存储内容是数据和下个结点的地址

  • 数组的存储空间是静态的，连续分布的，导致存储空间会出现过剩或者溢出现象

    链表的存储空间是动态分布的，只要内存空间尚有空闲，就不会产生溢出；链表中每个结点是可以动态变化的，空间利用率会更好

任务：英雄结点

任务要求：对英雄人物的创建，删除，更新，查找的实现

主函数调用

HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
HeroNode hero4 = new HeroNode(4, "李逵", "黑旋风");
HeroNode hero5 = new HeroNode(5, "林冲", "豹子头");

// 创建要给的链表
SingLeLinkedListDemo demo  = new SingLeLinkedListDemo();

// 加入4个节点
demo.addByOrder(hero1);
demo.addByOrder(hero3);
demo.addByOrder(hero2);
demo.addByOrder(hero4);
demo.update(hero5);
demo.delete(hero1);

// 显示链表
demo.list();

// 显示英雄的个数
System.out.println(demo.heroCount(SingLeLinkedListDemo.getHead()));
System.out.println("**************************************");

// 删除对应的英雄观察来判断正确
demo.delete(SingLeLinkedListDemo.bottomNode(SingLeLinkedListDemo.getHead(),4));
demo.list();
System.out.println("**************************************");

// 单链表的反转[腾讯面试题]
demo.ReverseHero(SingLeLinkedListDemo.getHead());
demo.list();
System.out.println("**************************************");
demo.ReverseHero2(SingLeLinkedListDemo.getHead());
demo.list();

定义一个链表类，用来生成每一个结点

class HeroNode{
    private int no;
    private  String name;
    private  String nickname;
    public  HeroNode next; // 指向下一个节点

    // 无参/有参构造函数
    public  HeroNode(){}
    public HeroNode(int no,String name,String nickname){
        this.name = name;
        this.no = no;
        this.nickname = nickname;
    }

    // 获得编号的方法
    public int GetNo(){
        return no;
    }

    // 获得姓名的方法
    public String GetName(){
        return name;
    }

    // 获得外号的方法
    public String GetNickname(){
        return nickname;
    }

    // 显示方便，重写toString()方法
    @Override
    public  String toString(){
        return "HeroNode[no="+no+",name="+name+",nickname"+nickname+"]";
    }
}

核心代码：具体实现算法

我分步骤进行讲述：

1.先初始化一个头节点，头节点不要动，不放具体数据

private static HeroNode head = new HeroNode(0,"","");
// 获得头结点
 public static HeroNode getHead() {
     return head;
 }

// 计算英雄的个数(单链表的节点个数)
public static int heroCount(HeroNode heroNode){
    int Length = 0;
    if(head == null){
        return 0;
    }
    HeroNode temp = head;
    while(temp.next != null){
        Length++;
        temp = temp.next;
    }
    return Length;
}

2.添加英雄结点（默认添加到最后一个位置）

// 添加节点到单项链表
// 思路:当不考虑编号顺序时
// 1.找到当前链表对的最后节点
// 2.将最后这个节点的next指向新的节点
public void add(HeroNode heroNode){
    // head节点不能动，我们需要用head结点来遍历链表
    HeroNode temp = head;
    // 遍历链表，找到最后一个结点
    while(true){
        if(temp.next == null){
            break;
        }
        temp = temp.next;
    }
    // 当退出while循环时候，temp就指向最后一个节点
    temp.next = heroNode;
}

3.添加英雄结点升级版（添加到指定位置）

public void addByOrder(HeroNode heroNode){
    // head节点不能动，我们需要用head结点来遍历链表
    HeroNode temp = head;
    while(true){
        if(temp.next == null){
            break;
        }
        if(temp.next.GetNo() == heroNode.GetNo()){  // heroNode.GetNo() 英雄数据编号
            throw new RuntimeException("传入英雄数据编号有误!");
        }
        // 找到指定位置 进行添加结点
        if(temp.next.GetNo() > heroNode.GetNo()){
            heroNode.next = temp.next;
            temp.next = heroNode;
            return;
        }
        temp = temp.next;
    }
    // 当退出while循环时候，temp就指向最后一个节点
    heroNode.next = temp.next;
    temp.next = heroNode;
}

4.更新英雄结点（根据英雄数据编号进行更新）

public void update(HeroNode heroNode){
    // 判断链表是否为空
    if(head.next == null){
        System.out.println("链表为空~~");
        return;
    }
    //找到需要修给的结点，根据编号修改该英雄结点数据
    HeroNode temp = head;
    while(true) {
        if (temp.next == null) {
            System.out.println("没有该编号的人物，无法更新");
            return;
        }
        if (temp.next.GetNo() == heroNode.GetNo()) {
            heroNode.next = temp.next.next;
            temp.next = heroNode;
            return;
        }
        temp = temp.next;
    }
}

5.删除英雄结点（根据英雄数据编号进行删除）

public void delete(HeroNode heroNode){
    // 判断链表是否为空
    if(head.next == null){
        System.out.println("链表为空~~");
        return;
    }
    //找到需要修给的节点，根据编号修删除该英雄结点数据
    HeroNode temp = head;
    while (true){
        if(temp.next == null){
            System.out.println("没有该人物英雄~~");
            return;
        }
        if(temp.next.GetNo() == heroNode.GetNo()){
            if(temp.next.GetName() == heroNode.GetName() && temp.next.GetNickname() == heroNode.GetNickname()){
                temp.next = temp.next.next;
                return;
            }else{
                System.out.println("删除的该人物英雄对象不匹配~~");
                return;
            }
        }
        temp = temp.next;
    }
}

6.显示全部链表数据

public void list(){
    // 判断链表是否为空
    if(head.next == null){
        System.out.println("链表为空!");
        return;
    }
    // 因为头节点不能动，因此需要一个辅助变量
    HeroNode temp = head;
    while (true){
        if(temp.next == null){
            break;
        }
        temp = temp.next;
        System.out.println("链表数据:"+temp.toString());
    }
}

面试题补充进该任务

1.查找单链表中倒数第K个节点[新浪面试题]

public static HeroNode bottomNode (HeroNode heroNode,int k){
    if(heroCount(heroNode) < k){
        return null;
    }
    int count = heroCount(heroNode) - k;
    HeroNode temp = head.next;
    while(count != 0){
        count--;
        temp = temp.next;
    }
    return temp;
}

2.单链表的反转[腾讯面试题]

/**
  * 单链表的反转[腾讯面试题]
  * 思路:
  * 1.先定义一个节点reverseHead = new HeroNode();
  * 2.从头到尾遍历原来的链表，每遍历一个节点就将其取出，并放在新的链表reverseHead的最前端
  * 3.原来的链表的head.next = reverseHead.next
  */
// MyCode
public static HeroNode ReverseHero(HeroNode heroNode){
    HeroNode reverseHead = new HeroNode(0,"","");
    if(heroNode.next == null) return heroNode;
    // 记录heroNode.next
    HeroNode next= heroNode.next;
    // 记录reverseHead.next
    HeroNode reverseNext= reverseHead.next;
    // 记录heroNode.next.next
    HeroNode nextNext = heroNode.next.next;
    while(next != null){
        if(nextNext != null){
            heroNode.next.next = reverseNext;
            reverseHead.next = next;
            heroNode.next = nextNext;
            nextNext = nextNext.next;
        }else{
            heroNode.next.next = reverseNext;
            reverseHead.next = next;
            heroNode.next = nextNext;
        }
        next = heroNode.next;
        reverseNext = reverseHead.next;
    }
    heroNode.next = reverseHead.next;
    return heroNode;
}

// Teacher's Code
public static HeroNode ReverseHero2(HeroNode heroNode){
    if(heroNode.next == null) return heroNode;
    HeroNode reverseHead = new HeroNode(0,"","");
    HeroNode next= heroNode.next; // 记录heroNode.next
    HeroNode nextNext = heroNode.next; // 记录heroNode.next.next

    while(next != null){
        nextNext = nextNext.next;
        next.next = reverseHead.next;
        reverseHead.next = next;
        next = nextNext;
    }
    heroNode.next = reverseHead.next;
    return heroNode;
}

双向链表

概述

对于一个结点，有单链表一样有存储数据的data,指向后方的 next 它拥有单链表的所有操作和内容。但是还有一个前驱节点 pre

image-20211210210241213

单链表 Vs 双向链表

  • 单链表，查找的方向只能是一个，而双向链表可以向前或者向后查找，灵活性大

  • 单向链表不能自我删除，需要靠辅助节点，而双向链表则可以自我删除

代码示例（修改自单向链表）

public class DoubleLinkedList {
    public static void main(String[] args) {
        HeroNoded[] heroList= new  HeroNoded[5];
        // 进行测试
        heroList[0] = new HeroNoded(1, "宋江", "及时雨");
        heroList[1] = new HeroNoded(2, "卢俊义", "玉麒麟");
        heroList[2] = new HeroNoded(3, "吴用", "智多星");
        heroList[3] = new HeroNoded(4, "李逵", "黑旋风");
        heroList[4] = new HeroNoded(5, "林冲", "豹子头");

        // 添加英雄结点数据
        DoubleLinkedListDemo demo  = new DoubleLinkedListDemo();

        for (int i = 0; i < heroList.length; i++) {
            demo.addHero(heroList[i]);
        }

        // 更新英雄结点数据
        demo.update(new HeroNoded(5, "鲁智深", "花和尚"));
        DoubleLinkedListDemo.list();
        System.out.println();
        System.out.println();

        // 删除节点
        demo.delete(new HeroNoded(5, "鲁智深", "花和尚"));
        DoubleLinkedListDemo.list();
    }
}


/**
 * DoubleLinkedList 管理我们的英雄
 */
class DoubleLinkedListDemo{
    private static HeroNoded head = new HeroNoded(0,"","");

    private boolean IsEmptyList(){
        return head.next == null;
    }

    // 增加英雄 (根据no排序)
    public void addHero(HeroNoded heroNoded){
        if(heroNoded == null){
            System.out.println("未传入英雄!!!");
            return;
        }
        if(IsEmptyList()){
            head.next = heroNoded;
            heroNoded.pre = head;
            return;
        }
        HeroNoded temp = head.next;
        while(true){
            if(temp.next == null) break;
            if(temp.GetNo() == heroNoded.GetNo()){
                throw new RuntimeException("传入英雄数据编号有误!");
            }
            // 加入的英雄结点的no 小于 双向链表中的某一个结点的no
            if(heroNoded.GetNo() < temp.GetNo()){
                temp.pre.next = heroNoded;
                heroNoded.next = temp;
                heroNoded.pre = temp.pre;
                temp.pre = heroNoded;
                return;
            }
            temp = temp.next;
        }
        // 当退出while循环时候，temp就指向最后一个节点
        temp.next = heroNoded;
        heroNoded.pre = temp;
    }

    // 更新功能：修改节点的信息即根据no编号来修改
    public void update(HeroNoded heroNoded){
        // 判断链表是否为空
        if(IsEmptyList()){
            System.out.println("链表为空~~");
            return;
        }
        //找到需要修给的节点，根据编号修改
        HeroNoded temp = head.next;
        while(true) {
            if (temp == null) {
                System.out.println("没有该编号的人物，无法更新");
                return;
            }
            if (temp.GetNo() == heroNoded.GetNo()) {
                if(temp.next != null){
                    heroNoded.next = temp.next;
                    temp.next.pre = heroNoded;
                }
                heroNoded.pre = temp.pre;
                temp.pre.next = heroNoded;
                return;
            }
            temp = temp.next;
        }
    }

    // 删除功能:从双向链表中删除一个节点的思路
    public void delete(HeroNoded heroNoded){
        // 判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空~~");
            return;
        }
        //找到需要修给的节点，根据编号修改
        HeroNoded temp = head.next;
        while (true){
            if(temp == null){
                System.out.println("没有该人物英雄~~");
                return;
            }
            if(temp.GetNo() == heroNoded.GetNo()){
                if(temp.GetName().equals(heroNoded.GetName()) && temp.GetNickname().equals(heroNoded.GetNickname())){
                    temp.pre.next = temp.next;
                    if(temp.next != null){
                        temp.next.pre = temp.pre;
                    }
                    return;
                }else{
                    System.out.println("删除的该人物英雄对象不匹配~~");
                    return;
                }
            }
            temp = temp.next;
        }
    }

    // 显示链表
    public static void list(){
        // 判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空!");
            return;
        }
        // 因为头节点不能动，因此需要一个辅助变量
        HeroNoded temp = head;
        while (true){
            if(temp.next == null){
                break;
            }
            temp = temp.next;
            System.out.println("链表数据:"+temp.toString());
        }
    }
}

/**
 * 定义HeroNode,每个HeroNode对象就是一个节点
 */
class HeroNoded{
    private int no;
    private  String name;
    private  String nickname;
    public  HeroNoded next; // 指向下一个节点
    public HeroNoded pre; //指向上一个结点

    // 无参/有参构造函数
    public  HeroNoded(){}
    public HeroNoded(int no,String name,String nickname){
        this.name = name;
        this.no = no;
        this.nickname = nickname;
    }

    // 获得编号的方法
    public int GetNo(){
        return no;
    }

    // 获得姓名的方法
    public String GetName(){
        return name;
    }

    // 获得外号的方法
    public String GetNickname(){
        return nickname;
    }

    // 显示方便，重写toString()方法
    @Override
    public  String toString(){
        return "HeroNode[no="+no+",name="+name+",nickname"+nickname+"]";
    }
}

练习

430. 扁平化多级双向链表

你会得到一个双链表，其中包含的节点有一个下一个指针、一个前一个指针和一个额外的 子指针 。这个子指针可能指向一个单独的双向链表，也包含这些特殊的节点。这些子列表可以有一个或多个自己的子列表，以此类推，以生成如下面的示例所示的 多层数据结构 。

给定链表的头节点 head ，将链表 扁平化 ，以便所有节点都出现在单层双链表中。让 curr 是一个带有子列表的节点。子列表中的节点应该出现在扁平化列表中的 curr 之后 和 curr.next 之前 。

返回 扁平列表的 head 。列表中的节点必须将其 所有 子指针设置为 null 。

示例 1：

image-20220503102529977

输入：head = [1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]
输出：[1,2,3,7,8,11,12,9,10,4,5,6]
解释：输入的多级列表如上图所示。
扁平化后的链表如下图：

示例 2：

image-20220503102552076

输入：head = [1,2,null,3]
输出：[1,3,2]
解释：输入的多级列表如上图所示。
扁平化后的链表如下图：

示例 3：

输入：head = []
输出：[]
说明：输入中可能存在空列表。

提示：

  • 节点数目不超过 1000
  • 1 <= Node.val <= 105

栈遍历

/*
// Definition for a Node.
class Node {
    public int val;
    public Node prev;
    public Node next;
    public Node child;
};
*/

class Solution {
    public Node flatten(Node head) {
        if(head == null || (head.next == null && head.child == null)) return head;
        else{
            Stack<Node> st = new Stack<>();
            Node node = head;
            while(node.next != null || node.child != null || !st.empty()){
                if(node.child == null && node.next == null && !st.empty()){
                    Node temp = st.pop();
                    temp.prev = node;
                    node.next = temp;
                }else if(node.child == null){
                    node = node.next;
                }else{
                    if(node.next != null){
                        st.push(node.next);
                    }
                    Node temp = node.child;
                    node.next = temp;
                    temp.prev = node;
                    node.child = null;
                }
            }
            return head;
        }
    }
}

执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：39.6 MB, 在所有 Java 提交中击败了29.70%的用户

环形链表

概述

如果把单链表的最后一个节点的指针指向链表头部，而不是指向NULL，那么就构成了一个单向循环链表，通俗讲就是让尾节点指向头结点。

image-20220507113440456

单向环形链表应用场景：Josephu(约瑟夫、约瑟夫环)问题

代码实现

image-20220507093058757

构建一个单向的环形链表思路
1.先创建第一个节点，让first指向该节点，并形成环形
2.后面当我们每创建一个新的节点，就把该节点，加入到已有的环形链表中即可
遍历环形链表
1.先让一个辅助指针（变量）temp,指向firt节点
2.然后通过一个while循环遍历该环形链表即可temp…next=first结束

package linkedList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class CircleSingleLinkedList {
    public static void main(String[] args) {
        final int nums = 25;
        CircleSingleLinkedListDemo circle = new CircleSingleLinkedListDemo();
        circle.addNode(nums);
        circle.showNode();
        System.out.println(circle.orderNode(1,2,nums));;

    }
}

class CircleSingleLinkedListDemo{
    private CircleNode firstNode;

    // 添加节点
    public void addNode(int nums){
        // 校验nums值
        String str = "^[1-9][0-9]*$";
        Pattern pattern = Pattern.compile(str);
        Matcher matcher = pattern.matcher(nums + "");
        if(!matcher.find()){
            System.out.println("输入num不正确!");
        }

        // 辅助节点
        CircleNode temp = null;
        // 创建nums个节点
        for (int i = 1; i <= nums; i++) {
            CircleNode circleNode = new CircleNode(i);
            if(i == 1){
                firstNode = circleNode;
                temp = firstNode;
                temp.next = firstNode;
            }
            else{
                temp.next = circleNode;
                temp = temp.next;
                temp.next = firstNode;
            }
        }
    }

    // 根据用户的输入计算节点出圈的顺序
    // startNo:开始数数的节点，countNums:数的次数 nums:一共有多少小孩在圈中
    public String orderNode(int startNo, int countNums,int nums){
        // 校验nums值
       if(firstNode == null || startNo < 1 || startNo > nums){
           System.out.println("输出数据有误!");
           return "";
       }else{
           String str = "";
           // temp指向开始节点的前一个节点,firstNode指向开始节点
           while(firstNode.next.getNo() != startNo){
               firstNode = firstNode.next;
           }
           CircleNode temp = firstNode;
           firstNode = firstNode.next;

           while(nums-- > 0){
               int step = countNums;
               while(step > 1){
                   firstNode = firstNode.next;
                   temp = temp.next;
                   step--;
               }
               str += firstNode.getNo() + "  ";
               firstNode = firstNode.next;
               temp.next = firstNode;
           }
           return str;
       }
    }

    // 显示节点
    public void showNode(){
        // 辅助节点
        CircleNode temp = firstNode;

        if(temp == null){
            System.out.println("环形链表为空");
        }

        while(temp.next != firstNode){
            System.out.println(temp);
            temp = temp.next;
        }
        System.out.println(temp);
    }
}

class CircleNode{
    private int no;
    public CircleNode next;

    public CircleNode(int no) {
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public CircleNode getNext() {
        return next;
    }

    public void setNext(CircleNode next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "CircleNode{" +
                "no=" + no +
                '}';
    }
}

练习

141. 环形链表

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

示例 1：

img

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

img

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

img

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

提示：

  • 链表中节点的数目范围是 [0, 104]
  • -105 <= Node.val <= 105
  • pos 为 -1 或者链表中的一个 有效索引 。

**进阶：**你能用 O(1)（即，常量）内存解决此问题吗？

哈希表

/**
 * 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) {
        HashSet<ListNode> set = new HashSet<>();
        while(head != null){
            if(set.contains(head)) return true;
            set.add(head);
            head = head.next;
        }
        return false;
    }
}

快慢指针

/**
 * 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,slow = head;
        while(slow != null){
            slow = slow.next;
            if(fast.next != null){
                fast = fast.next.next;
            }else{
                fast = fast.next;
            }
            if(slow == null || fast == null) return false;
            if(slow == fast) return true;
        }
        return false;
    }
}
执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：42.3 MB, 在所有 Java 提交中击败了64.21%的用户
142. 环形链表 II

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

img

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

img

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

img

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

提示：

  • 链表中节点的数目范围在范围 [0, 104] 内
  • -105 <= Node.val <= 105
  • pos 的值为 -1 或者链表中的一个有效索引

**进阶：**你是否可以使用 O(1) 空间解决此题？

哈希表

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head == null) return null;
        Set<ListNode> set = new HashSet<>();
        while(head != null){
            if(set.contains(head)){
                return head;
            }else{
                set.add(head);
            }
            head = head.next;
        }
        return null;
    }
}

快慢指针

分析图取自官方（a：未入环，紫色点是相遇点）

image-20220504113035631

数学分析原理

  1. 快慢指针的速度我们设置为快指针是慢指针的两倍

  2. 数学推导

    // 第一次相遇，在慢指针第一圈移动时，不管快指针在哪里，快指针总能追上慢指针
// 假设一圈为a+b,快指针和慢指针刚入环相差x,快指针每一步都可以多靠近慢指针一个点，所以一定会在a+b-x之前遇到，因为a+b-x<a+b,所以一定能追上
a+(n+1)b+nc=2(a+b)  ⟹  a=c+(n−1)(b+c)
a=c+(n−1)(b+c) 可以看出起点离入环点距离(a)等价于慢指针离入环点距离(c) + （n-1）圈
所以两者定会相交

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if (head == null) {
            return null;
        }
        ListNode slow = head, fast = head;
        while (fast != null) {
            slow = slow.next;
            if (fast.next != null) {
                fast = fast.next.next;
            } else {
                return null;
            }
            if (fast == slow) {
                ListNode ptr = head;
                while (ptr != slow) {
                    ptr = ptr.next;
                    slow = slow.next;
                }
                return ptr;
            }
        }
        return null;
    }
}
执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：42 MB, 在所有 Java 提交中击败了20.90%的用户
Al_tair
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构与算法之链表
乞力马扎罗的雪CYF的博客
02-23 3065
链表的分类：（1）单链表头插法：只需要维护一个头结点即可，常用来模拟堆栈；尾插法：需要维护头结点和尾结点，常用来模拟队列。（2）双向链表双向遍历，可以用来保存网页的历史记录等；（3）循环链表经常出现在面试题中，判断链表是否有环。链表的删除方式一：维护两个指针，current（表示当前节点）和previous（表示当前节点的前一个节点）。当current遍历到要删除的元素时，执行previous->
数据结构与算法-----链表
weixin_45932712的博客
08-05 315
线性表的链式存储结构链式存储∶用一组任意的存储单元存储线性表中的数据元素。用这种方法存储的线性表简称线性链表。 存储链表中结点的一组任意的存储单元可以是连续的，也可以是不连续的，甚至是零散分布在内存中的任意位置上的。 链表中结点的逻辑顺序和物理顺序不一定相同。 为了正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其直接后继结点的地址(或位置)，称为指针(pointer)或链(Ilink)，这两部分组成了链表中的结点结构，如图2-2所示。 链表是通过每个结点的指针域将线性表的n个结点按其逻..
单链表题目
10-17 1267
1. 单链表反转 一个指针（引用）curr指向原链表头；头指针head指向当前头（开始时指向原链表头）， 循环开始： next指向curr下一个节点，即next = curr.next；nextNext指向next下一个节点，即nextNext = next.next；（前两步根据curr更新next和nextNext的位置）next.next = head; head = next
慕课网学习笔记之数据结构一单链表（C++）
pg的博客
10-06 1082
单链表的每个结点分别由数据域data和指针域next组成，data里面装的是数据，next里面装的是下一个数据所在的地址，由next我们就可以找到下一个数据，这里next作用相当于“链条”，把一个个数据连接起来，这样在存储中，我们可以不必像顺序那样连续的存储，而是分开来存储，这也能体现出单链表的优点，即更充分的使用内存。
[XJTUSE]数据结构学习——第一章 线性表 1.3 单链表的实现（JAVA)
weixin_47692652的博客
09-09 476
[XJTUSE]数据结构学习——第一章 线性表 1.3 单链表的实现（JAVA)
C语言数据结构———单项循环链表
RaphaelCeo的博客
03-21 1288
单项循环链表
数据结构与算法 c语言 线性表-静态链表
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
数据结构-链表相关功能和算法
06-11
在这个"数据结构-链表相关功能和算法"的主题中，我们将深入探讨链表的原理、操作以及它们在实际问题中的应用。 链表的基本概念： 1. 链表是由一系列节点构成的，每个节点包含数据部分和指针部分，指针指向下一个...
【数据结构与算法 - 链表】
04-18
在实际应用中，链表常用于实现队列、栈、哈希表等高级数据结构，以及解决各种算法问题，如LRU缓存、图的深度优先搜索等。 总的来说，掌握链表及其C语言实现对于提升编程能力至关重要。通过模块化的设计，我们可以更...
链表_数据结构--链表_
10-01
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。与数组不同，链表的元素不是在内存中连续存储，而是通过节点之间的引用连接起来。每个节点通常包含两个部分：数据...
算法与数据结构-综合提升C++版.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
线性表的链式存储-单链表
DY_blog的专栏
06-06 217
逻辑结构上一个挨着一个的数据，在实际存储中，并没有像顺序表那样也相互紧挨着，恰恰相反，数据随机分布在内存的各个位置，这种存储结构称为线性表的链式存储。 由于分散存储，为了能够体现出数据元素之间的逻辑关系，每个数据元素在存储的同时，要配备一个指针，用于指向它的直接后继元素，即每一个数据元素都指向下一个数据元素（最后一个指向NULL（空））。 当每一个数据元素都和它下一个数据元素用指针链接在一起时...
c语言单链表基本书写中的内存溢出报错
MaYang_的博客
09-12 1396
#include<stdio.h> #include<stdlib.h> struct Node { int info; struct Node *link; }; typedef struct Node * LinkList;/*单链表类型*/ //头插法建立单链表 LinkList createNullList() { int x; char str;...
手动实现-队列
普拉旺斯
04-30 614
队列： 基本概念： 队列也是一种操作受限的线性表。只能在一端进行插入而在另一端进行删除。允许插入的一端称为队尾【rear】,允许删除的另一端称为队头【front】。队头删除元素称作出队，队尾插入元素称为进队。 队列ADT： 顺序队列： 队列顺序存储就是使用数组依次存储相应数据元素。此时队列称为顺序队列。 通常进队列数据由低地址到高地址一次存放。队头元素是数组中首元素。 pub...
数据结构-链表
CaraYQ的博客
05-14 405
目录206. 反转链表 206. 反转链表 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 示例1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 解： 迭代：以例1为例 你要反转一个链表 首先你肯定需要两个节点prev和curr（分别代表上一个节点和当前节点） 你要让当前节点的next指向prev节点才算反转了当前节点对吧 但是当当前节点的next指向prev节点的话 当前节点和后面的节点就断了连接 如下图 所以我们还需要一个节点next用来保存c
数据结构—链表
小芦荟同学的博客
08-06 698
链表 目录 一、概述 二、单链表 三、双链表 四、双指针 五、经典问题—反转链表 一、概述 1.链表是什么 2.链表的基本结构 3.链表的分类 4.链表和数组的比较 5.设计链表：源代码（含测试用例） 1.链表是什么 链表数一种线性数据结构。它是动态地进行储存分配的一种结构。 什么是线性结构，什么是非线性结构？ 线性结构是一个有序数据元素的集合。常用的线性结构有：线性表，栈，队列，双队列，数组，串。 非线性结构，是一个结点元素可能有多个直接前趋和多个直接后继。常见的非线性结构有：二维数组，多维数组，广义表，
算法复杂度＜数据结构 C版＞
最新发布
hukang的博客
07-13 1645
简单来说算法复杂度是用来衡量一个算法的优劣的，一个程序在运行时，对运行时间和运行空间有要求，即时间复杂度和空间复杂度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Al_tair

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值