●day 17 第六章 二叉树part04

已于 2023-10-10 08:24:53 修改
阅读量114 收藏
点赞数
文章标签： 数据结构 算法
于 2023-10-10 08:24:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65279006/article/details/133631274
版权

本章节就是三道leetcode题目的学习。硬背下来的算是。。。 

110. 平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

class Solution {
    public boolean isBalanced(TreeNode root) {
        return getHeight(root)!=-1;
    }
    private int getHeight(TreeNode root){
        if(root==null){
            return 0;
        }
        int leftHeight = getHeight(root.left);
        if (leftHeight==-1){
            return -1;
        }
        int rightHeight = getHeight(root.right);
        if(rightHeight==-1){
            return -1;
        }
        if(Math.abs(leftHeight-rightHeight)>1){
            return -1;
        }
        return Math.max(leftHeight,rightHeight)+1;
    }
}

 迭代法暂时先不掌握。

257. 二叉树的所有路径

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。

叶子节点 是指没有子节点的节点。

递归

    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<>();
        dfs(root, "", res);
        return res;
    }

    private void dfs(TreeNode root, String path, List<String> res) {
        //如果为空，直接返回
        if (root == null)
            return;
        //如果是叶子节点，说明找到了一条路径，把它加入到res中
        if (root.left == null && root.right == null) {
            res.add(path + root.val);
            return;
        }
        //如果不是叶子节点，在分别遍历他的左右子节点
        dfs(root.left, path + root.val + "->", res);
        dfs(root.right, path + root.val + "->", res);
    }
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new LinkedList<>();
        if (root == null)
            return res;
        //到达叶子节点，把路径加入到集合中
        if (root.left == null && root.right == null) {
            res.add(root.val + "");
            return res;
        }
        //遍历左子节点的路径
        for (String path : binaryTreePaths(root.left)) {
            res.add(root.val + "->" + path);
        }
        //遍历右子节点的路径
        for (String path : binaryTreePaths(root.right)) {
            res.add(root.val + "->" + path);
        }
        return res;
    }

迭代

    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<>();
        if (root == null)
            return res;
        //栈中节点和路径都是成对出现的，路径表示的是从根节点到当前
        //节点的路径，如果到达根节点，说明找到了一条完整的路径
        Stack<Object> stack = new Stack<>();
        //当前节点和路径同时入栈
        stack.push(root);
        stack.push(root.val + "");
        while (!stack.isEmpty()) {
            //节点和路径同时出栈
            String path = (String) stack.pop();
            TreeNode node = (TreeNode) stack.pop();
            //如果是根节点，说明找到了一条完整路径，把它加入到集合中
            if (node.left == null && node.right == null) {
                res.add(path);
            }
            //右子节点不为空就把右子节点和路径压栈
            if (node.right != null) {
                stack.push(node.right);
                stack.push(path + "->" + node.right.val);
            }
            //左子节点不为空就把左子节点和路径压栈
            if (node.left != null) {
                stack.push(node.left);
                stack.push(path + "->" + node.left.val);
            }
        }
        return res;
    }
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<>();
        if (root == null)
            return res;
        //队列，节点和路径成对出现，路径就是从根节点到当前节点的路径
        Queue<Object> queue = new LinkedList<>();
        queue.add(root);
        queue.add(root.val + "");
        while (!queue.isEmpty()) {
            TreeNode node = (TreeNode) queue.poll();
            String path = (String) queue.poll();
            //如果到叶子节点，说明找到了一条完整路径
            if (node.left == null && node.right == null) {
                res.add(path);
            }

            //右子节点不为空就把右子节点和路径存放到队列中
            if (node.right != null) {
                queue.add(node.right);
                queue.add(path + "->" + node.right.val);
            }

            //左子节点不为空就把左子节点和路径存放到队列中
            if (node.left != null) {
                queue.add(node.left);
                queue.add(path + "->" + node.left.val);
            }
        }
        return res;
    }

官方递归

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> paths = new ArrayList<String>();
        constructPaths(root, "", paths);
        return paths;
    }

    public void constructPaths(TreeNode root, String path, List<String> paths) {
        if (root != null) {
            StringBuffer pathSB = new StringBuffer(path);
            pathSB.append(Integer.toString(root.val));
            if (root.left == null && root.right == null) {  // 当前节点是叶子节点
                paths.add(pathSB.toString());  // 把路径加入到答案中
            } else {
                pathSB.append("->");  // 当前节点不是叶子节点，继续递归遍历
                constructPaths(root.left, pathSB.toString(), paths);
                constructPaths(root.right, pathSB.toString(), paths);
            }
        }
    }
}

官方迭代

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> paths = new ArrayList<String>();
        if (root == null) {
            return paths;
        }
        Queue<TreeNode> nodeQueue = new LinkedList<TreeNode>();
        Queue<String> pathQueue = new LinkedList<String>();

        nodeQueue.offer(root);
        pathQueue.offer(Integer.toString(root.val));

        while (!nodeQueue.isEmpty()) {
            TreeNode node = nodeQueue.poll(); 
            String path = pathQueue.poll();

            if (node.left == null && node.right == null) {
                paths.add(path);
            } else {
                if (node.left != null) {
                    nodeQueue.offer(node.left);
                    pathQueue.offer(new StringBuffer(path).append("->").append(node.left.val).toString());
                }

                if (node.right != null) {
                    nodeQueue.offer(node.right);
                    pathQueue.offer(new StringBuffer(path).append("->").append(node.right.val).toString());
                }
            }
        }
        return paths;
    }
}

代码随想录

class Solution {
    /**
     * 递归法
     */
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<>();// 存最终的结果
        if (root == null) {
            return res;
        }
        List<Integer> paths = new ArrayList<>();// 作为结果中的路径
        traversal(root, paths, res);
        return res;
    }

    private void traversal(TreeNode root, List<Integer> paths, List<String> res) {
        paths.add(root.val);// 前序遍历，中
        // 遇到叶子结点
        if (root.left == null && root.right == null) {
            // 输出
            StringBuilder sb = new StringBuilder();// StringBuilder用来拼接字符串，速度更快
            for (int i = 0; i < paths.size() - 1; i++) {
                sb.append(paths.get(i)).append("->");
            }
            sb.append(paths.get(paths.size() - 1));// 记录最后一个节点
            res.add(sb.toString());// 收集一个路径
            return;
        }
        // 递归和回溯是同时进行，所以要放在同一个花括号里
        if (root.left != null) { // 左
            traversal(root.left, paths, res);
            paths.remove(paths.size() - 1);// 回溯
        }
        if (root.right != null) { // 右
            traversal(root.right, paths, res);
            paths.remove(paths.size() - 1);// 回溯
        }
    }
}

//方式二
class Solution {

    List<String> result = new ArrayList<>();

    public List<String> binaryTreePaths(TreeNode root) {
        deal(root, "");
        return result;
    }

    public void deal(TreeNode node, String s) {
        if (node == null)
            return;
        if (node.left == null && node.right == null) {
            result.add(new StringBuilder(s).append(node.val).toString());
            return;
        }
        String tmp = new StringBuilder(s).append(node.val).append("->").toString();
        deal(node.left, tmp);
        deal(node.right, tmp);

404. 左叶子之和

给定二叉树的根节点 root ，返回所有左叶子之和。

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if (root == null) return 0;
        int sum = 0;
        if (root.left != null && root.left.left == null && root.left.right == null) {
            sum += root.left.val;
        }
        sum += sumOfLeftLeaves(root.left);    // 左
        sum += sumOfLeftLeaves(root.right);  // 右
        return sum;
    }
}
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if (root == null) return 0;
        int leftValue = sumOfLeftLeaves(root.left);    // 左
        int rightValue = sumOfLeftLeaves(root.right);  // 右
                                                       
        int midValue = 0;
        if (root.left != null && root.left.left == null && root.left.right == null) { 
            midValue = root.left.val;
        }
        int sum = midValue + leftValue + rightValue;  // 中
        return sum;
    }
}

迭代

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if (root == null) return 0;
        Stack<TreeNode> stack = new Stack<> ();
        stack.add(root);
        int result = 0;
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            if (node.left != null && node.left.left == null && node.left.right == null) {
                result += node.left.val;
            }
            if (node.right != null) stack.add(node.right);
            if (node.left != null) stack.add(node.left);
        }
        return result;
    }
}
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        int sum = 0;
        if (root == null) return 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size -- > 0) {
                TreeNode node = queue.poll();
                if (node.left != null) { // 左节点不为空
                    queue.offer(node.left);
                    if (node.left.left == null && node.left.right == null){ // 左叶子节点
                        sum += node.left.val;
                    }
                }
                if (node.right != null) queue.offer(node.right);
            }
        }
        return sum;
    }
}

对于左节点不为空要判断一下。要么像第一个里面一样在第一个判断的时候加上判断左节点不为空。要么像第二个一样写在左节点不为空的判断里面。

Cccgy陈
关注
day 17：第六章 二叉树part04
jbjhzstsl的博客
04-19 256
掌握递归的思考过程● 110.平衡二叉树● 257. 二叉树的所有路径● 404.左叶子之和● 110.平衡二叉树/*110. 平衡二叉树简单给定一个二叉树，判断它是否是平衡二叉树一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。/** 返回值深度，传入节点* 终止条件：节点空* 单层递归逻辑：左子节点递归，右子节点递归，返回深度加一,如果判断出节点高度大于1，返回-1，说明不是平衡二叉树*/
day16 第六章 二叉树 part04
mvufi的博客
09-19 184
找树左下角的值前序法层序路径总和。
day17 第六章 二叉树 part05
mvufi的博客
09-23 161
层序：破坏了树状结构，很难重新构造，一般不用于构造树。如果t1为空，合并之后就是t2。如果t2为空，合并之后就是t1。直接return 不需要继续。700.二叉搜索树中的搜索。构造二叉树都是 前序遍历。98.验证二叉搜索树。
Day 17 第六章 二叉树part04
wxw154170875的博客
09-22 112
3道题目。
代码随想录 day17 第六章 二叉树part04
weixin_60315213的博客
03-10 1085
迭代法，大家可以直接过，二刷有精力的时候 再去掌握迭代法。● 257. 二叉树的所有路径。● 110.平衡二叉树。● 404.左叶子之和。
代码随想录 day14:第六章 二叉树 part04
z25735的博客
06-22 156
第六章 二叉树 part04找树左下角的值路径总和从中序与后序遍历序列构造二叉树 找树左下角的值 本题递归偏难，反而迭代简单属于模板题， 两种方法掌握一下 路径总和 涉及到回溯的过程，而且回溯的过程隐藏的还挺深 路径总和，和 113. 路径总和ii 一起做了。 优先掌握递归法。 从中序与后序遍历序列构造二叉树 106.从中序与后序遍历序列构造二叉树，105.从前序与中序遍历序列构造二叉树 一起做，思路一样的
【代码随想录算法训练营14期】- day 17 第六章 二叉树part04
jtzdgzlm的博客
05-30 178
二叉树递归函数如果有返回值，那么遍历时要return返回值；递归函数没有返回值，答案加入数组，传递数组地址&，不需要return，直接运行函数对于第三个左叶子节点，因为返回值每次都是0return，故需要把ans放入return中，相当于每次递归都是ans+0+0；最后累计；
代码随想录算法训练营day 17第六章 二叉树part04
mrmobi的博客
01-29 363
第一种递归方式，也是我选择的递归方式，就是将潜在的一条解决方案的路径按照vector<int>的方式存储（使用栈或者队列都并不方便，因为存入最后的结果数组的时候并不能将之前存入的数值pop掉，否则就会无法实现正确回溯），注意，数组传入的方式必须是传入地址，如果是复制的话，下层的递归改变的数组的值不会影响上层递归，导致回溯不成功——需要将根节点到每一个节点的路径都存储起来，然后试图更新这个路径（也就是增加路径的长度，到达它的子节点们），只有当该节点是叶子节点的时候才会真正存入结果数组中——
●day 18 第六章 二叉树 part05
weixin_65279006的博客
10-21 128
它们的作用域只限于声明它们的代码块。：只有当当前叶子节点的深度超过之前记录的最大深度时，我们才更新存储的最左侧值。为此，我们需要有一个变量来跟踪当前节点的深度，并将其与已知的最大深度进行比较。这样，当我们遇到一个叶子节点时，我们可以检查它是否位于比我们之前见过的任何叶子节点更深的位置。这对于确定哪些节点位于最底层是必要的，因为我们的目标是找到最底层的最左侧节点的值。这样的变量，我们就无法确定每个节点的深度，从而无法确定哪个叶子节点位于最底层。它与方法内部的局部变量的可见性或类的成员变量的可见性无关。
代码随想录-035期-算法训练营【博客笔记汇总表】
upward
04-10 612
代码随想录-035期-算法训练营【博客笔记汇总表】
代码随想录算法训练营Day11 | 递归遍历，迭代遍历，统一迭代，层序遍历
little__penguin的博客
06-21 404
利用漏洞实现 Outlook 的 RCE：第 2 部分
技术超强的网络安全平台
08-23 808
音频压缩管理器 (ACM) 是负责处理 WAV 文件中使用的编解码器不使用简单 PCM 编码的情况的代码，因此需要由自定义解码器进行解码。这些解码器在扩展名为 .acm 的文件中实现。一个常见示例是 MP3 编解码器，它在 l3codeca.acm 中实现。每个编解码器都由一个驱动程序处理（它与内核模式驱动程序不同，但功能相似），该驱动程序通过 ACM 注册。每当需要转换时，例如将 MP3 转换为 PCM 或反之，ACM 就会开始工作并管理此转换。
机器学习笔记-XGBoost
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
08-01 6365
XGBoost是2016年由华盛顿大学陈天奇老师带领开发的一个可扩展机器学习系统。严格意义上讲XGBoost并不是一种模型，而是一个可供用户轻松解决分类、回归或排序问题的软件包。它内部实现了梯度提升树(GBDT)模型，并对模型中的算法进行了诸多优化，在取得高精度的同时又保持了极快的速度，在一段时间内成为了国内外数据挖掘、机器学习领域中的大规模杀伤性武器。更重要的是，XGBoost在系统优化和机器学习原理方面都进行了深入的考虑。
第九次培训任务：学习嵌入式C
Adaobaozhao的博客
08-21 708
// 不带参数的宏定义 #define MAX 10 /*带参宏定义*/ #define M(y) y*y+3*y /*宏调用*/ k=M(5);
数据结构2——单链表
最新发布
weixin_73629886的博客
09-23 1155
了解了顺序表的不足，下面我们就来学习一下链表，看一看链表能不能解决顺序表的不足。
数据结构：二叉树（2）
2303_78940834的博客
09-21 1277
普通的树的实用价值比较小，将树更一步特殊化成二叉树，将获得更多的特殊性质。例如搜索二叉树，红黑树等。这篇博文主要介绍二叉树的基础知识，进阶版高级二叉树，后续会持续更新。
【数据结构取经之路】图解红黑树
bit_pan的博客
09-20 875
AVL-tree之外，另一个颇具历史且被广泛使用的平衡二叉搜索树是红黑树(RB-tree)，这名字听起来除了很抽象外，还颇具大哥味哈，会不会很难？客观地说，难度是有的，下面我们细细道来。//结点的颜色//红黑树结点的定义//结点的左孩子//结点的右孩子//结点的父节点//结点的颜色T _data;//结点的数据域{}以上就是红黑树节点定义，但有两个问题：为什么需要指向父节点的指针？为什么要将结点的默认颜色设置成黑色？先来回答第一个问题，在旋转时需要访问父节点，所以引入了指向父节点的指针。
代码随想录算法训练营 | 二叉树理论基础
jiabao0520的博客
09-22 537
训练营：二叉树理论基础
严蔚敏教材第六章：树与二叉树解题指南
"严蔚敏教材的第六章主要讨论了树和二叉树的相关概念与操作，包括子孙关系判断、相似树的识别以及不同遍历方法的实现。" 在计算机科学中，树是一种非线性数据结构，广泛应用于各种领域，如文件系统、编译器设计、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值