代码随想录算法-day4

已于 2024-11-11 13:22:16 修改
阅读量609 收藏 17
点赞数 24
文章标签： 算法 python
于 2024-11-09 09:47:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_46147058/article/details/143470081
版权
  • LeetCode 24. 两两交换链表中的节点
  • LeetCode 19.删除链表的倒数第N个节点
  • LeetCode 面试题 02.07. 链表相交
  • LeetCode 142.环形链表II

前言

疯狂补作业中……

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

题目链接/文章讲解/视频讲解

24-1 原始想法

这题比较简单，设一个临时变量中转就行了

24-2 随想录提醒

略

24-3 最终题解

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head: return head
        else:
            pre, current = head, head.next
            while current:
                temp = pre.val
                pre.val = current.val
                current.val = temp
                try:
                    pre = pre.next.next
                    current = current.next.next                
                except:
                    return head
            return head

24-4 Debug过程

调试后主要增设了try-except片段，当然也可以按照随想录的官方写法，将while的判断条件改为while current.next and current.next.next (注意这里是引用卡哥版本用了虚拟头指针的写法，而我的代码没有用虚拟头指针，所以应该是while current and current.next，比较绕写一遍就行了。)

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

题目链接/文章讲解/视频讲解

19-1 原始想法

实现说明，链表非常短或者为空的特殊情况先不考虑，在细节处理中体现。正常情况下，由于链表是一个不可凭索引直接访问的数据结构，无法预知链表的长度，所以暴力的解法就是先遍历一遍链表，记录其长度，但显然（参照了题目说明），如果可以采用快慢指针的方法，就避免了多次重复遍历的冗余。
快慢指针的间隔由n确定，这样当fast指针指向尾节点时，就可以删除slow指向的节点。这里有个坑要注意，前面提到过，我们永远都是对current.next操作才行，所以slow与fast之间准确的间隔应该是n+1而非n

19-2 随想录提醒

不说了，都在代码里！

19-3 最终题解

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        if not head: return head
        else:
            dummyHead = ListNode(next=head)
            slow, fast = dummyHead, dummyHead.next
            while n: # 这里简单考虑，默认n是合法的
                fast = fast.next
                n -= 1
            while fast: # 跳出循环时，fast指向尾节点的next,即None，链表遍历完毕
                fast = fast.next
                slow = slow.next
            slow.next = slow.next.next
            return dummyHead.next

19-4 Debug过程

要注意的一点就是，使用虚拟头节点后，输出一般都是return dummyHead.next，而不是return head

LeetCode 面试题 02.07. 链表相交

题目链接/文章讲解

0207-1 原始想法

不太理解题目中skipA和skipB的作用，题解模板里面没有这两个参数，不知道要怎么用……

0207-2 随想录提醒

随想录的这句话很关键：交点不是数值相等，而是指针相等；题目中也明确要求，要输出的应当是“两个单链表相交的起始节点”，这里是节点而不是节点的val。
要注意一个重要信息就是：单链表相交后，从相交节点开始后面的应当是完全一样的，所以从起始节点开始后面的长度也是一样的，这就是破题点。
一图胜千言：在这里插入图片描述

0207-3 最终题解

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        curA, curB = headA, headB
        while curA!=curB:
            curA = curA.next if curA else headB
            curB = curB.next if curB else headA
        return curA

0207-4 Debug过程

代码是不是简洁的有点过分了？这是因为利用了len(A)+len(B)=len(B)+len(A)，所以一次循环就可以实现末尾对齐！

LeetCode 142.环形链表II

题目链接/文章讲解/视频讲解

142-1 原始想法

如果沿用指针的思路，会发现指针进入环状结构以后会不断循环链表元素，无法结束，这或许是一个突破点。

142-2 随想录提醒

主要解法是快慢指针，而且这里首先要指出，快慢指针的速度分别为单位2和单位1（二者速度相差值为1，与慢指针速度相等，这点对于解题很重要），于是将该问题分解成两个部分：

  1. 判断链表是否有环。第一个部分可以利用142-1中提到的环路无限循环的特性，通过快慢指针相遇与否判断
  2. 确定环开始的节点。第二部分则需要进行一些数学证明和运算，关键是要把握 x = ( n − 1 ) ( y + z ) + z x = (n-1)(y+z) + z x=(n−1)(y+z)+z这一等式的含义（详见随想录）

142-3 最终题解

原理部分比较复杂，建议跳转上面链接查看，这里主要关注代码的实现。

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        try: # 若没有环，fast会先指向None，从而转到except输出None
            fast, slow = head.next.next, head.next
            index = head # 用于找到环的入口
            while slow != fast:
                fast = fast.next.next
                slow = slow.next
            while index != fast:
                index, fast = index.next, fast.next
            return index
        except: return None

142-4 Debug过程

原理清楚了，一次就过了噢！

上卿赋
关注
代码随想录-035期-算法训练营【博客笔记汇总表】
upward
04-10 823
代码随想录-035期-算法训练营【博客笔记汇总表】
代码随想录算法训练营day1
weixin_44520607的博客
11-16 1548
代码随想录 算法训练营第一天
代码随想录算法PDF.rar
08-06
代码随想录算法PDF.rar
算法随想录——数组篇
青青子衿
11-07 841
算法学习笔记，数组篇
算法随想
Geek+Maker=？
07-06 1067
深邃的编程思想可以延伸到各个方面,包括日常生活... 作者：彭小朋 导读：有人天生喜欢“遍历”，踏遍千山万水，遍享万种风情。扮演各种角色，希望人生丰富多彩；有人一生“贪婪”，眼界不宽，及时行乐；有人注定适用“穷搜”，辛辛苦苦勤勤恳恳一辈子，付出很多，收获有限；有人善用“时空权衡”，用最少的时间办最多的事情，的确精明；有人会“分治”，再多的难题也能迎刃而解；有人常“回溯”，错的太
算法题随想录（随时更新）
胜神明半子
08-25 600
1.有些数据点后面可能没有换行符，导致使用循环while(scanf("%c", &c))这样的读入会TLE。 可以这样：while(scanf("%c", &c) != EOF)，利用scanf读到文件末尾时返回EOF的特性。 2.cin>>n;真的不能读入含有空格的字符串，getline（cin,n)才行，回车也是一个字符麻烦用getchar吞掉。 3 ...
算法随想录算法训练营Day09
whaledown的博客
04-13 172
Day09，KMP算法，字符串完结了，加油加油！
代码随想录刷题打卡day02
04-18
4. 数组操作与指针移动：在双指针法中，通常需要对数组进行操作，并根据条件移动指针。在示例代码中，有两个指针 `left` 和 `right` 分别从数组两端开始遍历，根据条件比较和移动指针，并将结果存放在新数组 `result...
代码随想录算法训练营第四十四天|Day44 动态规划
a6666999d的博客
11-12 1010
1143.最长公共子序列。
代码随想录-DAY②-数组——leetcode 977 | 209
roronoa
07-04 321
使用两个指针分别指向位置 0 和 n−1，每次比较两个指针对应的数，选择较大的那个逆序放入答案并移动指针。这种方法无需处理某一指针移动至边界的情况。时间复杂度：O(n)空间复杂度：O(1)
算法学习笔记（代码随想录，JS语言）
qq_59079803的博客
06-09 2240
前提：下标从0开始，储存的内存的空间地址是连续的，因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。 适用：数组是有序排列的 特点：1.左右闭合 2.左闭右开（右开的情况下就不要将每次让right==middle时，不让middle进行计算和比较）........................................................................
算法速成之代码随想录
qq_63728673的博客
11-25 6724
有些同学想要学习算法题，但是时间很紧，自己的基础也不是很好，想要在空余时间完全掌握所有算法题确实有点不切实际了，终于去学习了遇到难题又半途而废，于是我总结了一下刷代码随想录题目的方法先看b站视频：BV1fA4y1o715，有规划的看，每一类题可以看一到两道，看完去做题，感觉基本了解了就可以直接看代码随录博客的题目跟着做，因为看视频较为费时间，博客中的注释非常详细；写题时候，，实在无从下手就他的，看完应该都能自己写了，如果连思路都看不懂，那么就求助gpt或者去看他的视频；每周写题也要有一定的规划，
算法随想录算法训练营 ---第六天
m0_62573048的博客
10-18 79
今天是哈希表的最后一天，虽然最后一天但是对哈希表的使用还不是很熟练后面这两道题也不是很会，需要不断复习，进行巩固。加油吧！
【算法】代码随想录刷题记录 | 动态规划篇（一）
Conner7的博客
04-01 4214
刷代码随想录LeetCode题的一些记录和感想（动态规划篇（一））
【算法】代码随想录刷题记录 | 3. 哈希表篇
Conner7的博客
01-10 4448
刷代码随想录LeetCode题的一些记录和感想（哈希表篇）
【代码随想录】贪心算法专栏（java版本含注释）
码农研究僧的博客
05-05 1560
所谓的贪心算法，就是局部最优到全局最优 关于该算法的学习路线如下： 代码随想录的贪心算法路线
【算法】代码随想录训练营Day13打卡，二叉树
YuZzz1的博客
01-16 312
二叉树前中后序遍历
贪心算法——代码随想录
weixin_45354197的博客
04-18 521
学习目的 1.理解这种经典算法的基础理论和应用场景 2.利用算法解决实际问题 （一）贪心算法解决的问题 数学归纳法； 反证法。 （二）回溯算法的基础 一般解题的步骤 ①将问题分为若干个子问题 ②求出适合的贪心策略 ③求解出每一个子问题的最优解 ④将局部最优堆叠为全局最优解 （三）例题 1.分发饼干 分发饼干 （1）题目分析 为了满足更多的小孩，就不要造成饼干的浪费。 子问题：从后向前用饼干依次满足小孩的胃口。 因为满足大胃口小孩的饼干一定能满足小胃口小孩的饼干。 （2）代码实现 a.遍历小孩的胃口数组 饼干
送卡神算法力作《代码随想录》！
极客重生
12-26 1444
刚开始学习数据结构与算法，或者在力扣（LeetCode）上刷题的读者都有这种困惑——从何学起，先学什么，再学什么。很多人刷题的效率低，主要体现在以下三点：难以寻找适合自己的题目。找到了不合...
代码随想录算法训练营Day04
最新发布
03-26
### 关于代码随想录 Day04 的学习资料与解析 #### 一、Day04 主要内容概述 代码随想录 Day04 的主要内容围绕 **二叉树的遍历** 展开，包括前序、中序和后序三种遍历方式。这些遍历可以通过递归实现，也可以通过栈的方式进行迭代实现[^1]。 #### 二、二叉树的遍历方法详解 ##### 1. 前序遍历（Pre-order Traversal） 前序遍历遵循访问顺序：根节点 -> 左子树 -> 右子树。以下是基于递归的实现： ```python def preorderTraversal(root): result = [] def traversal(node): if not node: return result.append(node.val) # 访问根节点 traversal(node.left) # 遍历左子树 traversal(node.right) # 遍历右子树 traversal(root) return result ``` 对于迭代版本，则可以利用显式的栈来模拟递归过程： ```python def preorderTraversal_iterative(root): stack, result = [], [] current = root while stack or current: while current: result.append(current.val) # 访问当前节点 stack.append(current) # 将当前节点压入栈 current = current.left # 转向左子树 current = stack.pop() # 弹出栈顶元素 current = current.right # 转向右子树 return result ``` ##### 2. 中序遍历（In-order Traversal） 中序遍历遵循访问顺序：左子树 -> 根节点 -> 右子树。递归实现如下： ```python def inorderTraversal(root): result = [] def traversal(node): if not node: return traversal(node.left) # 遍历左子树 result.append(node.val) # 访问根节点 traversal(node.right) # 遍历右子树 traversal(root) return result ``` 迭代版本同样依赖栈结构： ```python def inorderTraversal_iterative(root): stack, result = [], [] current = root while stack or current: while current: stack.append(current) # 当前节点压入栈 current = current.left # 转向左子树 current = stack.pop() # 弹出栈顶元素 result.append(current.val) # 访问当前节点 current = current.right # 转向右子树 return result ``` ##### 3. 后序遍历（Post-order Traversal） 后序遍历遵循访问顺序：左子树 -> 右子树 -> 根节点。递归实现较为直观： ```python def postorderTraversal(root): result = [] def traversal(node): if not node: return traversal(node.left) # 遍历左子树 traversal(node.right) # 遍历右子树 result.append(node.val) # 访问根节点 traversal(root) return result ``` 而迭代版本则稍复杂一些，通常采用双栈法或标记法完成： ```python def postorderTraversal_iterative(root): if not root: return [] stack, result = [root], [] while stack: current = stack.pop() result.insert(0, current.val) # 插入到结果列表头部 if current.left: stack.append(current.left) # 先压左子树 if current.right: stack.append(current.right) # 再压右子树 return result ``` #### 三、补充知识点 除了上述基本的二叉树遍历外，Day04 还可能涉及其他相关内容，例如卡特兰数的应用场景以及组合问题的基础模板[^2][^4]。如果遇到具体题目，可以根据实际需求调用相应算法工具。 --- ####
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值