力扣:判断根结点是否等于子结点之和

这篇博客讨论了一个简单的二叉树问题,即如何判断一个由3个节点组成的二叉树中,根节点的值是否等于左右子节点值之和。通过示例和代码实现,提供了检查方法。

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

2236. 判断根结点是否等于子结点之和

给你一个 二叉树 的根结点 root,该二叉树由恰好 3 个结点组成:根结点、左子结点和右子结点。

如果根结点值等于两个子结点值之和,返回 true ,否则返回 false

示例 1:

img

输入:root = [10,4,6]
输出:true
解释:根结点、左子结点和右子结点的值分别是 10 、4 和 6 。
由于 10 等于 4 + 6 ,因此返回 true 。

示例 2:

img

输入:root = [5,3,1]
输出:false
解释:根结点、左子结点和右子结点的值分别是 5 、3 和 1 。
由于 5 不等于 3 + 1 ,因此返回 false 。

提示:

  • 树只包含根结点、左子结点和右子结点
  • -100 <= Node.val <= 100
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean checkTree(TreeNode root) {
        return root.val==root.left.val+root.right.val;
    }
}
<think>嗯,用户想了解如何删除链表的倒数第N个节点。这道题我之前做过,但得仔细想想步骤。首先,链表的问题通常需要双指针技巧,尤其是处理倒数节点的时候。比如,要删除倒数第N个节点,可能需要找到它的前驱节点,然后调整指针。 那具体怎么做呢?比如,假设有一个链表是1->2->3->4->5,要删除倒数第2个节点,也就是4,结果应该是1->2->3->5。这时候,常规思路是先遍历一次得到长度,再计算正数的位置,然后第二次遍历到那个位置删除。但这样需要两次遍历,有没有更高效的方法? 对了,可以用快慢双指针。让快指针先走N步,然后快慢一起移动,直到快指针到末尾。这时慢指针就指向要删除节点的前一个节点。比如例子中,快指针先走2步到2,然后快慢一起移动,当快指针到5的时候,慢指针在3的位置,这样就可以把3的next指向5,从而跳过4。 但需要注意边界情况,比如如果删除的是头节点怎么办?比如链表是1->2,N=2,那么删除的是头节点。这时候需要处理头节点的情况,或者在前面加一个哑节点(dummy node),这样所有节点都有前驱,方便统一处理。比如哑节点指向头节点,然后快慢指针从哑节点开始,这样当快指针走完,慢指针就指向要删除节点的前驱,即使删除的是头节点,也能正确操作。 步骤大概是:创建哑节点,快指针先走N+1步(因为要找到前驱),然后快慢同时移动,直到快指针为null,此时慢指针的下一个节点就是需要删除的,执行删除操作。最后返回哑节点的next作为新头节点。 需要验证这个思路的正确性。比如例子中的情况,快指针先走N+1步的话,可能快指针会走到null,这时候慢指针的next就是需要删除的节点。比如当链表长度等于N时,删除头节点的情况,这时候快指针移动N+1步会超出,此时慢指针的下一个节点就是头节点,删除即可。 另外,要确保输入的N是有效的,比如不大于链表长度。题目可能假设N是有效的,所以不需要处理这种情况。 然后,代码实现的话,需要注意指针的移动次数。比如,初始化哑节点,然后快慢指针都指向哑节点。快指针先移动N+1次,然后同步移动直到快指针为null。这样慢指针的位置就是前驱节点。 比如,链表长度是L,快指针走了N+1步,然后剩下的步数是L - (N+1),这时候慢指针走了L - (N+1)步,所以慢指针的位置是第 (L - N -1) 个节点,而倒数第N个节点是第L - N +1 个节点,所以前驱节点是第L - N个节点,也就是L - N的位置。这时候,用L - (N+1)步走到前驱的话,可能要看具体的例子。 比如链表长度是5,N=2,那么L - N =3,也就是第3个节点是前驱。而用上述方法,快指针走3步(N+1=3),然后快慢一起移动直到快指针到末尾。初始时快指针在dummy,走3步到节点3的位置。然后快指针还有2步走到末尾(节点5之后是null)。这时候慢指针从dummy开始,移动2步到节点3的位置,此时它的next是4,也就是要删除的节点。这时候删除即可。 这似乎是对的。那代码的结构大概是: 创建dummy节点,dummy.next = head; 快慢指针都指向dummy; 快指针先移动N+1次; 然后同时移动直到快指针为null; 此时慢指针的next是要删除的节点,执行slow.next = slow.next.next; 返回dummy.next; 这样的话,可以处理各种情况,包括删除头节点的情况。 总结起来,步骤是: 1. 添加哑节点,简化头节点删除的情况。 2. 快指针先移动N+1步。 3. 快慢指针同时移动直到快指针到末尾。 4. 删除慢指针的下一个节点。 5. 返回哑节点的下一个节点作为新头。 这样时间复杂度是O(L),L是链表长度,空间复杂度是O(1)。</think>### 删除链表的倒数第 N 个结点 | 力扣题解 #### 问题分析 题目要求删除链表的**倒数第 N 个结点**,并返回头结点。核心难点在于如何高效定位倒数第 N 个结点,并处理边界情况(如删除头结点)。 --- #### 解决思路 **核心技巧:双指针法(快慢指针)** 1. **哑结点(Dummy Node)**:在链表头部前添加一个虚拟结点,用于统一处理删除头结点的情况。 2. **快指针先移动 N+1 步**:确保当快指针遍历到链表末尾时,慢指针刚好指向倒数第 N 个结点的**前驱结点**。 3. **同步移动双指针**:直到快指针指向 `null`,此时慢指针的 `next` 结点即为要删除的结点。 4. **删除目标结点**:修改指针跳过目标结点。 --- #### 分步解析 1. **初始化哑结点和双指针** ```python dummy = ListNode(0) # 哑结点 dummy.next = head fast = slow = dummy # 双指针均从哑结点出发 ``` 2. **快指针先移动 N+1 步** ```python for _ in range(n + 1): fast = fast.next ``` *示例*:链表 `1->2->3->4->5`,`n=2`,快指针移动后指向 `3`。 3. **同步移动双指针** ```python while fast: fast = fast.next slow = slow.next ``` *关键点*:当快指针到达末尾时,慢指针指向倒数第 N+1 个结点(即目标结点的前驱)。 4. **删除目标结点** ```python slow.next = slow.next.next # 跳过倒数第 N 个结点 ``` 5. **返回新链表头结点** ```python return dummy.next ``` --- #### 完整代码(Python) ```python class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next def removeNthFromEnd(head: ListNode, n: int) -> ListNode: dummy = ListNode(0) dummy.next = head fast = slow = dummy # 快指针先走 n+1 步 for _ in range(n + 1): fast = fast.next # 同步移动直到快指针到末尾 while fast: fast = fast.next slow = slow.next # 删除目标结点 slow.next = slow.next.next return dummy.next ``` --- #### 复杂度分析 - **时间复杂度**:$$O(L)$$,其中 $$L$$ 为链表长度。仅需一次遍历。 - **空间复杂度**:$$O(1)$$,仅使用常数级额外空间。 --- #### 边界案例验证 1. **删除头结点** 输入:链表 `[1,2]`,`n=2` 输出:`[2]` 处理过程:哑结点帮助统一操作,慢指针最终指向哑结点,直接跳过原头结点。 2. **删除中间结点** 输入:链表 `[1->2->3->4->5]`,`n=2` 输出:`[1->2->3->5]` 处理过程:慢指针指向 `3`,删除 `4`。 3. **删除尾结点** 输入:链表 `[1->2]`,`n=1` 输出:`[1]` 处理过程:慢指针指向 `1`,跳过 `2`。 --- #### 总结 通过**双指针法**和**哑结点技巧**,可以高效且简洁地解决链表倒数结点删除问题。关键在于通过快指针的提前移动,保证慢指针精确定位到目标前驱结点。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

XdpCs

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值