算法实现之二叉树的深度

查找二叉树中以x为根节点的子树深度算法实现 二叉树是一种每个节点最多包含两个子节点的树结构,通常称为左子节点和右子节点。其基本构成包括根节点(顶层节点)、父节点、子节点、叶子节点(无子节点的节点)等元素。树的深度是指从根节点到最远叶子节点的最长路径上的节点数目。计算二叉树深度的常用方式是递归遍历左右子树,取最大值后加一。例如,以下是一个简单的二叉树节点定义:self.val = val # 节点存储的数据self.left = left # 左子节点self.right = right # 右子节点。 阅读详情

题目

输入一棵二叉树的根结点,求该树的深度。从根结点到叶结点依次经过的结点(含根、叶结点)形成树的一条路径,最长路径的长度为树的深度。

思路

如果一棵树只有一个结点,它的深度为1。如果根结点只有左子树而没有右子树,那么树的深度应该是其左子树的深度加1;同样如果根结点只有右子树而没有左子树,那么树的深度应该是其右子树的深度加1。如果既有右子树又有左子树,那该树的深度就是其左、右子树深度的较大值再加1。

实现

public class BinaryTreeNode {

    public Object data;

    public BinaryTreeNode left;

    public BinaryTreeNode right;

    public BinaryTreeNode() {

    }

    public BinaryTreeNode(Object data, BinaryTreeNode left, BinaryTreeNode right) {
        this.data = data;
        this.left = left;
        this.right = right;
    }
}
public class BinaryTree {

    public static void main(String[] args) {
        //模拟生成上图的二叉树
        BinaryTreeNode node7 = new BinaryTreeNode("7", null, null);
        BinaryTreeNode node5 = new BinaryTreeNode("5", null, node7);
        BinaryTreeNode node4 = new BinaryTreeNode("4", null, null);
        BinaryTreeNode node6 = new BinaryTreeNode("6", null, null);
        BinaryTreeNode node3 = new BinaryTreeNode("3", null, node6);
        BinaryTreeNode node2 = new BinaryTreeNode("2", node4, node5);
        BinaryTreeNode node1 = new BinaryTreeNode("1", node2, node3);

        BinaryTree tree = new BinaryTree();

        int length = tree.treeDepth(node1);
        System.out.println(length);
    }

    public int treeDepth(BinaryTreeNode node) {
        if (node == null) {
            return 0;
        }
        int left = treeDepth(node.left);
        int right = treeDepth(node.right);

        return (left > right) ? (left + 1) : (right + 1);
    }

}
单细胞空间转录组分析流程学习python版(三) 空转python版学习 阅读详情

相关推荐

【RF】Receiver Function接收函数:从理论到实践的深度解析

本文深入解析地震学中的接收函数(Receiver Function, RF)技术,从理论原理到实践操作。文章将RF比作地球的“听诊器”,详细阐述了其通过反褶积剥离震源影响、揭示地下结构(如莫霍面)的核心机制,并提供了使用Python和rf库进行数据处理、计算、动校正与叠加的完整实战流程,同时探讨了其应用、局限性与常见问题的解决方案。

Jerry的专栏 121

数据结构,计算二叉树深度 C语言实现

数据结构,计算二叉树深度

weixin_63676550的博客 2065

映泰TB250-BTC主板魔改BIOS支持8/9代CPU实战与开机故障排查

BIOS(基本输入输出系统)是计算机硬件与操作系统之间的桥梁,负责初始化硬件和提供运行时服务。其工作原理是通过存储在主板芯片中的固件程序,在上电自检(POST)阶段完成对CPU、内存等关键组件的检测与配置。魔改BIOS的技术价值在于突破硬件限制,通过修改微码和电源管理模块,让旧平台支持新处理器,从而以极低成本实现性能跃升,在预算有限或追求极致性价比的DIY、办公和软路由等应用场景中极具吸引力。本文以映泰TB250-BTC矿板为例,详细解析了通过软刷方式刷入魔改BIOS,并重点解决了刷写后常见的“开机风扇转一

weixin_29164185的博客 406

【代码+注释】求二叉树的深度【超详细】递归+非递归实现

编写算法求出二叉树的深度(层数) 二叉树的深度是指从根结点到叶结点依次经过的结点(含根、叶结点)形成树的一条路径,最长路径的长度为树的深度。本文将用两种方式求出二叉树的深度 第一种:无可置疑是递归   核心代码块: /*求二叉树的深度 ,递归方式*/ int getDepth(BiTreeNode *root) { int left, right; if (root == NULL) //递归出口 return 0; else {

chaim16的博客 2万+

添加odbc数据源时的一些问题和解决办法

pl/sql

Mr_Syh的博客 9644

Hierarchical Flow Partition(Top-down&&Bottom-up)

hierarchy flow是将设计切分成多个block,分别处理单个block,然后完成后,将它们进行拼接以完成最终的chip。一般划分为三个阶段:chip planning;physical budget就是pin assignmenthierarchy flow实现的方法有两种,一种是top-down,另一种是bottom-up,无论是哪种,都是都要通过flatten的方法分别全局范围进行优化实现。

qq_39493558的博客 3072

【数据结构】二叉树遍历算法的应用(递归)

数据结构与算法(青岛大学-王卓) 王道数据结构 B站up主林语石、计算机考研大师兄 参考

Zxingyun12的博客 801

QMT vs Ptrade:量化交易新手如何根据需求选择券商系统(附实战案例)

本文对比了QMT和Ptrade两大券商量化交易系统的核心差异,帮助量化交易新手根据需求选择合适的平台。QMT适合技术面策略开发,执行效率高;Ptrade则提供全面的财务数据和复杂策略支持。通过实战案例,展示了如何结合两平台优势实现高效量化交易。

weixin_42683394的博客 527

求二叉树的深度

一,Leetcode104 求二叉树的最大深度 //递归 public int maxDepth(TreeNode root) { return getDepth(root); } //左右子树的高度因为递归都是从下向上计算 public int getDepth(TreeNode root){ //终止条件就是出现空节点,高度也就是0 if(root==null) return 0; int leftDepth=getDept

thorf的博客 1182

这种绑定设备的文件拷贝出来了,怎么放到一台新的P100上使用

🏆 本文收录于《全栈Bug调优(实战版)》专栏,致力于分享我在项目实战过程中遇到的各类Bug及其原因,并提供切实有效的解决方案。无论你是初学者还是经验丰富的开发者,本文将为你指引出一条更高效的Bug修复之路,助你早日登顶,迈向财富自由的梦想🚀!同时,欢迎大家关注、收藏、订阅本专栏,更多精彩内容正在持续更新中。让我们一起进步,Up!Up!Up!    备注: 部分问题/难题源自互联网,经过精心筛选和整理,结合数位十多年大厂实战经验资深大佬经验总结所得,数条可行方案供所需之人参考。

**My Coding Family** 1135

人工智能在慢病管理中的具体应用全集:从技术落地到场景创新

这一成果的取得,得益于 AI 对居民血压数据的实时监测和分析,以及及时的干预措施。据统计,医疗支出下降了 18%,这主要是由于 AI 慢病管理系统实现了对慢病患者的早筛早诊早治,减少了并发症的发生,降低了医疗资源的浪费,从而减轻了患者和社会的医疗负担。医院信息系统(HIS)、电子病历(EMR)、区域卫生平台、可穿戴设备(如三诺血糖仪、华为手环)、第三方健康APP以及体检中心的数据往往采用不同的数据标准和格式(如HL7、FHIR、JSON、CSV等),且存储在相互隔离的系统中,形成典型的数据孤岛。

AllenLV的博客 2093

算法—求二叉树深度

题目 输入一棵二叉树,求该树的深度。从根结点到叶结点依次经过的结点(含根、叶结点)形成树的一条路径,最长路径的长度为树的深度。 分析 用递归即可,递归计算左子树深度left,递归计算右子树深度right,选择两者中较大的加一即是树的深度。 代码 import java.lang.Math; public class Solution { public int TreeDepth(TreeNode root) { if(root == null){ retur

shengpeizhu的博客 1945

【unity游戏开发入门到精通——UGUI】UI控件 —— Image图像控件

【unity游戏开发入门到精通——UGUI】UI控件 —— Image图像控件

向宇的博客,专注php/web全栈 unity游戏开发,欢迎大家评论纠错 2356

java 二叉树的深度 非递归算法_java二叉树深度不用递归,非递归实现

之前给大家带来了java二叉树中所有距离为K的结点的相关内容,那么下面要给大家带来的就是java二叉树深度非递归实现的内容,一起来看看吧。非递归实现利用层次遍历算法,设置变量level记录当前节点所在的层数,设置变量last指向当前层的最后一个节点,当处理完当前层的最后一个节点,让level指向+1操作。设置变量cur记录当前层已经访问的节点的个数,在cur等于last的时候,该层访问结束。层次遍...

weixin_30591519的博客 461

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Leetcode 111. 二叉树的最小深度 递归实现及BFS算法的实现 python版

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None from collections import deque class Solution: def minDepth(self, root: TreeNode) -> i.

CallMeYunzi的博客 400

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

【算法集训】Java实现之二叉树先中后序遍历、层序遍历、最大深度和合并二叉树

Java实现之二叉树先中后序遍历、层序遍历、最大深度和合并二叉树。

农夫的码,没有草原 1576

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

二叉树的最大深度——递归算法与非递归算法实现及其复杂度分析

该算法题源力扣,如下: 给定一个二叉树,找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例: 给定二叉树 [3,9,20,null,null,15,7], 3 / \ 9 20 /// / //\ ///15 7 ...

qq_34907927的博客 3477

算法题-二叉树的最小深度【JS实现】

给定一个二叉树,找出其最小深度。 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。 说明:叶子节点是指没有子节点的节点。 链接: https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/ 递归 var minDepth = function(root) { const res = []; if (!root) return 0 const min = (root, level) => { if (!root) ret

CrystalLee 934

[PHP]算法- 二叉树的深度的PHP实现

二叉树的深度: 输入一棵二叉树,求该树的深度。从根结点到叶结点依次经过的结点(含根、叶结点)形成树的一条路径,最长路径的长度为树的深度。 思路: 1.非递归层序遍历 2.使用辅助队列,根结点先入队列 3. 循环判断队列是否为空,如果不为空就继续循环队列里面的每个结点 4. 循环队列时,当前当前结点出队列,把该结点的左右孩子入队列 TreeDepth(tree) ...

weixin_34238633的博客 157

数据结构与算法——Java实现 42.二叉树的最大深度

给定一个二叉树root,返回其最大深度。二叉树的是指从根节点到最远叶子节点的最长路径上的节点数。323。

m0_73983707的博客 1225

LeetCode力扣题目111:多种算法对比实现二叉树的最小深度

它通过迭代方式检查每一层的节点,直到找到第一个叶子节点,然后立即返回这个叶子节点的深度。这个方法的主要优点是它不必检查所有的节点,尤其是在一个高度不平衡的树中,它可以更快地找到最浅的叶子节点。通过这种改进,BFS 方法更加高效和直观,尤其是在处理大型数据集时,这种方法能快速找到最小深度,而无需深入遍历树的所有部分。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。注意:叶子节点是指没有子节点的节点。这些方法在需要快速确定数据结构(如游戏、网络路由、社交网络的层级结构)中的最小路径或深度时非常有用。

10年数据\经营分析经验,现任大厂数据分析负责人 634

二叉树深度优先遍历:算法原理、实现与应用全解析

本文系统介绍了二叉树深度优先遍历的原理、实现及应用。深度优先遍历包括前序、中序和后序三种方式,分别对应不同的节点访问顺序。实现方法上,递归简洁但可能栈溢出,迭代使用栈更安全。该技术广泛应用于树结构分析、搜索算法、编译器设计等领域,是处理树形数据的基础。掌握深度优先遍历对理解数据结构、优化算法效率具有重要意义,其扩展应用仍在不断演进。

你若盛开,清风自来 1923

【算法】Java实现二叉树遍历、还原二叉树、深度查找

二叉树遍历前言遍历为树结构效果图前序遍历中序遍历后序遍历还原二叉树前中序还原二叉树中后序还原二叉树后记 前言 二叉树算是树结构中最常见也相对简单的一种结构了,平常在查找、排序算法中也常常作为优化工具被使用。这篇文章就记录一下如何多种方式遍历二叉树。 先贴出基本的代码结构: public class MyTree { public static void main(String[] args) { int[] list = { 6, 3, 2, 8, 5, 9, 0, 1, 7, 4 }; Tree

TiramisuDP的博客 1000

二叉树最大路径和:从数据结构到算法实现的深度解析

本文探讨了二叉树中的"最大路径和"问题,阐述了其核心挑战在于路径可以任意起始和终止,且节点值可能为负。通过结合深度优先搜索和动态规划思想,提出了一种递归解决方案:从叶子节点向上遍历,计算每个节点作为顶点的四种可能路径情况,维护全局最大值。文章详细解析了算法实现,包括边界条件处理、复杂度分析(O(n)时间,O(h)空间)以及特殊情况考虑,展示了如何将复杂问题分解为子问题进行递归求解。该解决方案适用于各类二叉树路径问题,体现了DFS在树结构中的典型应用模式。

2402_87010087的博客 967

前端必考算法——二叉树的深度优先搜索之代码实现

二叉树的深度优先搜索之代码实现 代码演示: function Node(value) { this.value = value; this.left = null; this.right = null; } var a = new Node("a"); var b = new Node("b"); var c = new Node("c"); var d = new Node("d"); var e = new Node("e"); var f = new Node("f"); var g

qq_63664183的博客 417

算法题-二叉树的最大深度【JS实现】

给定一个二叉树,找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 链接: https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/ 递归 /** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.rig

CrystalLee 585
上一篇: 算法实现之第一个只出现一次的字符
下一篇: android平台下OpenCV之从零开始
handy周
handy周 领域专家: 操作系统技术领域 领域专家: 操作系统技术领域
博客等级 码龄14年 507粉丝 240原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值