算法学习（门徒计划）1-1 链表学习笔记_门徒平台首页开户-优快云博客

本文是关于链表的学习笔记，介绍了链表的概念、特性，如查询时间复杂度为n，插入和删除时间复杂度为1。讲解了链表在操作系统动态内存分配和LRU缓存淘汰算法中的应用。探讨了链表反转、旋转链表、链表成环等经典问题的解决方案，并涉及快乐数的链表思维判断方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言

3月4日，开课吧门徒计划算法课第一讲学习笔记。
本课讲链表。
课题为：
1-1 链表以及经典问题

链表

链表概念简述

通常链表指单向链表，单向链表每一个最小单元包含2个参数，一个是存储的内容，另一个是指向下一个节点的内容。
也就是说，链表中的任何一个节点都能获取到其下一个节点（除非没有下一个节点）或者这个储存的内容。

java 方式链表节点举例：

 public class ListNode {
   int val;
   ListNode next = null;
 }

每个对象存储了一个内容和下一个对象。

链表特性

查询动作时间复杂度 n

由于链表是通过指针域的方式实现排布，因此当需要查询一个节点时，需要遍历该节点前所有节点，所以时间复杂度为o（n）。

插入和删除时间复杂度 1

当需要插入或者删除某个节点时，只需要对这个节点前后的指向关系进行修改，因此时间复杂度为o（1）。

链表场景应用场景

场景一：操作系统的动态内存分配

假设原始内存区域为10GB，现在使用malloc函数（一个动态分配内存的函数，这部分内存需要手动释放）分配了2GB内存，那么剩下的8GB内存就需要操作系统去进行维护。

而有一种操作系统维护内存的方式（openVPN中有一种基于链表的内存管理方案）就是通过将不同的剩余内存碎片穿成链表进行维护。

场景二：LRU缓存淘汰算法

LRU（Least Recently Used）（意思为近期最少使用）
举例：
设备间存在速度差异，可以通过将使用频率高的数据存放在高速设备上，来实现更高效率的调用。
其实现的方法为当容量到达上限时，删除(或转移)最少使用的，为新的数据留出空间。

经典问题

链表的反转

要求在不进行修改存储值的情况下，通过修改链表各个单元对于下一个单元的指向关系来翻转链表的元素顺序。

通用案例

要求将某个链表从第n个元素开始翻转k个长度

如图，n为3，k为3

思考解决方案：

首先除翻转段外，其余部分应保持不变，因此链表被分为3份，

翻转区块之前的一份：
顺序不变，最终末尾指向翻转区域的首位；
翻转区块的一份：改变顺序，最终末尾指向翻转区块之后的首位；
翻转区块之后的一份： 顺序不变，不需要改动(不需要关注)

代码：

    public static ListNode reverseLinkList(ListNode head, int n,int k) {
        if(head == null || head.next == null || k < 2) return head;
        
        //临时节点
        ListNode temp,end;
        //计算长度
        int len = 0;
        temp = head;
        while (temp != null) {
            len ++ ;
            temp = temp.next;
            end = temp; //记录结尾
        }
        
        //无法翻转
        if(n+k>len) return head;
        
        //创建空头，用于承接需要翻转的部分
        ListNode dummy = new ListNode(0);
        temp = head;
        for(int i=0;i<n-1;i++){
            temp = temp.next;
        }
        dummy.next = temp;
        
        //创建调换时需要使用的中介变量
        ListNode cur = temp;
        for (int i = 1; i < k; i ++ ) {
             //将下一个需要调换的提取出来
            temp = cur.next;
            //跨过下一个指向下下个
            cur.next = temp.next;
            
            //让提取的这个成为调换中新链表的头
            temp.next = dummy.next;
            dummy.next = temp;
        }
        return head;
    }

旋转链表

要求将链表首位相接，向后走k位后将环拆开。
（代码略）

方案

取得尾部，指向头，以尾部所在指针向后走k步，然后取得next作为头的指针，将尾部所在指针指向null。return 头。

链表成环

对于单向链表，由于根据每一个节点只能获得下一个节点的位置，所以不能确保某一个节点不会指向其之前的节点。一旦发生这种情况，就会导致试图查询链表末尾的动作无法结束，并且无法查询到环以后的节点（假设原本有一段，那么因为没有被指向，这段将被丢弃）。

(cyclizationLinkList.png)]

换句说法，一个节点如果可有2种方式到达，则链表成环，且该节点为入环点，但是链表每个元素只能知道指向什么，怎么知道这个点呢？

（本题困难主要来源于思路，代码十分简单，略过）

初级问题：判断某个链表是否成环

方案1 用额外空间哈希表

提供一个足够大的空间，依次载入链表各个节点（不需要载入值，只载入下一个节点的连接关系），当一个点，被第二次有载入的需求时，这个链表就是有环的。

方案2 快慢指针

从头开始，提供2个指针，一个指针一次只向下找一位，另一个则试图找两位，持续这个动作直到快指针到达结尾或者两个指针在某一个节点相遇。因为在相同时间t内，快走过的路程一定是慢的2倍，在假定有环的情况下，如果一直走下去，二者一定都会进环，而在环内由于快的速度是慢的两倍，因此快一定能追上慢的指针。同理如果没有环，快指针一定会到达链表的结尾。

方案衍生：查找入环点。

额外空间对于入环点很好找，但是指针该怎么找呢？。

需要利用两个指针的速度差。

第一步：记录两个指针第一次相遇的步数。
此时快指针领先慢指针的距离等于慢指针行走的距离（因为快指针速度是慢的两倍）。

第二步：重新准备一个指针速度和慢指针相同，令这个指针从头开始走，同时慢指针继续走。
此时假设，三号指针（假定为C），一直走到快慢指针相遇的点，那么原来的慢指针将走到何处？
也会到达快慢指针的第一次相遇点（因为这个距离是快指针领先慢指针的距离）。
但是由于指针C和慢指针速度相同，且在环内会经过的路程，因此虽然可以确定二者在快慢指针的相遇点是重合的，但是有可能二者更早就相遇了（在环内同向同路程）。

第三步：新指针和慢指针持续走，直到第一次相遇。

新指针和慢指针相遇的点就是入环点。
而整个动作为新指针和慢指针在入环点相遇，然后共同以相同的速度，并行到达快慢指针的第一次相遇点。