[leetcode]大可日常打卡-树

基于YOLOv12的焊接质量检测系统:从原理到实现的完整指南 python"""标准卷积块: Conv + BatchNorm + SiLU""""""跨阶段部分连接块"""])"""YOLOv12颈部网络 - 特征金字塔"""p3, p4, p5 = features # 不同尺度的特征图# 上采样路径x = self.csp1(x) # 中尺度特征y = self.csp2(y) # 小尺度特征# 下采样路径z = self.csp3(z) # 中尺度特征。 阅读详情

687. 最长同值路径

    一开始非常没有思路。看了解析以后,找到了思路,把长度看作是从一个节点向左右子树延伸出去的两个箭头,从下往上遍历,后序遍历递归,如果箭头上的值等于节点的值,那么那么路径的长度就加1。然后刚开始写出的代码分别计算两边的,然后加起来。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int max=0;
    public int longestUnivaluePath(TreeNode root) {
        help(root);
        return max;
    }
    public int help(TreeNode root){
        if(root==null){
            return 0;
        }
        int left=help(root.left);
        int right=help(root.right);
        if(root!=null&&root.left!=null){
            if(root.val==root.left.val){
                left++;
            }else{
                left=0;
            }
        }
        if(root!=null&&root.right!=null){
            if(root.val==root.right.val){
                right++;
            }else{
                right=0;
            }
        }
        max=Math.max(max,left+right);
        return Math.max(left,right);
    }
}

226. 翻转二叉树

    递归。交换二叉树左右子树。然后对每一个左右子树进行递归。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root==null){
            return root;
        }
        TreeNode temp=root.left;
        root.left=root.right;
        root.right=temp;
        if(root.left!=null){
            invertTree(root.left);
        }
        if(root.right!=null){
            invertTree(root.right);
        }
        return root;
    }
}

112. 路径总和

    给定一个二叉树和一个目标和,判断该树中是否存在根节点到叶子节点的路径,这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。

思路:参考剑指offer34,二叉树中和为某一值的路径。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    ArrayList<ArrayList<Integer>> pathlist=new ArrayList<ArrayList<Integer>>();
    ArrayList<Integer> path=new ArrayList<Integer>(); //每次都新建一个,题目没有让找出具体路径,只要有就返回true,找不到就返回false
    public boolean hasPathSum(TreeNode root, int sum) {
        findPath(root,sum);
        if(path.size()==0){
            return false;
        }
        return true;
    }
    public ArrayList<Integer> findPath(TreeNode root,int sum){
        if(root==null){
            return path;
        }
        // if((sum>0&&root.val>sum)||(sum<0&&root.val<sum)){
        //     return path;
        // }
        path.add(root.val);
        sum-=root.val;
        if(sum==0&&root.left==null&&root.right==null){
            return path; //找到路径啦!
        }
        findPath(root.left,sum);
        findPath(root.right,sum);
        path.remove(path.size()-1);
        return path;
    }
        
}

113. 路径总和 II 

    给定一个二叉树和一个目标和,找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

说明: 叶子节点是指没有子节点的节点。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    List<List<Integer>> pathlist=new ArrayList();
    List<Integer> path=new ArrayList();
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        if(root==null){
            return pathlist;
        }
        path.add(root.val);
        sum-=sum=root.val;
        if(sum==0&&root.left==null&&root.right==null){
            pathlist.add(new ArrayList<>(path));
        }
        pathSum(root.left,sum);
        pathSum(root.right,sum);
        path.remove(path.size()-1);
        return pathlist;
    }
}

437. 路径总和 III

    给定一个二叉树,它的每个结点都存放着一个整数值。

找出路径和等于给定数值的路径总数。

路径不需要从根节点开始,也不需要在叶子节点结束,但是路径方向必须是向下的(只能从父节点到子节点)。

二叉树不超过1000个节点,且节点数值范围是 [-1000000,1000000] 的整数。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int total=0;
	ArrayList<ArrayList<Integer>> pathlist=new ArrayList<ArrayList<Integer>>();
    ArrayList<Integer> path=new ArrayList<Integer>();
	public int pathSum(TreeNode root, int sum) {
//		int total;
        if(root==null){
             return 0;
        }
        total=numOfPath(root,sum);
        //System.out.println(total+" "+root.val);
        pathSum(root.left,sum);
        //System.out.println(pathSum(root.left,sum)+"**");
        pathSum(root.right,sum);
        //System.out.println(pathSum(root.right,sum)+"**");
        return total;
    }
    
    public int numOfPath(TreeNode root,int sum){ //对于树root的每一个节点来说,返回以这个节点为根节点的和为sum的路径个数
        if(root==null){
            return pathlist.size();
        }
        path.add(root.val);
        sum-=root.val;
        if(sum==0){
        	
        	for(int i:path){
        	//	System.out.print(i+" ");
        	}
        	//System.out.println();
        	
        	pathlist.add(new ArrayList<>(path));
        
        }
        if(root.left!=null){
        	numOfPath(root.left,sum);
        }
        if(root.right!=null){
        	numOfPath(root.right,sum);
        }
        
        path.remove(path.size()-1);
        
        //System.out.println(pathlist.size());
        return pathlist.size();
    }
}

    未通过!

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int total=0;
	ArrayList<ArrayList<Integer>> pathlist=new ArrayList<ArrayList<Integer>>();
    ArrayList<Integer> path=new ArrayList<Integer>();
	public int pathSum(TreeNode root, int sum) {
//		int total;
        if(root==null){
             return total;
        }
        total=numOfPath(root,sum);
        //System.out.println(total+" "+root.val);
        pathSum(root.left,sum);
        //System.out.println(pathSum(root.left,sum)+"**");
        pathSum(root.right,sum);
        //System.out.println(pathSum(root.right,sum)+"**");
        return total;
    }
    
    public int numOfPath(TreeNode root,int sum){ //对于树root的每一个节点来说,返回以这个节点为根节点的和为sum的路径个数
        if(root==null){
            return pathlist.size();
        }
        path.add(root.val);
        sum-=root.val;
        if(sum==0){
        	//for(int i:path){
        	//	System.out.print(i+" ");
        	//}
        	//System.out.println();
        	pathlist.add(path);
            //return pathlist.size();
        }
        if(root.left!=null){
        	numOfPath(root.left,sum);
            path.remove(path.size()-1);
        }
        if(root.right!=null){
        	numOfPath(root.right,sum);
            path.remove(path.size()-1);
        }
        
        return pathlist.size();
    }
}

109. 有序链表转换二叉搜索树

思路:先根据给的例子寻找思路!根据题意得,要求出得是平衡二叉搜索树,平衡二叉搜索树的条件是左右子树的高度差的绝对值不超过1!!所以对于单链表,我们从中间开始,找到mid位置!!先把左边变成一棵平衡二叉树返回left节点,再把右边变成一棵平衡二叉树,返回right节点,再和根连起来。

    首先,寻找单链表的中间位置,设定两个指针,一个快指针,一个慢指针,当快指针的next为null时,慢指针指向中间位置。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        if(head==null){
            return null;
        }
        if(head.next==null){
            return new TreeNode(head.val);
        }
        if(head.next.next==null){
            TreeNode root=new TreeNode(head.val);
            root.right=new TreeNode(head.next.val);
            return root;
        }
        //先找到list的中间位置
        ListNode fast=head;
        ListNode slow=head;
        while(fast.next!=null&&fast.next.next!=null){
            fast=fast.next.next;
            slow=slow.next;
        }
        //现在slow就是中间位置,slow前面的是left,slow后面的是right
        ListNode tmp=head;
        while(tmp.next!=slow){
            tmp=tmp.next;
        }
        tmp.next=null;
        ListNode left=head;
        ListNode right=slow.next;
        slow.next=null;//把链表从中间截断!!!!现在链表变成了left和right
        
        TreeNode root=new TreeNode(slow.val);
        TreeNode leftNode=sortedListToBST(left);
        TreeNode rightNode=sortedListToBST(right);
        if(leftNode!=null){
            root.left=leftNode;
        }
        if(rightNode!=null){
            root.right=rightNode;
        }
        
        return root;
    }
}

111. 二叉树的最小深度

    给定一个二叉树,找出其最小深度。

    最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

思路:参考剑指offer55,二叉树的深度,那个是求最大的,这个是求最小的。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        int min=0;
        if(root==null){
            return 0;
        }
        int left=0;
        if(root.left!=null){
            left=minDepth(root.left);
        }
        int right=0;
        if(root.right!=null){
            right=minDepth(root.right);
        }
        min=Math.min(left+1,right+1);
        return min;
    }
}

    上面的程序通不过1,2,null,null,null这个样例,应该返回2,但是它返回1。因为要找的路径应该是从根节点到叶子节点,叶子节点应该是既没有左孩子也没有右孩子的节点。但是根节点很特别。其实就是如果左右孩子里面有一个是空的话,那么min就是非空的那边的值!!

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        int min=0;
        if(root==null){
            return 0;
        }
        if(root.left==null&&root.right==null){
            return 1;
        }
        if(root.left==null){
            return minDepth(root.right)+1;
        }
        if(root.right==null){
            return minDepth(root.left)+1;
        }
        
        min=Math.min(minDepth(root.left)+1,minDepth(root.right)+1);
        return min;
    }
}

嵌入式内存管理之“LittleFS文件系统”开发(附LittleFS项目源码) 本文介绍了如何在嵌入式系统中实现 LittleFS 文件系统,并结合 Flash 存储进行数据管理。通过详细的代码示例,展示了如何配置、挂载 LittleFS 文件系统,并进行文件操作,如读取、写入和更新数据。特别地,博客通过实际应用演示了如何实现启动计数功能,以及如何处理文件系统的格式化和挂载过程。该示例帮助读者掌握在资源受限的嵌入式环境中实现高效文件存储管理的关键技术。 阅读详情

相关推荐

维护测试监控LLM应用

LangFuse: 开源 + SaaS(免费/付费),LangSmith 平替,可集成 LangChain 也可直接对接 OpenAI API;LangSmith: LangChain 的官方平台,SaaS 服务(免费/付费),非开源,企业版支持私有部署;调试 Prompt 的 Playground测试/验证系统的相关指标数据集管理各种指标监控与统计:访问量、响应时长、Token 费等等。

SunnyRivers 1785

【小Y学算法】⚡️每日LeetCode打卡⚡️——26.相同的树

算法题打卡:相同的树。没有特别幸运,那么请先特别努力,别因为懒惰而失败,还矫情地将原因归于自己倒霉。所以说,树倒了,没有一片雪花是无辜的

努力前行,总会成为自己心中的那道光 9773

从零到一:基于Rocky Linux 9的Kubernetes高可用集群部署实战

本文提供了一份基于Rocky Linux 9操作系统,从零开始部署Kubernetes高可用集群的完整实战指南。详细讲解了包括系统初始化、容器运行时配置、使用kubeadm工具进行集群初始化、节点加入以及Calico网络插件安装在内的核心步骤,并针对国内网络环境提供了镜像加速等优化方案,旨在帮助读者构建一个稳定可靠的生产级K8s环境。

weixin_29197835的博客 143

【小Y学算法】⚡️每日LeetCode打卡⚡️——33.杨辉三角

算法题打卡:杨辉三角。没有特别幸运,那么请先特别努力,别因为懒惰而失败,还矫情地将原因归于自己倒霉。所以说,树倒了,没有一片雪花是无辜的

努力前行,总会成为自己心中的那道光 9573

风控IV、AUC、KS python计算代码

df_temp:数据集,Y:是否逾期标签,feas_list:需要计算IV的 变量。2、 按月和不同Y 下的 IV计算。

暮雨听轩的专栏 1618

盘点那些好用的SAP FIORI App(二) -上传凭证Upload Journal Entry

SAP FICO运维问题及解决方案分享

lijinbao171022的博客 1545

前端小白的力扣打卡日常-1779

前言 本人身为一个前端小白,一开始就没怎么接触过算法。想着做前端应该也不太需要去学算法,但是最近看到各种面试经历的文章以及身边一些人的面试经历,都说明了算法的重要性,从现在开始我也要慢慢来,先从打卡力扣每日一题开始! 题目内容 「1779. 找到最近的有相同 X 或 Y 坐标的点。」 给你两个整数 x 和 y ,表示你在一个笛卡尔坐标系下的 (x, y) 处。同时,在同一个坐标系下给你一个数组 points ,其中 points[i] = [ai, bi] 表示在 (ai, bi) 处有一个点。当一个点与你

weixin_51217727的博客 261

RK3568笔记二:部署手写数字识别模型

部署手写数字识别模型,使用手写数字识别(mnist)数据集训练了一个 LENET 的五层经典网络模型。Lenet是我们的深度学习入门的必学模型,是深度学习领域中的经典卷积神经网络(CNN)架构之一。过程分为:训练,导出ONNX,转化RKNN,测试。

1172

力扣日常打卡112.路径总和

题目描述: 给定一个二叉树和一个目标和,判断该树中是否存在根节点到叶子节点的路径,这条路径上所有节点值相加等于目标和。 示例: 思路及实现: 根据题目很容易想到dfs算法,若dfs有一条路径返回true,则整体返回true。 转化为代码即为: bool left,right; left = dfs(node->left,sum,temp); right = dfs(node->right,sum,temp); return left|right; 其中,sum为最终的求和参数,temp为到目

qq_27615887的博客 226

Claude Code Agents 进阶:多代理协作与任务委托

Agent 是一个独立运行的 Claude 实例,它有自己的上下文和任务焦点。│ 主 Claude ││ (协调者) ││ │ │▼ ▼ ▼│ 代码审查 │ │ 测试生成 │ │ 文档编写 ││ │ ││▼汇总结果,完成任务并行处理:多个 Agent 同时工作,提高效率任务隔离:每个 Agent 有独立的上下文专业分工:不同类型的 Agent 擅长不同任务灵活控制:可以指定运行模式、超时等参数。

gaoxiang_120的专栏 336

华为OD机考真题 新系统 - 数列求值(Java/Py/C/C++/Js/Go)

华为OD机试真题 新系统【数列求值】,提供C语言、Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解,以及在线OJ模拟做题。华为OD机试真题 【数列求值】多语言题解。

qq_45776114的博客 666

[leetcode]大可日常打卡1

344. Reverse Stringclass Solution { public String reverseString(String s) { if(s==null||s.length()==0){ return s; } StringBuilder sb=new StringBuilder(); for(int i=...

hellodake的博客 173

Flow Matching05:概率路径与插值【概率路径:线性插值路径(最简单)、高斯插值路径】【先尝试线性插值,看效果如何;若不够好,尝试高斯插值】

好的,我将从数学角度详细解释Flow Matching,从高中生能理解的基础知识开始,逐步深入到高级概念。

u013250861的博客 174

LeetCode打卡集锦

LeetCode 是一个非常棒的 OJ(Online Judge)平台,收集了许多常见的算法面试题目,同时还收录很多互联网公司的题库内容。如果为了面试刷题,LeetCode绝对是一个绝佳的选择。即使不为了跳槽面试,作为一个程序员,通过LeetCode保持手感也是不错的选择。本人就是平时刷刷题,在LeetCode上打打卡,告诉自己除了日常工作内容,还能做一些自己感兴趣的事情。 话不多说,看看最新刷过的题目列表,这仅仅是个开始。 LeetCode之两数之和(一) LeetCode之两数相加(二) Lee

liuzhen007的专栏 954

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

Leetcode刷题打卡贴,第一次有排名啦,文末附Leetcode刷题路线

种一棵树最好的时间是十年前,其次是现在

qq_53086461的博客 1268

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

力扣日常打卡---面试题04.10.检查子树

题目描述: 检查子树。你有两棵非常大的二叉树:T1,有几万个节点;T2,有几万个节点。设计一个算法,判断 T2 是否为 T1 的子树。 如果 T1 有这么一个节点 n,其子树与 T2 一模一样,则 T2 为 T1 的子树,也就是说,从节点 n 处把树砍断,得到的树与 T2 完全相同。 示例: 思路与题解: 看到题目要求,这种包含关系,第一时间我想的是把二叉树与字符串进行转换,然后判断: return !(s1.find(s2)==string::npos); 其中s1为t1树中序遍历的结果,s2为t2

qq_27615887的博客 407

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

[leetcode]大可日常打卡2

804. Unique Morse Code Words    先把所有的字母以及对应的morse code存储到map里面,然后对于words的每一个,把对应的transformation存储到一个hashmap里面,要是里面有对应的转换的话,就continue;没有的话就添加,返回transformation这个map的size就好。import java.util.HashMap; clas...

hellodake的博客 225

最长回文串_【Leetcode每日打卡】最长回文串

干货预警:所有文章都会首发于我的公众号【甜姨的奇妙冒险】,欢迎watch。一、来历: 力扣从3月开始开启了每日一题打卡活动,于是跟风加入了打卡大军,这两天写评论、发题解,没想到反响还不错,收到了来自很多同学的鼓励与好评,短短几天就170的关注了,有的同学说每天都会蹲我的评论和题解哈哈 ,本来觉得wx公众号是比较私人的趣味(つд⊂),但不由萌生了在公众号开一个专栏写每日一题的想法,有啥...

weixin_39712455的博客 135

Leetcode每日一题 720. 词典中最长的单词 一题两做 从零到一掌握前缀树的基础理解我会啦~

📖本篇内容:Leetcode每日一题 720. 词典中最长的单词 一题三做 从零到一深刻掌握前缀树(感谢三叶姐姐和y总 )前缀树的基础理解我会啦~ 📑 文章专栏:leetcode每日一题《打卡日常》 📆 最近更新:2022 年 3 月 16日 Leetcode每日一题 432. 全 O(1) 的数据结构 双向链表+数据结构的巧妙合理设计 完成O(1)搜索 ⭐算法仓库:小付的算法之路——Alascanfu-algorithm.git.io 🙊个人简介:一只二本院校在读的大三程序猿,本着注重基础,打.

Alascanfu的博客 632

【LeetCode高频SQL50题-基础版】打卡第4天:第21~25题

在这个博客专栏中,我将为大家提供关于 LeetCode 高频 SQL 题目的基础版解析。LeetCode 是一个非常受欢迎的编程练习平台,其中的 SQL 题目涵盖了各种常见的数据库操作和查询任务。对于计算机科班出身的同学来说,SQL 是一个基础而又重要的技能。不仅在面试过程中经常会遇到 SQL 相关的考题,而且在日常的开发工作中,掌握 SQL 的能力也是必备的。本专栏的目的是帮助读者掌握 LeetCode 上的高频 SQL 题目,并提供对每个题目的解析和解决方案。

热爱编程、热爱生活、热爱探索 749

【LeetCode高频SQL50题-基础版】打卡第7天:第36~40题

在这个博客专栏中,我将为大家提供关于 LeetCode 高频 SQL 题目的基础版解析。LeetCode 是一个非常受欢迎的编程练习平台,其中的 SQL 题目涵盖了各种常见的数据库操作和查询任务。对于计算机科班出身的同学来说,SQL 是一个基础而又重要的技能。不仅在面试过程中经常会遇到 SQL 相关的考题,而且在日常的开发工作中,掌握 SQL 的能力也是必备的。本专栏的目的是帮助读者掌握 LeetCode 上的高频 SQL 题目,并提供对每个题目的解析和解决方案。

热爱编程、热爱生活、热爱探索 923

力扣日常打卡面试题04.05.合法二叉搜索树

题目描述: 实现一个函数,检查一颗二叉树是否为搜索树。 示例: 思路及题解: 我们只要弄清楚何为二叉搜索树的概念即可: 即: 左节点的值<根节点的值<右节点的值 且对于左子树与右子树都必须满足这个条件且树内无重复项,简而言之,即: 中序遍历为升序的树才是合法的二叉搜索树。 知道了二叉搜索树的概念后,问题就迎刃而解了。 由于对于任意的子树(包括其本身)都需要满足以上条件,所以直观的思路就是对于每一个子树,我们设定一个lower和upper,若此节点满足 lower<node->val

qq_27615887的博客 278

【LeetCode高频SQL50题-基础版】打卡第8天:第41~45题

在这个博客专栏中,我将为大家提供关于 LeetCode 高频 SQL 题目的基础版解析。LeetCode 是一个非常受欢迎的编程练习平台,其中的 SQL 题目涵盖了各种常见的数据库操作和查询任务。对于计算机科班出身的同学来说,SQL 是一个基础而又重要的技能。不仅在面试过程中经常会遇到 SQL 相关的考题,而且在日常的开发工作中,掌握 SQL 的能力也是必备的。本专栏的目的是帮助读者掌握 LeetCode 上的高频 SQL 题目,并提供对每个题目的解析和解决方案。

热爱编程、热爱生活、热爱探索 856

力扣日常打卡---面试题04.06.后继者

题目描述: 设计一个算法,找出二叉搜索树中指定节点的“下一个”节点(也即中序后继)。 如果指定节点没有对应的“下一个”节点,则返回null。 示例: 思路及题解: 由于题目交代输入树已为二叉搜索树,那么,搜寻后继者的思路就变得清晰。 思路1:用一个vector储存中序遍历的结果,然后找到p所对应的值,则后继者为数组中p的值的后一个值,若p的值为数组中最后一个值,则返回null。代码如下: vector<TreeNode*> temp; void helper(TreeNode* node) {

qq_27615887的博客 335

Leetcode每日一题 440. 字典序的第K小数字 无树似有树 学习解题思路(感谢 杨兴元 uu 和 Benhao总)

📖本篇内容:Leetcode每日一题 440. 字典序的第K小数字 无树似有树 学习大佬们的解题思路 📑 文章专栏:leetcode每日一题《打卡日常》 📆 最近更新:2022 年 3 月 22 日 Leetcode每日一题 2038. 如果相邻两个颜色均相同则删除当前颜色 基础博弈题 ⭐算法仓库:小付的算法之路——Alascanfu-algorithm.git.io 🙊个人简介:一只二本院校在读的大三程序猿,本着注重基础,打卡算法,分享技术作为个人的经验总结性的博文博主,虽然可能有时会犯懒,但是还.

Alascanfu的博客 754

leetcode打卡

LeetCode日常试错。找到数组中两个不重复的数(其他的数都是两两的),一开始想到哈希表,但是尝试失败。。。。 使用位运算符解决问题,在做之前参考了找到一个不重复的数,全员异或,相同的两个都为0,单个的与0异或剩下单个的:如图: 所以问题变为如何将含有两个不重复的数的一个数组变为两个数组。继续全员异或,得到两个单独的数的异或,之后找到根据异或的结果,我们可以得到两者不同的最低位,我们根据这个最低位就可以将两个数分为两个数组,同时因为相同的数与最低位的与的结果相同,所以也保证了两个数组中相同的数是成

wyb990624的博客 111
上一篇: [剑指offer]大可日常打卡-树
下一篇: [计算机网络]一个完整的TCP连接
hellodake
博客等级 码龄10年 24粉丝 101原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值