LeetCode：24.两两交换链表中的节点 && 19.删除链表的倒数第N个节点 && 02.07. 链表相交 && 141.环形链表

已于 2023-08-09 23:27:15 修改
阅读量90 收藏
点赞数
分类专栏： LeetCode 文章标签： 链表 leetcode java 算法
于 2023-04-09 22:16:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47957908/article/details/130043282
版权

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

题目

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

链接：两两交换链表中的节点

思路

注意：不要觉得是按照1234…这样的数字来安排的，不是这种（if(xxx.next.val % 2 == 0)）

原图：如下图，pre是虚拟头节点

在这里插入图片描述

cur.next = second; // 如下图

在这里插入图片描述

first.next = second.next;  // 如下图

在这里插入图片描述

second.next = first;  // 如下图

在这里插入图片描述

cur = first;  // 如下图

在这里插入图片描述

ListNode first = cur.next;
ListNode second = cur.next.next;  // 如下图

在这里插入图片描述

最终：如下图

在这里插入图片描述

迭代（创建虚拟头节点）

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)
class Solution {
    public ListNode swapPairs(ListNode head) {
        //创建虚拟头节点
        ListNode pre = new ListNode(0);
        pre.next = head;
        ListNode cur = pre;
        //循环，确保下一个和下下一个节点的存在
        while(cur.next != null && cur.next.next != null){
            //看图
            ListNode first = cur.next;
            ListNode second = cur.next.next;
            cur.next = second;
            first.next = second.next;
            second.next = first;
            cur = first;
        }
        return pre.next;
    }
}

递归

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)
class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null) return head;
        // 获取当前的下一个节点
        ListNode node = head.next;
        // 进行递归
        ListNode newNode = swapPairs(node.next);
        // 开始交换
        node.next = head;
        head.next = newNode;
        return node;
    }
}

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

题目

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
在这里插入图片描述
链接：删除链表的倒数第N个节点

计算长度

思路

计算链表长度，在通过总数 - 倒数删除的节点数 + 1，就可以定位到删除节点的前一个位置

  • 时间复杂度：O(count)，count是链表的长度
  • 空间复杂度：O(1)
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //创建虚拟头节点
        ListNode pre = new ListNode(0);
        pre.next = head;
        //计算有多少个节点
        int count = 0;
        while(head != null){
            count++;
            head = head.next;
        }

        ListNode temp = pre;
        //count - n + 1，可以直接将结点传到要删除的节点的上一个节点
        int i = 1;
        while(i < count - n + 1){
            temp = temp.next;
            i++;
        }
        /*for(int i = 1; i < count - n + 1; i++){
            temp = temp.next;
        }*/
        //删除节点
        temp.next = temp.next.next;
        ListNode ans = pre.next;
        return ans;
    }
}

双指针法1

思路

  • 时间复杂度：O(n)，n是链表的长度
  • 空间复杂度：O(1)

原图：如下图

在这里插入图片描述

// 如下图
for(int i = 1; i <= n; i++){ first = first.next; }// n=2

在这里插入图片描述

// 如下图
while(first != null){ second = second.next; first = first.next; }

在这里插入图片描述

// 如下图
second.next = second.next.next;

在这里插入图片描述

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //创建虚拟节点
        ListNode dur = new ListNode(0);
        dur.next = head;
        // ListNode dur = new ListNode(0, head);

        ListNode first = dur.next;
        ListNode second = dur;
        //倒数多少位，就将first向前几位
        for(int i = 1; i <= n; i++){
            first = first.next;
        }
        while(first != null){
            second = second.next;
            first = first.next;
        }
        second.next = second.next.next;
        ListNode ans = dur.next;
        return ans;
    }
}

双指针法2

思路

  • 时间复杂度：O(n)，n是链表的长度
  • 空间复杂度：O(1)
// 如下图
ListNode temp = new ListNode(0);
temp.next = head;
ListNode slow = temp;
ListNode fast = temp;

在这里插入图片描述

// 如下图
for(int i = 0; i < n; i++){ fast = fast.next; } // n = 2

在这里插入图片描述

// 如下图
while(fast.next != null){ slow = slow.next; fast = fast.next; }

在这里插入图片描述

// 如下图
slow.next = slow.next.next;

在这里插入图片描述

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode temp = new ListNode(0);
        temp.next = head;

        ListNode slow = temp;
        ListNode fast = temp;

        for(int i = 0; i < n; i++){
            fast = fast.next;
        }
        while(fast.next != null){
            slow = slow.next;
            fast = fast.next;
        }
        slow.next = slow.next.next;
        return temp.next;
    }
}

02.07. 链表相交

题目

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
图示两个链表在节点 c1 开始相交：
在这里插入图片描述
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
在这里插入图片描述
链接：链表相交

双指针法

  • 时间复杂度：O(ha + hb)，ha,hb是链表headA,headB的长度
  • 空间复杂度：O(1)
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode Ha = headA;
        ListNode Hb = headB;
        while (Ha != Hb) {
            Ha = Ha != null ? Ha.next : headB;
            Hb = Hb != null ? Hb.next : headA;
        }
        return Ha;
    }
}

141.环形链表

题目

给你一个链表的头节点 head ，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ，则返回 true 。 否则，返回 false 。
在这里插入图片描述
在这里插入图片描述
链接：环形链表

快慢指针法（双指针法1）

思路

  • 判断链表是否环
  • 如果有环，如何找到这个环的入口
  • 时间复杂度: O(n)，快慢指针相遇前，指针走的次数小于链表长度，快慢指针相遇后，两个index指针走的次数也小于链表长度，总体为走的次数小于 2n
  • 空间复杂度: O(1)
public class Solution {
    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){
                // slow和fast相遇的节点
                ListNode index1 = fast;
                // 头节点
                ListNode index2 = head;
                // 相遇节点和头节点在未遇见之前各走一步，直到相遇为止
                while(index1 != index2){
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null;
    }
}

快慢指针法（双指针法2）（不符合题意）

思路

设定两个节点，一前一后，在经过循环时，前面的结点要比后面的节点走得更快，如果是环形链表，则走得快的节点会遇到走得慢的节点，如果不是环形链表，则两个节点不会遇到

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)

原图：如下图

在这里插入图片描述

//进入循环后，如下图：
slow = slow.next; //走一步
fast = fast.next.next; //走两步

循环一次：如下图

在这里插入图片描述

循环两次：如下图

在这里插入图片描述

循环三次（遇到了）：如下图

在这里插入图片描述

public class Solution {
    public boolean hasCycle(ListNode head) {
        //判断链表是否为空
        if(head == null || head.next == null){
            return false;
        }
        //确定快慢指针
        ListNode slow = head;
        ListNode fast = head.next;
        while(slow != fast){
            if(fast == null || fast.next == null){
                return false;
            }
            //走一步
            slow = slow.next;
            //走两步
            fast = fast.next.next;
        }
        return true;
    }
}

补充：环形链表

在这里插入图片描述

有环的情况下，如何找到环的入口

前提条件

  • 从头结点到环形入口节点 的节点数为x。
  • 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。
  • 从相遇节点再到环形入口节点节点数为z。

思路

在这里插入图片描述

南瓜骨头
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
wuyuejinxia#Leetcode#24.两两交换链表中的节点1
07-25
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。示例:给定 1->2->3->4, 你应该返回 2->1->4->3.ListNode dummy =
链表-LeetCode24. 两两交换链表中的节点（Python）
12-21
在LeetCode的第24题中，我们被要求实现一个功能，即两两交换链表中的节点。这个题目属于链表操作的范畴，主要考察的是对链表结构的理解以及如何在链表上进行高效的节点操作。以下是详细的知识点解析： 1. **链表...
c++-c++编程基础之leetcode题解第24题两两交换链表中的节点.zip
04-07
第24题"两两交换链表中的节点"是其中一道典型的链表操作题目，旨在考察程序员对链表的理解以及对指针操作的熟练程度。 链表是一种线性数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。在...
c语言-c语言编程基础之leetcode题解第24题两两交换链表中的节点.zip
04-19
在C语言编程中，解决LeetCode上的问题24——两两交换链表中的节点，是一项基本的链表操作。这道题目要求我们给定一个单链表，其中的节点按顺序编号，对每两个相邻的节点进行交换，例如，1->2->3->4应该被转换为2->1-...
python-leetcode面试题解之两两交换链表中的节点.zip
03-06
这道“两两交换链表中的节点”是LeetCode上的一道经典面试题，旨在考察对链表操作的理解和熟练度。在Python中，链表通常通过定义一个节点类来实现，节点包含值和指向下一个节点的引用。 **题目描述：** 给定一个...
【Leetcode56】合并区间（数组 | 排序）
发现问题，并解决问题，批判性思维
09-07 193
# 二、思路 - 先将所有子列表按照`start_pos`进行排序，有利于保持顺序性，每次处理新子列表时，只用和结果列表`ans_lst`的最后一个子列表对比，如果有重合则合并，然后将合并的新子列表插入结果列表 - 排序可以使用`lambda`函数，`intervals.sort(key=lambda x: x[0])` - 时间复杂度O(n)，空间复杂度O(n) # 三、代码 ```python class Solution(object): def merge(self, intervals):
Leetcode 两数之和
985小菜鸡
09-08 866
哈希函数的设计：不良的哈希函数会导致较多的冲突，从而使查找和插入的时间复杂度退化为 O(n)。冲突的处理策略：冲突解决的方式（如链地址法或开放地址法）决定了在发生冲突时的额外开销。负载因子：过高的负载因子会增加冲突的几率，因此需要动态扩展哈希表来保持性能。一个均匀分布、计算高效的哈希函数能够显著减少冲突，保持哈希表在大多数情况下的 O(1) 性能。需要用到的头文件public://初始化一个hash table存储元素值和下标i++) {//求当前元素的补数。
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 499
C语言 | Leetcode C语言题解之第389题找不同
Leetcode 3281. Maximize Score of Numbers in Ranges
codename_cys的博客
09-08 469
Leetcode 3281. Maximize Score of Numbers in Ranges
LeetCode //C - 349. Intersection of Two Arrays
Made in Code
09-06 521
【代码】LeetCode //C - 349. Intersection of Two Arrays。
力扣第一题:两数之和
长安初雪的博客
09-06 367
我们可以一边遍历数组, 一边将每个值与 target 做运算. 比如 target 是7, 数组中的第一个元素是 3 , 那么就可以将 target - 3 的值存进到 Map 里去, key 是 target-3, value是当前数组的下标.以上 是我对这道算法的一些遐想和延伸, 可能不是最优解, 但是算法的优化嘛 本身就是一个思索的过程, 能在这个思索和迭代的过程中有所收获和乐趣就是在成长了, 欢迎大家一起来交流更多的解答…输入：nums = [2,7,11,15], target = 9。
【Hot100】LeetCode—118. 杨辉三角
weixin_44382896的博客
09-08 290
118. 杨辉三角。
【刷题】Leetcode1683. Invalid Tweets
apple_50678962的博客
09-09 285
【代码】【刷题】Leetcode1683. Invalid Tweets。
【leetcode详解】清除数字：栈思想解决字符串问题(思路详解)
H13420972436的博客
09-05 366
用栈思想的问题的特点： 对‘紧挨着’对象来判断条件和执行操作
力扣每日1题--2181.合并零之间的节点
weixin_75188368的博客
09-09 294
下面我会向大家介绍我的思考过程和解题思路。
Leetcode每日刷题之155.最小栈
2301_80689220的博客
09-05 390
1.题目解析 本题是实现一个栈并且要实现其中的插入、删除、返回栈顶元素、返回最小元素的函数，这里主要的难点就是返回最小元素的函数，如果我们直接遍历，那么时间复杂度就是O(N)，但是题目要求我们需要在常数时间也就是O(1)的时间复杂度内实现，那么接下来我们使用一种巧妙地方法来完成本题 2.算法原理 这里的主要难点只有在常数时间内找出栈顶最小元素，我们可以创建一个minst栈来存储数据，具体原理是在向st插入数据时判断此时插入的数据与minst中的栈顶元素哪个更小，如果minst的栈顶元素更小
【Hot100】LeetCode—763. 划分字母区间
weixin_44382896的博客
09-08 322
763. 划分字母区间。
LeetCode移除元素
最新发布
山雀的博客
09-09 185
LeetCode移除元素
Python | Leetcode Python题解之第389题找不同
Mopes__的博客
09-07 277
Python | Leetcode Python题解之第389题找不同
LeetCode链表算法系列：两两交换节点，删除指定位置，链表相交与环形链表
删除链表的倒数第N个节点、面试题02.07. 链表相交以及142. 环形链表 II。这些题目涵盖了链表操作的多个关键点： 1. 24. 两两交换链表中的节点：要求对链表进行两两节点交换，不改变节点值。通过设置虚拟头结点（如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值