leetcode 117

news2025/1/12 13:31:02

leetcode 117

代码

#include <iostream>

// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};

class Solution {
public:
    void handle(Node* &last, Node* &p, Node* &nextStart) {

        if (last) {
            last->next = p;
        } 
        if (!nextStart) {
            nextStart = p;
        }
        last = p;
        
    }

    Node* connect(Node* root) {
        if (!root) {
            return nullptr;
        }
        Node *start = root;
        while (start) {
            Node *last = nullptr, *nextStart = nullptr;
            for (Node *p = start; p != nullptr; p = p->next) {
                if (p->left) {
                    handle(last, p->left, nextStart);
                }
                if (p->right) {
                    handle(last, p->right, nextStart);
                }
            }
            start = nextStart;
        }
        return root;
    }
};

int main(){
    Node* n1 = new Node(1);
    Node* n2 = new Node(2);
    Node* n3 = new Node(3);
    Node* n4 = new Node(4);
    Node* n5 = new Node(5);
    Node* n6 = new Node(6);
    
    n1->left = n2;
    n1->right = n3;

    n2->left = n4;
    n2->right = n5;

    n3->right = n6;

    Solution s;
    
    Node* res = new Node();
    res = s.connect(n1);

    return 0;
}

这个解法的优点是对空间占用比直接层序遍历更好。27行和29行会更新指针本身，而不仅是指针的指向对象的值。

gdb调试

在这里插入图片描述
在这里插入图片描述

c++ 知识点

Node *&、Node&和Node *之间的区别在于它们的类型和用法。

  1. Node *&是一个引用的引用，表示一个指向指针的引用。这种引用的使用场景通常是为了能够修改指针本身的值，而不仅仅是修改指针所指向的对象的值。通过Node *&可以修改指针的指向，从而改变原始指针的值。

  2. Node&是一个引用，表示对Node类型对象的引用。通过Node&可以直接访问和修改引用所指向的对象的成员变量。

  3. Node *是一个指针，用于指向Node类型的对象。通过指针可以间接访问和修改指针所指向的对象的成员变量。

以下是一个示例，展示了Node *&、Node&和Node *之间的区别：

#include <iostream>

class Node {
public:
    int data;
    Node* next;

    Node(int value) {
        data = value;
        next = nullptr;
    }
};

void modifyPointer(Node *&ptr) {
    ptr = new Node(20);
}

void modifyReference(Node &ref) {
    ref.data = 30;
}

void modifyObject(Node *ptr) {
    ptr->data = 40;
}

int main() {
    Node* node1 = new Node(10);

    // 使用 Node *& 修改指针本身的值
    modifyPointer(node1);
    std::cout << "Modified pointer: " << node1->data << std::endl;

    // 使用 Node & 修改引用所指向的对象的值
    modifyReference(*node1);
    std::cout << "Modified reference: " << node1->data << std::endl;

    // 使用 Node * 修改指针所指向的对象的值
    modifyObject(node1);
    std::cout << "Modified object: " << node1->data << std::endl;

    delete node1;

    return 0;
}

在上面的示例中，我们定义了一个Node类，它有两个成员变量data和next。我们还定义了三个函数modifyPointer、modifyReference和modifyObject来修改指针和对象的值。

在main函数中，我们首先创建了一个node1节点，并将其传递给modifyPointer函数。modifyPointer函数接受一个Node *&类型的参数，它修改了指针本身的值，将其指向一个新创建的Node对象。然后，我们打印出修改后的指针所指向的对象的值。

接下来，我们将node1节点传递给modifyReference函数。modifyReference函数接受一个Node &类型的参数，它修改了引用所指向的对象的值，将其data成员变量设置为30。然后，我们再次打印出修改后的对象的值。

最后，我们将node1节点传递给modifyObject函数。modifyObject函数接受一个Node *类型的参数，它修改了指针所指向的对象的值，将其data成员变量设置为40。然后，我们再次打印出修改后的对象的值。

输出结果应该是：

Modified pointer: 20
Modified reference: 30
Modified object: 40

这样，我们可以看到Node *&、Node&和Node *之间的区别。Node *&允许我们修改指针本身的值，Node &允许我们直接修改引用所指向的对象的值，而Node *只能通过指针间接访问和修改指针所指向的对象的值。

(gdb) b 22
Breakpoint 1 at 0x40089a: file leetcode117.cpp, line 22.
(gdb) b 30
Breakpoint 2 at 0x4008e0: file leetcode117.cpp, line 30.
(gdb) r
Starting program: /home/csapp/leetcode/leetcode117
warning: Error disabling address space randomization: Operation not permitted

Breakpoint 1, Solution::handle (this=0x7fff7657bd37, last=@0x7fff7657bd08: 0x0, p=@0x15d1018: 0x15d1040,
nextStart=@0x7fff7657bd00: 0x0) at leetcode117.cpp:23
23 if (last) {
Missing separate debuginfos, use: debuginfo-install glibc-2.17-326.el7_9.x86_64 libgcc-4.8.5-44.el7.x86_64 libstdc+±4.8.5-44.el7.x86_64
(gdb) p *last
Cannot access memory at address 0x0
(gdb) c
Continuing.

Breakpoint 2, Solution::handle (this=0x7fff7657bd37, last=@0x7fff7657bd08: 0x15d1040, p=@0x15d1018: 0x15d1040,
nextStart=@0x7fff7657bd00: 0x15d1040) at leetcode117.cpp:31
31 }
(gdb) p *last
$1 = {val = 2, left = 0x15d10a0, right = 0x15d10d0, next = 0x0}
(gdb) p *p
$2 = {val = 2, left = 0x15d10a0, right = 0x15d10d0, next = 0x0}
(gdb) p *nextStart
$3 = {val = 2, left = 0x15d10a0, right = 0x15d10d0, next = 0x0}
(gdb) c
Continuing.

Breakpoint 1, Solution::handle (this=0x7fff7657bd37, last=@0x7fff7657bd08: 0x15d1040, p=@0x15d1020: 0x15d1070,
nextStart=@0x7fff7657bd00: 0x15d1040) at leetcode117.cpp:23
23 if (last) {
(gdb) p *last
$4 = {val = 2, left = 0x15d10a0, right = 0x15d10d0, next = 0x0}
(gdb) p *p
$5 = {val = 3, left = 0x0, right = 0x15d1100, next = 0x0}
(gdb) p *nextStart
$6 = {val = 2, left = 0x15d10a0, right = 0x15d10d0, next = 0x0}
(gdb) c
Continuing.

Breakpoint 2, Solution::handle (this=0x7fff7657bd37, last=@0x7fff7657bd08: 0x15d1070, p=@0x15d1020: 0x15d1070,
nextStart=@0x7fff7657bd00: 0x15d1040) at leetcode117.cpp:31
31 }
(gdb) p *last
$7 = {val = 3, left = 0x0, right = 0x15d1100, next = 0x0}
(gdb) p *p
$8 = {val = 3, left = 0x0, right = 0x15d1100, next = 0x0}
(gdb) p *nextStart
$9 = {val = 2, left = 0x15d10a0, right = 0x15d10d0, next = 0x15d1070}
(gdb) c
Continuing.

Breakpoint 1, Solution::handle (this=0x7fff7657bd37, last=@0x7fff7657bd08: 0x0, p=@0x15d1048: 0x15d10a0,
nextStart=@0x7fff7657bd00: 0x0) at leetcode117.cpp:23
23 if (last) {
(gdb) p *last
Cannot access memory at address 0x0
(gdb) p *p
$10 = {val = 4, left = 0x0, right = 0x0, next = 0x0}
(gdb) p *nextStart
Cannot access memory at address 0x0
(gdb) c
Continuing.

Breakpoint 2, Solution::handle (this=0x7fff7657bd37, last=@0x7fff7657bd08: 0x15d10a0, p=@0x15d1048: 0x15d10a0,
nextStart=@0x7fff7657bd00: 0x15d10a0) at leetcode117.cpp:31
31 }
(gdb) p *last
$11 = {val = 4, left = 0x0, right = 0x0, next = 0x0}
(gdb) p *p
$12 = {val = 4, left = 0x0, right = 0x0, next = 0x0}
(gdb) p *nextStart
$13 = {val = 4, left = 0x0, right = 0x0, next = 0x0}
(gdb) c
Continuing.

Breakpoint 1, Solution::handle (this=0x7fff7657bd37, last=@0x7fff7657bd08: 0x15d10a0, p=@0x15d1050: 0x15d10d0,
nextStart=@0x7fff7657bd00: 0x15d10a0) at leetcode117.cpp:23
23 if (last) {
(gdb) p *last
$14 = {val = 4, left = 0x0, right = 0x0, next = 0x0}
(gdb) p *p
$15 = {val = 5, left = 0x0, right = 0x0, next = 0x0}
(gdb) p *nextStart
$16 = {val = 4, left = 0x0, right = 0x0, next = 0x0}
(gdb) c
Continuing.

Breakpoint 2, Solution::handle (this=0x7fff7657bd37, last=@0x7fff7657bd08: 0x15d10d0, p=@0x15d1050: 0x15d10d0,
nextStart=@0x7fff7657bd00: 0x15d10a0) at leetcode117.cpp:31
31 }
(gdb) p *last
$17 = {val = 5, left = 0x0, right = 0x0, next = 0x0}
(gdb) p *p
$18 = {val = 5, left = 0x0, right = 0x0, next = 0x0}
(gdb) p *nextStart
$19 = {val = 4, left = 0x0, right = 0x0, next = 0x15d10d0}
(gdb) c
Continuing.

Breakpoint 1, Solution::handle (this=0x7fff7657bd37, last=@0x7fff7657bd08: 0x15d10d0, p=@0x15d1080: 0x15d1100,
nextStart=@0x7fff7657bd00: 0x15d10a0) at leetcode117.cpp:23
23 if (last) {
(gdb) p *last
$20 = {val = 5, left = 0x0, right = 0x0, next = 0x0}
(gdb) p *p
$21 = {val = 6, left = 0x0, right = 0x0, next = 0x0}
(gdb) p *nextStart
$22 = {val = 4, left = 0x0, right = 0x0, next = 0x15d10d0}
(gdb) c
Continuing.

Breakpoint 2, Solution::handle (this=0x7fff7657bd37, last=@0x7fff7657bd08: 0x15d1100, p=@0x15d1080: 0x15d1100,
nextStart=@0x7fff7657bd00: 0x15d10a0) at leetcode117.cpp:31
31 }
(gdb) p *last
$23 = {val = 6, left = 0x0, right = 0x0, next = 0x0}
(gdb) p *p
$24 = {val = 6, left = 0x0, right = 0x0, next = 0x0}
(gdb) p *nextStart
$25 = {val = 4, left = 0x0, right = 0x0, next = 0x15d10d0}
(gdb) c

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1168528.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【Linux进阶之路】进程（下）—— 进程控制

【Linux进阶之路】进程（下）—— 进程控制

文章目录 前言一.再识fork1.为啥有两个返回值&#xff1f;2.为啥给父进程返回子进程的pid&#xff0c;给子进程返回0&#xff1f;3.为啥返回的同一个变量&#xff0c;地址相同&#xff0c;但值不同&#xff1f; 二.进程退出1.退出情况1.1正常退出&#xff0c;退出码正常1.2正常…
阅读更多...
【漏洞库】XXL-JOB 默认accessToken权限绕过导致RCE

【漏洞库】XXL-JOB 默认accessToken权限绕过导致RCE

文章目录 漏洞描述漏洞编号漏洞评级影响版本漏洞复现- EXP 编写 漏洞挖掘修复建议 漏洞描述 XXL-JOB 是一款开源的分布式任务调度平台&#xff0c;用于实现大规模任务的调度和执行。 XXL-JOB 默认配置下&#xff0c;用于调度通讯的 accessToken 不是随机生成的&#xff0c;而…
阅读更多...
基于SpringBoot+Vue的旅游系统、前后端分离

基于SpringBoot+Vue的旅游系统、前后端分离

博主24h在线&#xff0c;想要源码文档部署视频直接私聊&#xff0c;低价有偿&#xff01; 基于SpringBootVue的旅游系统、前后端分离 开发语言&#xff1a;Java 数据库&#xff1a;MySQL 技术&#xff1a;SpringBoot、Vue、Mybaits Plus、ELementUI 工具&#xff1a;IDEA/Ec…
阅读更多...
微信怎么设置自动通过好友申请？

微信怎么设置自动通过好友申请？

当开展引流获客活动时&#xff0c;员工会在一段时间内频繁收到好友添加的申请&#xff0c;手动同意好友请求费时费力还容易出现漏加的情况&#xff0c;那么微信能自动通过好友请求吗&#xff1f; 如何设置快速自动通过好友申请呢&#xff1f; 当微信号在系统登录&#xff0c;…
阅读更多...
【计算机网络】网络层：数据平面

【计算机网络】网络层：数据平面

一.网络层概述 每台路由器的数据平面的主要功能时从其输入链路向其输出链路转发数据报&#xff0c;控制平面的主要功能是协调这些本地的每路由转发动作&#xff0c;使得数据报沿着源和目的地主机之间的路由器路径最终进行端到端传送。 网络层不运行运输层和应用层协议。 转发是…
阅读更多...
【QT】绘图设备

【QT】绘图设备

绘图设备是指继承QPainterDevice的子类。Qt提供了很多这样的类&#xff0c;例如QPixmap、QBitmap、QImage和 QPicture。其中&#xff0c; QPixmap专门为图像在屏幕上的显示做了优化QBitmap是QPixmap的一个子类&#xff0c;它的色深限定为1&#xff0c;可以使用 QPixmap的isQBi…
阅读更多...
安徽省黄山景区免9天门票为哪般？

安徽省黄山景区免9天门票为哪般？

今日浑浑噩噩地睡了大半天&#xff0c;强撑起身子写网文......可是&#xff0c;题材不好选&#xff0c;本“人民体验官”只得推广人民日报官方微博文化产品《这两个月“黄山每周三免门票”》。 图&#xff1a;来源“人民体验官”推广平台 因年事渐高&#xff0c;又有未愈的呼吸…
阅读更多...
麒麟KYLINIOS软件仓库搭建02-软件仓库添加新的软件包

麒麟KYLINIOS软件仓库搭建02-软件仓库添加新的软件包

原文链接&#xff1a;麒麟KYLINIOS软件仓库搭建02-软件仓库添加新的软件包 hello&#xff0c;大家好啊&#xff0c;今天给大家带来麒麟桌面操作系统软件仓库搭建的文章02-软件仓库添加新的软件包&#xff0c;本篇文章主要给大家介绍了如何在麒麟桌面操作系统2203-x86版本上&…
阅读更多...
改进YOLOv5 | 头部解耦 | 将YOLOX解耦头添加到YOLOv5 | 涨点杀器

改进YOLOv5 | 头部解耦 | 将YOLOX解耦头添加到YOLOv5 | 涨点杀器

改进YOLOv5 | 头部解耦 | 将YOLOX解耦头添加到YOLOv5 论文地址：https://arxiv.org/abs/2107.08430 文章目录 改进YOLOv5 | 头部解耦 | 将YOLOX解耦头添加到YOLOv51. 解耦头原理2. 解耦头对收敛速度的影响3. 解耦头对精度的影响4. 代码改进方式第一步第二步第三步第四步第五步本…
阅读更多...
0-1背包 完全背包 + 至多/恰好/至少 + 空间优化 + 常见变形题

0-1背包 完全背包 + 至多/恰好/至少 + 空间优化 + 常见变形题

# capacity:背包容量 # w[i]: 第 i 个物品的体积 # v[i]: 第 i 个物品的价值 # 返回:所选物品体积和不超过 capacity 的前提下&#xff0c;所能得到的最大价值和 def zero_one_knapsack(capacity:int,w:List[int],v:List[int]) -> int:n len(w)cache #记忆化搜索 def dfs(i…
阅读更多...
吴恩达《机器学习》4-6-＞4-7:正规方程

吴恩达《机器学习》4-6-＞4-7:正规方程

一、正规方程基本思想 正规方程是一种通过数学推导来求解线性回归参数的方法&#xff0c;它通过最小化代价函数来找到最优参数。 代价函数 J(θ) 用于度量模型预测值与实际值之间的误差&#xff0c;通常采用均方误差。 二、步骤 准备数据集&#xff0c;包括特征矩阵 X 和目标…
阅读更多...
使用C# 编写VISA相关的代码控制 keysight 34461A万用表

使用C# 编写VISA相关的代码控制 keysight 34461A万用表

使用C# 编写VISA相关的代码控制 keysight 34461A万用表 1. 获取设备2. 开始编程2.1 创建项目2.2 编程2.3 全部工程代码 软件控制仪器仪表的教程在网上相对比较少&#xff0c;都是一段一段的代码&#xff0c;没有从头开始带初学者来进行操作的一个完整流程&#xff0c;整个方案难…
阅读更多...
Unity中Shader的GI相关数据的准备

Unity中Shader的GI相关数据的准备

文章目录 前言一、把 Unity 中用到的 GI 的函数移植到我们自定义的 cginc 文件中二、开始使用和 GI 相关的方法1、了解 UnityGI 结构体的内容,并且准备 UnityGI 的数据2、了解 SurfaceOutput 结构体&#xff0c;并且准备数据3、了解并准备 UnityGIInput 结构体&#xff0c;并且…
阅读更多...
Flutter笔记：发布一个模块 scale_design - （移动端）设计师尺寸适配工具

Flutter笔记：发布一个模块 scale_design - （移动端）设计师尺寸适配工具

Flutter笔记 发布一个模块scale_design设计师尺寸适配工具与常用组件库 作者&#xff1a;李俊才 &#xff08;jcLee95&#xff09;&#xff1a;https://blog.csdn.net/qq_28550263 邮箱 &#xff1a;291148484163.com 本文地址&#xff1a;https://blog.csdn.net/qq_28550263/a…
阅读更多...
词向量模型Word2Vec

词向量模型Word2Vec

Word2Vec CBOW连续词袋模型例子CBOW模型的embeddings层CBOW模型的线性层 总结 skip-gram跳字模型例子Skip-Gram模型的结构 CBOW和skip-gram的目标都是迭代出词向量字典&#xff08;嵌入矩阵&#xff09;——embeddings CBOW连续词袋模型 根据上下文词汇预测目标词汇 例子 使…
阅读更多...
【FastCAE源码阅读3】几何模型显示：从OCC对象到VTK对象

【FastCAE源码阅读3】几何模型显示：从OCC对象到VTK对象

从几何到显示还是比较麻烦的&#xff0c;需要将几何对象转换成渲染对象&#xff0c;涉及几何建模、面的三角化、图形渲染等学科&#xff0c;阅读本文需了解一些基本的OCC、VTK编程 一、几何体显示基本流程 FastCAE几何内核使用的是OCC&#xff0c;显示渲染用的VTK&#xff0c;…
阅读更多...
Leetcode—111.二叉树的最小深度【简单】

Leetcode—111.二叉树的最小深度【简单】

2023每日刷题&#xff08;十八&#xff09; Leetcode—111.二叉树的最小深度 DFS实现代码 /*** Definition for a binary tree node.* struct TreeNode {* int val;* struct TreeNode *left;* struct TreeNode *right;* };*/ int minDepth(struct TreeNode* root…
阅读更多...
NCL颜色索引表---全平台可用

NCL颜色索引表---全平台可用

NCL颜色索引表—全平台可用
阅读更多...
三维向量旋转

三维向量旋转

三维向量旋转 问题描述问题分析 v ⃗ ∣ ∣ \vec{v}_{||} v ∣∣​的旋转 v ⃗ ⊥ \vec{v}_{\bot} v ⊥​的旋转 v ⃗ \vec{v} v 的旋转结论致谢 问题描述 如图1所示&#xff0c;设一个向量 v ⃗ \vec{v} v 绕另一个向量 u ⃗ [ x , y , z ] T \vec{u}[x,y,z]^{T} u [x,y,z]T…
阅读更多...
【电路笔记】-相位差和相移

【电路笔记】-相位差和相移

相位差和相移 文章目录 相位差和相移1、概述2、相位差2.1 同频信号2.2 电流与电压信号2.3 相似频率的信号 3、干扰4、总结 当我们听歌曲时&#xff0c;我们将正弦声音波形感知为音乐。 它们的振幅告诉我们信号有多大&#xff0c;频率告诉我们声音是低音还是高音。 然而&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023