【思路详解+详细注释】小白都能看懂的力扣算法详解——链表

爱写代码的July

已于 2024-08-27 23:50:59 修改

阅读量760

点赞数 24

分类专栏：算法练习文章标签：算法 leetcode 链表

于 2024-02-09 16:02:06 首次发布

本文链接：https://blog.csdn.net/Liu_y_xin/article/details/136086614

版权

算法练习专栏收录该内容

30 篇文章 0 订阅

订阅专栏

LC 24.两两交换链表中的节点

题目描述：给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

24. 两两交换链表中的节点 - 力扣（LeetCode）

本题的难点在于如何将链表划分为两两一组。可以想到，用指针cur来标记每组元素的位置，交换完成后指针向后走两步，即为下一组元素的首个节点。

接下来思考第二个问题，如何实现每组元素之间的两两互换？通过小白都能看懂的力扣算法详解——链表（一）-CSDN博客这部分习题的练习，不难想到，让指针指向该节点的前一个节点，通过cur.next 和cur.next.next就能找到我们需要交换的两个节点了。

第三个问题，如何实现交换。这一步的方法有很多，只要注意不要乱了就可以。如图，链表的原先链接方式为黑色箭头，我们要把它变成红色箭头(千万不要忘记交换完1和2后，还要让1指向3）。我们这里采取使用两个临时指针temp1和temp2来记录1和3的地址，通过临时指针进行交换的方式。

接下来考虑亿点点细节。首先是关于循环条件的判断。根据题目给出的示例不难发现，有链表节点是奇数和偶数个两种情况。当节点个数是奇数个时，退出循环的情况如下图所示，即cur.next.next；当节点个数是偶数个时，退出循环的情况为cur.next为空。所以循环判断条件可以写为cur.next != null && cur.next.next != null。这里需要注意&&前后的两个条件顺序不能交换！因为写在前面的条件会被优先判断，如果先判断cur.next.next的情况就有可能出现空指针异常。

接下来是对返回值的考虑。因为我们使用了虚拟头结点，所以不需要额外考虑头结点被换掉的情况，直接返回虚拟头节点的下一个节点就可以。至此，我们就可以愉快的写代码了。

 public ListNode swapPairs(ListNode head) {
        // 定义虚拟头节点和指针cur
        ListNode dh = new ListNode(0);
        dh.next = head;
        ListNode cur = new ListNode();
        cur = dh;
        // 定义两个临时指针
        ListNode temp1 = new ListNode();
        ListNode temp2 = new ListNode();
        // 进行交换
        while (cur.next != null && cur.next.next != null) {
            temp1 = cur.next;
            temp2 = cur.next.next.next;
            cur.next = cur.next.next;
            cur.next.next = temp;
            temp1.next = temp2;
            cur = cur.next.next;
        }
        return dh.next;
    }

交换过程如下：

LC 19.删除链表中的第n个结点

题目描述：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

这道题可以类比数组的类似题型，考虑使用双指针（快慢指针）来寻找倒数第n个元素，我们让快指针fast比慢指针slow多走n步，之后两个指针同时向前，当快指针遍历结束时，慢指针刚好走到倒数第n个元素的位置上。

思路考虑完毕，接下来考虑细节处理。首先是如何进行"删除"操作，根据以往经验，我们需要让慢指针走到待删除节点的前一个节点，因此我们只要在原有思路基础上，让fast快指针再多走一步，这样快指针遍历结束时，慢指针就走到了倒数第n+1个元素的位置上，也就是待删除节点的前一个节点。让slow.next = slow.next.next即可。

那么我们又要如何实现让快指针多走n+1步呢？我们这里采用了for循环的方式，让fast = fast.next操作进行n+1次，这里需要额外注意一下边界的判断，因为i是从0开始的，所以循环到i>n时结束，刚好是n+1次。

最后是对特殊情况（如链表只有头节点）的考虑，由于我们使用了虚拟头节点，因此如果头节点被删掉，那么返回虚拟头节点的下一个节点，也就是null满足。那么会不会出现n大于链表中节点个数或者链表为空的情况呢？至少在本题中无需考虑。

public ListNode removeNthFromEnd(ListNode head, int n) {
        // dummyNode 虚拟头节点
        ListNode dn = new ListNode();
        dn.next =head;
        // 快慢指针
        ListNode fast = dn;
        ListNode slow = dn;
        for(int i = 0; i <= n; i++) {
            fast = fast.next;
        }
        // 快慢指针同时走，直到块指针遍历结束
        while(fast != null) {
            fast = fast.next;
            slow = slow.next;
        }
        // 找到待删除节点前一个节点，删除
        slow.next = slow.next.next;
        return dn.next;
    }

LC 面试02.07 链表相交

题目描述：

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

面试题 02.07. 链表相交 - 力扣（LeetCode）

这道题卡尔哥的解法也很妙，不难观察出，两条链表在相交后，后半段的长度是一样的，那么只要我们求出两条链表长度的差值，然后让两条链表的尾巴对对齐，比较各节点的值即可。具体解法可以参考代码随想录代码随想录 (programmercarl.com)，有很多图示更加直观。

这里我想介绍另一种思路。观察以上两个示例或者我画的这个很抽象的图，可以发现，链表A的长度加上B的前半部分刚好等于链表B的长度加上A的前半部分，那么我们可以让两个指针p和q分别遍历链表A、B，当遍历结束后，就返回到链表B、A的头节点继续遍历另一条链表，当两个指针相遇时（说明它俩走了相同的步数），即为我们寻找的节点位置。

这个思路来源于b站【LeetCode 每日一题】160. 相交链表 | 手写图解版思路 + 代码讲解_哔哩哔哩_bilibili

 public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 解法1
        ListNode p = headA;
        ListNode q = headB;
        while(p != q) {
            p = (p != null ? p.next :headB);
            q  = (q != null ? q.next : headA);
        }
        return q;
        // 解法2
        //  ListNode curA = headA;
        // ListNode curB = headB;
        // int lenA = 0, lenB = 0;
        // while (curA != null) { // 求链表A的长度
        //     lenA++;
        //     curA = curA.next;
        // }
        // while (curB != null) { // 求链表B的长度
        //     lenB++;
        //     curB = curB.next;
        // }
        // curA = headA;
        // curB = headB;
        // // 让curA为最长链表的头，lenA为其长度
        // if (lenB > lenA) {
        //     //1. swap (lenA, lenB);
        //     int tmpLen = lenA;
        //     lenA = lenB;
        //     lenB = tmpLen;
        //     //2. swap (curA, curB);
        //     ListNode tmpNode = curA;
        //     curA = curB;
        //     curB = tmpNode;
        // }
        // // 求长度差
        // int gap = lenA - lenB;
        // // 让curA和curB在同一起点上（末尾位置对齐）
        // while (gap-- > 0) {
        //     curA = curA.next;
        // }
        // // 遍历curA 和 curB，遇到相同则直接返回
        // while (curA != null) {
        //     if (curA == curB) {
        //         return curA;
        //     }
        //     curA = curA.next;
        //     curB = curB.next;
        // }
        // return null;
    }

LC 142.环形链表II

题目描述：

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

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

不允许修改 链表。

142. 环形链表 II - 力扣（LeetCode）

本题是对141判断链表是否成环的进阶考法，更像是对数学能力的考察（关于数学证明可以参考力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台）。具体代码大家可以直接去看视频讲解，会更加直观（这里需要注意的是因为快指针一次走两步，所以需要满足fast != null && fast.next != null）把环形链表讲清楚！如何判断环形链表？如何找到环形链表的入口？ LeetCode：142.环形链表II_哔哩哔哩_bilibili

public ListNode detectCycle(ListNode head) {
        // 判断是否成环：快慢指针相遇
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {// 有环
                ListNode index1 = fast; // 相遇节点
                ListNode index2 = head; 
                // 两个指针，从头结点和相遇结点，各走一步，直到相遇，相遇点即为环入口
                while (index1 != index2) {
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null;
    }