LeetCode刷题记录(JavaScript)——二叉树

最新推荐文章于 2023-05-04 19:37:15 发布
最新推荐文章于 2023-05-04 19:37:15 发布
阅读量283 收藏
点赞数
分类专栏： Leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38211443/article/details/105024274
版权

目录

104. 二叉树的最大深度(easy)——03/22

617. 合并二叉树(easy) ——04/10

100. 相同的树(easy) —— 04/10

110. 平衡二叉树(easy) ——04/10

637. 二叉树的层平均值(easy)——04/17

226. 翻转二叉树（easy）——04/17

235. 二叉搜索树的最近公共祖先(easy)——04/17

111. 二叉树的最小深度(easy) ——04/17

104. 二叉树的最大深度(easy)——03/22

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

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

示例：
给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

 

递归
/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var maxDepth = function(root) {
    if (root ==null) return 0 ;
    let left = maxDepth(root.left);
    let right = maxDepth(root.right);
    return Math.max(left,right)+1;
};

617. 合并二叉树(easy) ——04/10

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

示例 1:

输入: 
    Tree 1                     Tree 2                  
          1                         2                             
         / \                       / \                            
        3   2                     1   3                        
       /                           \   \                      
      5                             4   7                  
输出: 
合并后的树:
         3
        / \
       4   5
      / \   \ 
     5   4   7
注意: 合并必须从两个树的根节点开始。

解题思路：

 1.从根节点开始，递归，前序遍历思想， 将t2合并到t1上面： 

如果t1为空，则取t2,如果t2为空，取t1，如果都不空，那么计算新值，并且对它们的左孩子，右孩子进行合并，返回

2.非递归： 实际上是广度优先（层序遍历），如果t1,t2有一个是null,就直接返回非空，如果都不空，那么就进入队列循环

循环中：取出节点，计算合并值，赋给t1，判断 两个left，如果都非空，那么进入队列，再判断 两个right，如果都非空，那么也进入队列。否则谁不为空，就赋给t1。直到队列空了

最后返回t1即可


/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} t1
 * @param {TreeNode} t2
 * @return {TreeNode}
 */

1.递归
var mergeTrees = function(t1, t2) {
    if (t1 == null){
        return t2;
    }
    else if (t2 == null){
        return t1;
    } else {
        t1.val  = t1.val + t2.val;
        t1.left  = mergeTrees(t1.left,t2.left);
        t1.right = mergeTrees(t1.right,t2.right);
        return t1;
    }
};


2.非递归
var mergeTrees = function(t1, t2) {
    if (t1 == null || t2 == null){
        return t1 ? t1 :t2;
    } 
    let queue = [];
    queue.push([t1,t2]);
    while(queue.length > 0) {
        let [p,q] = queue.shift(); 
        p.val += q.val;

        if (p.left == null || q.left == null){
            p.left = p.left ? p.left : q.left;
        }else {
            queue.push([p.left,q.left]);
        }
        
        if (p.right == null || q.right == null){
            p.right = p.right ? p.right : q.right;
        }else {
            queue.push([p.right,q.right]);
        }
    }
    return t1;
};

100. 相同的树(easy) —— 04/10

给定两个二叉树，编写一个函数来检验它们是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1:

输入:       1         1
          / \       / \
         2   3     2   3

        [1,2,3],   [1,2,3]

输出: true

示例 2:

输入:      1          1
          /           \
         2             2

        [1,2],     [1,null,2]

输出: false

解题思路：

 递归：

p,q都是null ——> true

p,q 一个是null，一个不是 ——> false

p,q 值不相等 ——> false

p,q 值相等 ——> 判断left 和 right;  取 并 

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {boolean}
 */

var isSameTree = function(p, q) {
    if (p == null && q == null){
        return true;
    }else if (p == null || q == null){
        return false;
    }else if (p.val != q.val){
        return false; 
    }

    return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
};

110. 平衡二叉树(easy) ——04/10

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

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

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

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7
返回 true 。

解题思路： 

-1时代表失败，直接返回

否则递归查询，递归出口是root == null ,返回高度0

递归查询左右子树高度，如果高度差绝对值<2，那么该节点是平衡的，它的高度等于左右高度的max+1，否则不平衡，直接-1

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {boolean}
 */
var isBalanced = function(root) {
    return checkBalanced(root) != -1;
};

var checkBalanced = function(root){
    if (root == null) return 0;
    let left = checkBalanced(root.left);
    if (left == -1) return -1;
    let right = checkBalanced(root.right);
    if (right == -1) return -1;
    return Math.abs(left - right) < 2 ? Math.max(left,right)+1 : -1;
};

637. 二叉树的层平均值(easy)——04/17

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组.

示例 1:

输入:
    3
   / \
  9  20
    /  \
   15   7
输出: [3, 14.5, 11]
解释:
第0层的平均值是 3,  第1层是 14.5, 第2层是 11. 因此返回 [3, 14.5, 11].
注意：

节点值的范围在32位有符号整数范围内。

解题思路：

广度优先遍历，类似于层次遍历，用queue来存储每层的节点，但是为了计算每层节点数量，借助临时队列temp来存储下一层的节点，这样方便计算本层数量，及本层sum值，在计算完成后再把temp赋值给queue。

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var averageOfLevels = function(root) {
    let result = [],queue = [];
    if (!root) return result;
    queue.push(root);
    while(queue.length>0){
        let count = 0, sum = 0, temp=[];
        while(queue.length>0){
            let node = queue.shift();
            count ++;
            sum += node.val;
            if (node.left) temp.push(node.left);
            if (node.right) temp.push(node.right);
        }
        queue = temp;
        result.push(sum/count);
    }
    return result;
};

226. 翻转二叉树（easy）——04/17

翻转一棵二叉树。

示例：

输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9
输出：

     4
   /   \
  7     2
 / \     / \
9   6 3   1

解题思路：

递归，后序，先处理左孩子，右孩子，最后把左右孩子调换。

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {TreeNode}
 */
var invertTree = function(root) {
    if (!root) return root;
    root.left = invertTree(root.left);
    root.right = invertTree(root.right);
    let temp = root.left;
    root.left = root.right;
    root.right = temp;
    return root;
};

235. 二叉搜索树的最近公共祖先(easy)——04/17

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉搜索树:  root = [6,2,8,0,4,7,9,null,null,3,5]

 

示例 1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6 
解释: 节点 2 和节点 8 的最近公共祖先是 6。
示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

解题思路：

二叉搜索树特性：左子树的值都比根的值小，右子树的值都比根的值大。

所以根据这个特性，得出方法：从根开始遍历，如果p和q都在左子树上，那么把左孩子当根再进行遍历，如果p和q都在右子树上，那么把右孩子当根进行遍历，如果p和q不在同一侧，那么这个节点就是他们的最近的公共祖先。

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {TreeNode}
 */
var lowestCommonAncestor = function(root, p, q) {
    
        let  parentVal = root.val, pVal =p.val, qVal = q.val;
        if ( pVal > parentVal && qVal > parentVal) {
            return lowestCommonAncestor(root.right, p, q);
        } else if (pVal < parentVal && qVal < parentVal) {
            return lowestCommonAncestor(root.left, p, q);
        } else {
            return root;
        }
};

111. 二叉树的最小深度(easy) ——04/17

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

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

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

示例:

给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回它的最小深度  2.

解题思路：

递归出口：

1.root == null,是叶子节点，0

2.root左右孩子都是null，那么它的深度是1。

3.要注意的是当有一个孩子为空，另一个孩子不空，那么它的深度要取不空孩子的深度+1;

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var minDepth = function(root) {
    if (!root) return 0;
    if (!root.left && !root.right ) return 1;
    if (!root.left || !root.right) return Math.max(minDepth(root.left),minDepth(root.right))+1;
    return Math.min(minDepth(root.left),minDepth(root.right))+1;
};

 

旺仔流奶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
二叉树（详解）
weixin_63246738的博客
03-30 1万+
简单实现二叉树
Leetcode刷题笔记（C++）——二叉树
CV小菜鸟的博客
08-01 338
Leetcode刷题笔记（C++）——二叉树 整理一下刷题过程中的思路，在这里进行一下总结与分享。 github地址：https://github.com/lvjian0706/Leetcode-solutions github项目是刚刚新建的，陆续会将整理的代码以及思路上传上去，代码是基于C++与python的。同时会将基础的排序算法等也一并进行整理上传。 102. 二叉树的层序遍历 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。 示例： 二叉树：[3,9,2
深入理解二叉树（超详细）
Kalton的博客
09-17 1万+
二叉树（Binary Tree） 回顾 在前面的文章 — 二叉树前奏中，我们对于二叉树的一些基本概念进行了回顾，同时对比了线性结构与树形结构，总结了一些常见的二叉树的性质，像二叉树，真二叉树，完全二叉树，以及满二叉树等等，但是，我们仅仅是在概念上对于二叉树有所了解，并没有进行编码工作，今天来完善一下这一步的操作 直接进入二叉树的设计与编码，如果你对于二叉树的概念以及性质不了解的话，可以回去翻翻 二叉树前奏，熟悉一下，因为编码实际上就是对于二叉树性质的一个体现 设计 属性与节点 首先，我们的二叉树是用来存放元
【数据结构】——二叉树详解
atwdy的博客
07-28 5万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
leetcode对称二叉树（js实现）
qq_41096610的博客
08-09 563
对称二叉树 给定一个二叉树，检查它是否是镜像对称的。 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。 但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的: 解题思路 递归求解 两个数互为镜像的条件： 1.他们的两个根节点具有相同的值 2.每个树的右子树都与另一个树的左子树镜像对称 可以根据 此构造一个递归函数，通过同时移动两个指针，来遍历左右子树，left指针和right指针一开始都指向树的根节点，left左移的同时，right右移，left右移的同时，right左移
二叉树详解
m0_68989458的博客
05-12 1万+
二叉树详解
Leetcode刷题总结——二叉树
weixin_47883447的博客
04-06 426
二叉树节点的定义： 1、二叉树的遍历 前序遍历（中左右）、中序遍历（左中右）、后序遍历（左右中） 递归三要素： 1）确定递归函数的参数和返回值：确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。 2）确定终止条件：写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。 3）.
LeetCode:LeetCode刷题-JavaScript版
05-20
在LeetCode平台上，JavaScrip
leetcode刷题账号-LeetCode:LeetCode刷题记录(C#)
07-06
这个压缩包文件"LeetCode-master"很可能包含了某个用户在刷题过程中的代码记录或者解决方案。 在刷LeetCode的过程中，有几个关键知识点是值得深入探讨的： 1. **基础数据结构**：在LeetCode的题目中，常见数据结构...
leetcode:leetcode刷题记录与总结
04-11
《LeetCode刷题记录与总结》 LeetCode，一个广受欢迎的在线编程挑战平台，汇聚了各类算法题目，是程序员提升编程技能、准备面试的重要工具。这篇文档将围绕我在LeetCode上的刷题经历，分享一些关键知识点和学习心得...
leetcode-python:leetcode刷题记录
04-12
重建二叉树 二叉树，前序遍历，中序遍历 剑指Offer 09. 用两个栈实现队列 栈与队列的操作 503. 下一个更大元素 II 单调栈 剑指Offer 18. 删除链表的节点 链表双指针 剑指Offer 22. 链表中倒数第k个节点 链表双指针 ...
【数据结构】二叉树（详细）
最新发布
Zhuang_N的博客
05-04 5166
二叉树的四种遍历、大量练习、二叉树的创建和销毁
数据结构与算法之二叉树大全
努力让自己发光，对的人才能迎着光而来
09-04 2万+
二叉树的定义 二叉树的性质(特性) 满二叉树与完全二叉树 链式存储的二叉树 顺序存储的二叉树 线索二叉树(Threaded BinaryTree) 二叉排序树（Binary Sort Tree） 平衡二叉树（ Balanced Binary Tree） 为什么使用平衡二叉树？ 如何判断平衡二叉树？ 相关概念 旋转方式 实例 代码实现...
【数据结构】二叉树详解
qq_52989768的博客
08-20 4298
树是一种非线性的数据结构，是由多个节点组成的有层次关系的集合，看起来就像一颗倒挂的树，如下图：树中有一个节点没有前驱节点，这个节点称为根节点除根节点外，其余的节点又可以看成多个互不相交的集合，每一个集合就是一颗子树。
二叉树基础知识总结
热门推荐
小拳头的博客
03-24 10万+
题外话昨晚面了腾讯，问了一个完全二叉树的题，竟然让我算了快10分钟，因为等比公式记错了导致最后用最原始的方法推算结果也没算对，一下子就懵了。本来精心准备了1周的面试，最后因为自己基础知识记忆不牢固导致了悲剧。不管怎样，还是要继续查漏补缺，准备将数据结构再细细看一遍，先来补上二叉树的这个漏洞吧。 一、树的定义树是一种数据结构，它是由n（n&gt;=1）个有限结点组成一个具有层次关系的集合。 树具有的...
"详细代码解析：Leetcode刷题记录
在本文中，我将分享我的leetcode刷题记录，包括我在解决每个问题时所使用的代码和思路讲解。这份记录非常详细，旨在帮助其他人更好地理解leetcode题目的解法和编程技巧。 21、TWO SUM 这道题的关键在于要找到数组中...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值