编程导航算法通关村第一关 | 链表中环的问题与双向链表

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

1. 链表中环的问题

1.1 判断链表中是否有环

1.1.1 使用Hash

遍历链表的时候将元素放入到map中, 如果有环一定会发生碰撞, 发生碰撞的位置也就是环的入口。在代码实现中, 使用set集合:

 /**
     * 方法1：通过HashMap判断
     *
     * @param head
     * @return
     */
    public static boolean hasCycleByMap(ListNode head) {
        Set<ListNode> seen = new HashSet<ListNode>();
        while (head != null) {
            if (!seen.add(head)) {
                return true;
            }
            head = head.next;
        }
        return false;
    }

1.1.2 双指针

快指针每次走两步, 慢指针每次走一步, 如果链表中存在环, 则双指针在某一个节点必然会相遇。

这里需要的是:

快指针在快追上慢指针的时候不会存在跳过去,导致两个指针无法相遇的情况。

快指针在快追上慢指针的时候只会出现以下两种情况:

  1. 快指针和慢指针相差一步
  2. 快指针和慢指针相差两步

在第一种情况下, 下一次遍历两个指针就会相遇, 而在第二种情况下, 下一次遍历后就会变成情况1。

/**
     * 方法2 通过双指针实现
     *
     * @param head
     * @return
     */

    public static boolean hasCycleByTwoPoint(ListNode head) {
        if (head == null || head.next == null) {
            return false;
        }
        ListNode fast = head, slow = head;
        while (fast != null && slow != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) {
                return true;
            }
        }
        return false;
    }

1.2 确定环的入口

快指针每次走两步, 慢指针每次走一步。
在这里插入图片描述

① 一圈就相遇的情况

快指针在第二次进入环的时候与慢指针相遇, 以图中Z节点为例。此时快指针走了 a + b + c + b 步, 慢指针走了 a + b 步, 由于快指针每次走的

距离都是慢指针的 2 倍, 那么可得出等式 2 * ( a + b ) = a + b + c + b, 所以 a = c。因此此时让慢指针从Z节点继续向前走, 快指针回到起点,

两个同时开始走 (每次都走一步), 那么最终它们会在 Y 点相遇, 正是环的入口。

② 如果多圈之后才相遇

设链表中环外部分的长度为 a。慢指针进入环后, 又走了 b 的距离与快指针相遇。此时快指针已经走完了环的 n 圈, 一次它走过的总距离为:

快指针: a + n * (b+c) + b = a + n * c + (n+1) * b;

由于任意时刻，fast 指针走过的距离都为 slow 指针的 2 倍。所以又可得到下列公式:

2 * ( a + b ) = a + ( n + 1 ) * b + n * c

也就是: a = c + ( n - 1 ) * ( b + c )

由于 b + c 就是环的长度, 假如为LEN, 则 a = c + ( n - 1 ) * LEN, 说明在相遇的时候快指针已经在环里转了 n - 1 圈, 当 n 等于 1 时, 也就是

上述一圈就相遇的情况。

/**
     * 通过双指针实现
     *
     * @param head
     * @return
     */

    public static ListNode detectCycleByTwoPoint(ListNode head) {
        if (head == null) {
            return null;
        }
        ListNode fast = head, slow = 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;
    }

1.3 三次双指针

将问题拆分为三个步骤, 并分别使用双指针进行处理:

  1. 判断是否有环。快指针一次走两步, 慢指针一次走一步, 如果两个指针最终相遇, 说明有环
  2. 计算环的大小。当两个指针相遇后, 让慢指针固定在相遇位置, 快指针以一步的频率继续遍历链表, 当再次相遇时, 就得到了环的长度 k
  3. 通过查找倒数第 k 个节点的方法来确定入口
/**
   * 方法3 通过三次双指针实现
   *
   * @param head
   * @return
   */
  public static ListNode detectCycleByTwoPointThreeTimes(ListNode head) {
    if (head == null) {
      return null;
    }
    ListNode fast = head, slow = head;
    // 1. 判断是否有环。快指针一次走两步, 慢指针一次走一步, 如果两个指针最终相遇, 说明有环 
    while (fast != null) {
      slow = slow.next;
      if (fast.next != null) {
        fast = fast.next.next;
      } else {
        return null;
      }
      if (fast == slow) {
        // 2. 计算环的大小。当两个指针相遇后, 让慢指针固定在相遇位置, 快指针以一步的频率继续遍历链表, 当再次相遇时, 就得到了环的长度 k
        ListNode temp = slow;
        int k = 1;
        while (temp.next != slow) {
          temp = temp.next;
          k++;
        }
        // 3. 通过查找倒数第 k 个节点的方法来确定入口
        slow = head;
        fast = head;
        while (fast != null && k-- > 0) {
          fast = fast.next;
        }
        while (fast != null && fast != slow) {
          fast = fast.next;
          slow = slow.next;
        }
        return slow;
      }
    }
    return null;
  }

2. 双链表

2.1 基本概念

和单链表相比, 双链表既可以向后遍历, 也可以向前遍历。

在这里插入图片描述

class DoubleNode {
    public int data;    //数据域
    public DoubleNode next;    //指向下一个结点
    public DoubleNode prev;
    public DoubleNode(int data) {
        this.data = data;
    }
    //打印结点的数据域
    public void displayNode() {
        System.out.print("{" + data + "} ");
    }
}

2.2 插入元素

当链表为空时:

在这里插入图片描述

插入头节点:

在这里插入图片描述

/**
 * 空链表插入
 * @param data
 */
public void insertFirst(int data) {
    DoubleNode newDoubleNode = new DoubleNode(data);
    if (isEmpty()) {
        last = newDoubleNode;
    } else {//如果不是第一个结点的情况
        first.prev = newDoubleNode;    //将还没插入新结点之前链表的第一个结点的previous指向newNode
    }
    newDoubleNode.next = first;        //将新结点的next指向first
    first = newDoubleNode;            //将新结点赋给first（链接）成为第一个结点
}

插入尾节点时:

在这里插入图片描述

/**
 * 尾部插入
 * @param data
 */
public void insertLast(int data) {
    DoubleNode newDoubleNode = new DoubleNode(data);
    if (isEmpty()) {
        first = newDoubleNode;        //若链表为空，则将first指向新的结点（newNode）
    } else {
        newDoubleNode.prev = last;//将last的previous指向last（last永远指向的是最后一个结点）【此时还没有插入新的结点newNode，所以last指向的是当前链表的最后一个结点】
        last.next = newDoubleNode;    //将last.next(当前链表最后一个结点的next域)指向新的结点newNode
    }
    last = newDoubleNode;                //由于插入了一个新的结点，又因为是尾部插入，所以将last指向newNode
}

中间位置插入:

在这里插入图片描述

/**
 * 某个结点的后部插入
 * @param key
 * @param data
 */
public void insertAfter(int key, int data) {
    DoubleNode newDoubleNode = new DoubleNode(data);
    DoubleNode current = first;
    while ((current != null) && (current.data != key)) {
        current = current.next;
    }
    //若当前结点current为空
    if (current == null) {                    //current为null有两种情况 一种是链表为空，一种是找不到key值
        if (isEmpty()) {                    //1、链表为空
            first = newDoubleNode;                //则插入第一个结点（其实可以调用其它的Insert方法）
            last = newDoubleNode;                    //first和last均指向该结点（第一个结点）
        } else {
            last.next = newDoubleNode;        //2、找不到key值
            newDoubleNode.prev = last;    //则在链表尾部插入一个新的结点
            last = newDoubleNode;
        }
    } else {
        if (current == last) {                    //第三种情况，找到了key值，分两种情况
            newDoubleNode.next = null;            //1、key值与最后结点的data相等
            last = newDoubleNode;                    //由于newNode将是最后一个结点，则将last指向newNode
        } else {
            newDoubleNode.next = current.next;        //2、两结点中间插入                                                                                                                            四
            current.next.prev = newDoubleNode;    //将current当前结点的下一个结点赋给newNode.next
        }                                        //将current下一个结点即current.next的previous域指向current
        current.next = newDoubleNode;                    //将当前结点的next域指向newNode
        newDoubleNode.prev = current;                //将新结点的previous域指向current（current在newNode前面一个位置）

    }

}

3.3 删除元素

首尾删除:

/**
* 从头部删除结点
 * @return
 */
public DoubleNode deleteFirst() {
    DoubleNode temp = first;
    if (first.next == null) {            //若链表只有一个结点，删除后链表为空，将last指向null
        last = null;
    } else {
        first.next.prev = null;        //若链表有两个（包括两个）以上的结点 ，因为是头部插入，则first.next将变成第一个结点，其previous将变成null
    }
    first = first.next;                //将first.next赋给first
    return temp;                    //返回删除的结点
}

/**
 * 从尾部删除结点
 * @return
 */
public DoubleNode deleteLast() {
    DoubleNode temp = last;
    if (first.next == null) {        //如果链表只有一个结点，则删除以后为空表,last指向null
        first = null;
    } else {
        last.prev.next = null;    //将上一个结点的next域指向null
    }
    last = last.prev;            //上一个结点称为最后一个结点，last指向它
    return temp;                    //返回删除的结点
}

删除中间元素:

在这里插入图片描述

 /**
 * 按值删除
  * @param key
  * @return
  */
 public DoubleNode deleteKey(int key) {
     DoubleNode current = first;
     while (current != null && current.data != key) {        //遍历链表寻找该值所在的结点
         current = current.next;
     }
     if (current == null) {                        //若当前结点指向null则返回null，
         return null;                        //两种情况当前结点指向null，一是该链表为空链表，而是找不到该值
     } else {
         if (current == first) {                //如果current是第一个结点
             first = current.next;            //则将first指向它，将该结点的previous指向null,其余不变
             current.next.prev = null;
         } else if (current == last) {            //如果current是最后一个结点
             last = current.prev;        //将last指向当前结点的上一个结点（我们将当前结点除名了以后它便不再是最后一个了）
             current.prev.next = null;    //相应的要删除结点的上一个结点的next域应指向null
         } else {
             current.prev.next = current.next;        //当前结点的上一个结点的next域应指向当前的下一个结点
             current.next.prev = current.prev;    //当前结点的下一个结点的previous域应指向当前结点的上一个结点
         }
     }
     return current;        //返回
 }
Mamba_Stan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
算法通关村第一关-链表青铜挑战笔记
10-28
源代码
【Java数据结构与算法】双向链表
12-21
在计算机科学中，数据结构是组织、存储和处理数据的方式，而算法是解决问题或执行特定任务的步骤。...熟练掌握双向链表及其操作对于理解和优化算法至关重要，因为它能够提高数据处理的效率，降低复杂度。
编程导航算法通关村第1关 | 链表中环的问题
qq_53342601的博客
07-23 106
给定一个链表，判断链表中是否有环，这就是。进一步，假如有环，那环的位置在哪里？这就是题。
算法通关村第一关 | 链表中环的问题
分享快乐的博客
07-19 157
结论：相遇的时候快指针已经转l（n-1）圈，同样是上面的场景找入口位置，再写一次（按快慢指针找到相遇位置（假设图中的Z），然后将两指针分别放在链表头（X）和相遇位置（Z），并改为相同速度前进，则两个指针在开始位置相遇（Y）.）n = 1,2,3...问题1： 判断环的大小，首先判断环的存在，快慢指针相遇，就证明有环，假设相遇点Z，让fast和slow，让 fast固定在该位置，slow遍历，当fast = slow 时，slow走过的距离就是环的长度。举例：操场跑圈，跑的快的同学会追上跑得慢的同学。
编程导航算法通关村第一关|黄金挑战-链表中环的问题
weixin_64658019的博客
10-18 530
【代码】编程导航算法通关村第一关|黄金挑战-链表中环的问题。
编程导航算法通关村（一） | 链表环问题
IU_LIZHIEN的博客
07-21 194
给定一个链表，判断链表中是否有环。假如有环，那环的位置在哪里？示例1：输入：head = [3,2,0,-4], pos = 1输出：true解释：链表中有一个环，其尾部连接到第二个节点。
C#数据结构与算法揭秘四 双向链表
12-31
双向链表结点的定义与单链表的结点的定义很相似， ，只是双向链表多了一个字段 prev。其实，双向链表更像是一根链条一样，你连我，我连你，不清楚，请看图。 双向链表结点类的实现如下所示 //一个链条的类 public ...
Python二叉搜索树与双向链表转换算法示例
01-21
本文实例讲述了Python二叉搜索树与双向链表转换算法。分享给大家供大家参考，具体如下： 题目描述 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的...
算法-KMP字符串匹配
xx_xb的博客
07-23 178
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
【LeetCode】141.环形链表、142. 环形链表 II（算法 + 图解）
最新发布
明志の博客
07-25 865
环形链表
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 660
AtCoder Beginner Contest 363 ABCDE
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 760
二叉搜索树向左或向右指明方向，不用遍历整个树。
数据结构与算法--【数组2】力扣练习 || 双指针 / 移除元素 / 数组排序
qq_44578108的博客
07-25 516
简单删除元素 / 指定某元素位置，其余元素位置相对不变双指针指向数组头。快指针扫描数组并判断，慢指针收集变化后的数组元素。不创建新数组，只覆盖原数组。对数组元素排序一个指针指开头，一个指针指结尾。判断两指针指向值大小，循环结束条件first <= last；for循环，while循环均可，本人更习惯while循环。使用malloc为新数组分配空间，注意，创建了新数组。
河南萌新联赛2024第（二）场：南阳理工学院
a13997460860的博客
07-25 662
这场比赛里面出到了很多的题，都是需要很多的时间去写，主要考察到了代码的实现能力，与codeforces里面的题有些差距。codeforces打多了还是有点不习惯的。题挺好的，尤其是H题感觉很考代码实现能力与STL的使用熟练度。多写写这样的题还是对我们很有好处的。只不过前三题都太水了，没有一点难度。
python基础知识点（蓝桥杯python科目个人复习计划73）
m0_73523976的博客
07-25 135
（1）100万元正好被分成若干份，不能有剩余。1 <= |s| <= 5 * 10^5,保证s只包含大写字母、小写字母和数字。地产大佬先生临终的遗愿是拿出100万元给x社区的居民抽奖。1 <= |s| <= 10^6，保证s只包含大小写字母。给定一个长度为n的字符串s，请你判断字符串s是否回文。（3）在满足上述条件的情况下，分成的份数越多越好。给定一个字符串s，请你求出s的最长回文字符串。若字符串s为回文串，则输出Y，否则输出N。输出共1行，包含一个整数，表示答案。输入仅一行包含一个字符串s。
算法力扣刷题记录 五十六【501.二叉搜索树中的众数】
danaaaa的博客
07-21 916
求众数方法
代码随想录算法训练营day8 | 344.反转字符串、541.反转字符串 II、卡码网：54.替换数字
m0_55763458的博客
07-25 441
代码随想录算法训练营day8 | 344.反转字符串、541.反转字符串 II、卡码网：54.替换数字
SMO算法，platt论文的原始算法及优化算法
Rhett_Butler0922的博客
07-25 146
platt论文的原始SMO算法、一种优化算法、及libsvm算法。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值