力扣刷题day04|24两两交换链表中的节点、19删除链表的倒数第N个节点、160链表相交、142环形链表II

Skyc26

已于 2022-12-11 08:46:15 修改

阅读量206

点赞数

分类专栏： leetcode 文章标签：链表 leetcode 数据结构

于 2022-09-25 17:42:45 首次发布

本文链接：https://blog.csdn.net/dtc1261/article/details/127040629

版权

leetcode 专栏收录该内容

54 篇文章 0 订阅

订阅专栏

文章目录

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

力扣题目链接

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

示例1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例2：

输入：head = []
输出：[]

示例3：

输入：head = [1]
输出：[1]

思路

迭代虚拟头节点法

假设交换的节点为[a,b]，虚拟头节点先指向b完成第一次交换，b再指向a完成第二次交换，a指向c完成第三次连接

难点

每一次交换两个节点时，cur必须指向这两个节点的后一个
在判断什么时候停时，要先判断cur.next是否为空然后再判断cur.next.next是否为空，否则很有可能导致空指针异常
先要保存第一个交换节点对的前一个节点和第二个交换节点对的后一个节点

public ListNode swapPairs(ListNode head) {
    // 先定义虚拟头节点指向head
    ListNode dummyHead = new ListNode(-1);
    dummyHead.next = head;
    // 再定义cur指针遍历链表
    ListNode cur = dummyHead;

    // 考虑有奇数个节点的情况，要判断两个next都不为空才能往下循环
    while (cur.next != null && cur.next.next != null) {
        // 提前保存要交换的前一个节点
        ListNode temp1 = cur.next;
        // 提前保存要交换节点组的下一个节点
        ListNode temp3 = cur.next.next.next;
        // 现在虚拟头节点应该指向后一个节点
        cur.next = cur.next.next;
        // 后一个节点再指向前一个
        cur.next.next = temp1;
        // 交换后的第二个节点现在要指向之前的第三个节点
        cur.next.next.next = temp3;

        // 移动cur节点到下一个要交换节点组的前面
        cur = cur.next.next;

    }
    return dummyHead.next;
}

时间复杂度：O(n)

递归法

递归可以参考一下大佬写的一个博客，附有详细的图文介绍：三道题套路解决递归问题 | lyl’s blog

难点，swap()到底返回的是什么

直接上三部曲模版：

找终止条件： 什么情况下递归终止？没得交换的时候，递归就终止了呗。因此当链表只剩一个节点或者没有节点的时候，自然递归就终止了。
找返回值： 我们希望向上一级递归返回什么信息？由于我们的目的是两两交换链表中相邻的节点，因此自然希望交换给上一级递归的是已经完成交换处理，即已经处理好的链表。
本级递归应该做什么： 结合第二步，由于只考虑本级递归，所以这个链表在我们眼里其实也就三个节点依次连接：head、head.next、已处理完的链表部分。而本级递归的任务也就是交换这3个节点中的前两个节点。

难点

swap()括号里接受的参数是当前两个节点对[head,next]的下一个节点，该参数作为下级的head

return返回的是当前已经处理完的节点对（链表的部分），原来是[head,next]，返回处理完后[next,head]中的next。

图解

从最后两个节点来看

单从其中一级[1,2]来看递归

public ListNode swapPairs(ListNode head) {
    // 终止条件：链表只剩一个节点或者没节点了，没得交换了。返回的是已经处理好的链表
    if (head == null || head.next == null) return head;
    // 定义一个next指针指向当前head节点的下一个节点
    ListNode next = head.next;
    // 进行递归
    // 递归交给下一级的参数是当前两个节点对[head,next]的下一个节点
    ListNode newNode = swapPairs(next.next);
    // 这里进行交换，先将next往前指
    next.next = head;
    // 再把前一个节点head指向后面要继续递归的节点（链表）
    head.next = newNode;

    return next;
}

19. 删除链表的倒数第N个节点

力扣题目链接

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

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

输入：head = [1,2], n = 1
输出：[1]

思路

参照数组移除节点的方法，可以设置双指针一个快一个慢

双指针法

快指针：快指针向往前走比慢指针快n+1，最后指向null
慢指针：最后指向要删除的节点的前一个节点

本来快指针只用和慢指针相隔n个节点，最终快指针指向null时，慢指针正好指向的就是倒数第n个节点，但在链表中进行删除操作需要指针指向要删除节点的前一个，所以快指针需要比慢指针先走n+1步

难点

因为题目给的n可能大于链表长度，因此快指针遍历链表时除了n要大于0外，还要看快指针是否移动到了null处，即还要判断fast != null

public ListNode removeNthFromEnd(ListNode head, int n) {
    // 先定义虚拟头节点指向head
    ListNode dummyHead = new ListNode(-1);
    dummyHead.next = head;

    // 定义快慢指针
    ListNode slow = dummyHead;
    ListNode fast = dummyHead;

    // 快指针要比慢指针先走n+1
    n++;
    while (n-- > 0 && fast != null) {
        fast = fast.next;

    }
    // 再让快慢指针同时往后移动
    while (fast != null) {
        fast = fast.next;
        slow = slow.next;

    }
    // 删除倒数第n个节点
    slow.next = slow.next.next;

    // 返回头节点
    return dummyHead.next;
}

106. 链表相交

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

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

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

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

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'

解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'

解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null

解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。这两个链表不相交，因此返回 null 。

思路

两个相同长度的链表若相交，则同时从头结点开始遍历，会在相交节点相遇，因此先要计算两个链表的长度，长链表需要缩短和短链表一样长

难点

计算完两个链表长度后，要使两个指针重新回到head
比较长度后统一设定哪个链表长，curA为长链表指针，lenA为长链表长度

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    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指向谁的头，让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;
}

142. 环形链表II

力扣题目链接

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

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

说明：不允许修改链表。

示例1：

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

示例2：

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

示例3：

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

思路

快慢指针

快指针走两步，慢指针走一步，如果有环，二者一定在环中相遇。相遇后再设置两个指针，一个指向头节点一个指向相遇节点，二者同时继续向前走，最终相遇点一定在环的入口处。

难点

while判断中要判断fast和fast.next是否为null，不用判断fast.next.next是否为空

因为fast移动两步，移动到null也没关系，因为在fast=fast.next.next后进入下一次循环中就会先判断fast是否为空。

判断fast.next是否为空有必要，因为要对fast.next再做.next的操作

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) {
            // 相遇后index1指向快慢指针相遇的位置
            ListNode index1 = fast;
            // index2指向头节点
            ListNode index2 = head;

            // 两个指针从头结点和相遇结点，各走一步，直到相遇
            while (index1 != index2) {
                index1 = index1.next;
                index2 = index2.next;
            }
            // 相遇点即为环入口
            return index1;
        }
    }
    return null;
}