JavaScript算法题总结 （三）二叉树

最新推荐文章于 2022-06-17 13:20:03 发布
最新推荐文章于 2022-06-17 13:20:03 发布
阅读量329 收藏 2
点赞数
分类专栏： 算法 文章标签： javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nxcniuxiangchen/article/details/124696034
版权

BM23 二叉树的前序遍历

在这里插入图片描述

/*
 * function TreeNode(x) {
 *   this.val = x;
 *   this.left = null;
 *   this.right = null;
 * }
 */
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param root TreeNode类 
 * @return int整型一维数组
 */
function preorderTraversal( root ) {
    // write code here
    let arr=[];
    function preOrder(root){
        if(!root) return null;
        arr.push(root.val);
        preOrder(root.left);
        preOrder(root.right);
    }
    preOrder(root)
    return arr;
}
module.exports = {
    preorderTraversal : preorderTraversal
};

BM24 二叉树的中序遍历

在这里插入图片描述

/*
 * function TreeNode(x) {
 *   this.val = x;
 *   this.left = null;
 *   this.right = null;
 * }
 */
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param root TreeNode类 
 * @return int整型一维数组
 */
function inorderTraversal( root ) {
    // write code here
    let arr=[];
    function midOrder(root){
        if(!root) return;
        midOrder(root.left);
        arr.push(root.val);
        midOrder(root.right);
    }
    midOrder(root);
    return arr;
}
module.exports = {
    inorderTraversal : inorderTraversal
};

BM25 二叉树的后序遍历

在这里插入图片描述

/*
 * function TreeNode(x) {
 *   this.val = x;
 *   this.left = null;
 *   this.right = null;
 * }
 */
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param root TreeNode类 
 * @return int整型一维数组
 */
function postorderTraversal( root ) {
    // write code here
    let arr=[];
    function lastOrder(root){
        if(!root) return ;
        lastOrder(root.left);
        lastOrder(root.right);
        arr.push(root.val)
    }
    lastOrder(root)
    return arr;
}
module.exports = {
    postorderTraversal : postorderTraversal
};

BM26 求二叉树的层序遍历

在这里插入图片描述

/*
 * function TreeNode(x) {
 *   this.val = x;
 *   this.left = null;
 *   this.right = null;
 * }
 */

/**
  * 
  * @param root TreeNode类 
  * @return int整型二维数组
  */
function levelOrder( root ) {
    // write code here
    let arr=[];
    function cxOrder(root,level){
        if(!root) return;
        if(!arr[level]) arr[level]=[];
        arr[level].push(root.val);
        cxOrder(root.left,level+1);
        cxOrder(root.right,level+1);
    }
    cxOrder(root,0)
    return arr;
}
module.exports = {
    levelOrder : levelOrder
};

BM27 按之字形顺序打印二叉树

在这里插入图片描述

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function Print(pRoot)
{
    // write code here
    let arr=[];
    function cxOrder(root,level){
        if(!root) return;
        if(!arr[level]) arr[level]=[];
        arr[level].push(root.val);
        cxOrder(root.left,level+1);
        cxOrder(root.right,level+1);
    }
    cxOrder(pRoot,0);
    for(let i=0;i<arr.length;i++){
        if(i%2!==0){
            arr[i].reverse();
        }
    }
    return arr
}
module.exports = {
    Print : Print
};

BM28 二叉树的最大深度

在这里插入图片描述

/*
 * function TreeNode(x) {
 *   this.val = x;
 *   this.left = null;
 *   this.right = null;
 * }
 */

/**
  * 
  * @param root TreeNode类 
  * @return int整型
  */
function maxDepth( root ) {
    // write code here
    function dfs(root){
        if(!root) return 0;
        let left=dfs(root.left);
        let right=dfs(root.right);
        return Math.max(left+1,right+1);
    }
    return dfs(root);
}
module.exports = {
    maxDepth : maxDepth
};

BM29 二叉树中和为某一值的路径(一)

在这里插入图片描述

/*
 * function TreeNode(x) {
 *   this.val = x;
 *   this.left = null;
 *   this.right = null;
 * }
 */

/**
  * 
  * @param root TreeNode类 
  * @param sum int整型 
  * @return bool布尔型
  */
function hasPathSum( root ,  sum ) {
    // write code here
    if(!root) return false;
    if(root.val===sum&&!root.left&&!root.right) return true;
    return hasPathSum(root.left,sum-root.val)||hasPathSum(root.right,sum-root.val)
}
module.exports = {
    hasPathSum : hasPathSum
};

BM30 二叉搜索树与双向链表

在这里插入图片描述

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function Convert(pRootOfTree)
{
    // write code here
    let head=null,pre=null;
    function midOrder(cur){
        if(!cur) return;
        midOrder(cur.left);
        //递归到最左初始化头节点
        if(pre===null){
            head=cur;
        }else{
            pre.right=cur;
        }
        cur.left=pre;
        pre=cur;
        
        midOrder(cur.right);
    }
    midOrder(pRootOfTree);
    return head;
}
module.exports = {
    Convert : Convert
};

BM31 对称的二叉树

在这里插入图片描述

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function isSymmetrical(pRoot)
{
    // write code here
    if(pRoot===null) return true;
    function compare(node1,node2){
        if(!node1&&!node2) return true;
        if(!node1||!node2)return false;
        if(node1.val!==node2.val) return false;
       return compare(node1.left,node2.right)&&compare(node1.right,node2.left)
    }
    return compare(pRoot.left,pRoot.right);
}
module.exports = {
    isSymmetrical : isSymmetrical
};

BM32 合并二叉树

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

/*
 * function TreeNode(x) {
 *   this.val = x;
 *   this.left = null;
 *   this.right = null;
 * }
 */

/**
 * 
 * @param t1 TreeNode类 
 * @param t2 TreeNode类 
 * @return TreeNode类
 */
function mergeTrees( t1 ,  t2 ) {
    // write code here
    if(t1&&t2){
        t1.val+=t2.val;
        t1.left=mergeTrees(t1.left,t2.left);
        t1.right=mergeTrees(t1.right,t2.right);
    }
    return t1||t2;
}
module.exports = {
    mergeTrees : mergeTrees
};

BM33 二叉树的镜像

在这里插入图片描述

/*
 * function TreeNode(x) {
 *   this.val = x;
 *   this.left = null;
 *   this.right = null;
 * }
 */
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param pRoot TreeNode类 
 * @return TreeNode类
 */
function Mirror( pRoot ) {
    // write code here
    if(!pRoot) return;
    let t=pRoot.right;
    pRoot.right=Mirror(pRoot.left);
    pRoot.left=Mirror(t);
    return pRoot;
}
module.exports = {
    Mirror : Mirror
};

BM34 判断是不是二叉搜索树

在这里插入图片描述

/*
 * function TreeNode(x) {
 *   this.val = x;
 *   this.left = null;
 *   this.right = null;
 * }
 */
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param root TreeNode类 
 * @return bool布尔型
 */
function isValidBST( root ) {
    // write code here
    let arr=[];
    function midOrder(root){
        if(!root) return;
        midOrder(root.left);
        arr.push(root.val);
        midOrder(root.right);
    }
    midOrder(root);
    for(let i=0;i<arr.length-1;i++){
        if(arr[i]>arr[i+1])
            return false;
    }
    return true
}
module.exports = {
    isValidBST : isValidBST
};

BM35 判断是不是完全二叉树

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

/*
 * function TreeNode(x) {
 *   this.val = x;
 *   this.left = null;
 *   this.right = null;
 * }
 */
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param root TreeNode类 
 * @return bool布尔型
 */
function isCompleteTree( root ) {
    // write code here
    let arr=[];
    arr.push(root);
    let end=false;
    while(arr.length){
        let node=arr.shift();
        if(!node) end=true;
        else{
            //如果已经碰到一次空了 arr还有长度 
            if(arr.length&&end) return false
            arr.push(node.left);
            arr.push(node.right);
        }
    }
    return true;
}
module.exports = {
    isCompleteTree : isCompleteTree
};

BM36 判断是不是平衡二叉树

在这里插入图片描述

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function IsBalanced_Solution(pRoot)
{
    // write code here
    if(pRoot===null) return true;
    //判断左右子树的深度差值
    if(Math.abs(depth(pRoot.left)-depth(pRoot.right))>1) return false;
    //递归判断左右子树是否为平衡二叉树
    return IsBalanced_Solution(pRoot.left)&&IsBalanced_Solution(pRoot.right)
}
function depth(node){
    if(node===null){return 0};
    let left=depth(node.left);
    let right=depth(node.right);
    return Math.max(left,right)+1
}
module.exports = {
    IsBalanced_Solution : IsBalanced_Solution
};

BM37 二叉搜索树的最近公共祖先

在这里插入图片描述

/*
 * function TreeNode(x) {
 *   this.val = x;
 *   this.left = null;
 *   this.right = null;
 * }　
 */
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param root TreeNode类 
 * @param p int整型 
 * @param q int整型 
 * @return int整型
 */
function lowestCommonAncestor( root ,  p ,  q ) {
    // write code here
    if(!root) return null;
        //如果俩值都小于根节点，说明祖先在左子树一侧
    if(p<root.val&&q<root.val)
        return lowestCommonAncestor(root.left,p,q);
        //如果俩值都大于根节点，说明祖先在右子树一侧
    else if(p>root.val&&q>root.val)
        return lowestCommonAncestor(root.right,p,q);
        //否则，在两个值中间，或者等于其中的一个值
    else
        return root.val;
}
module.exports = {
    lowestCommonAncestor : lowestCommonAncestor
};

BM38 在二叉树中找到两个节点的最近公共祖先在这里插入图片描述

在这里插入图片描述

/*
 * function TreeNode(x) {
 *   this.val = x;
 *   this.left = null;
 *   this.right = null;
 * }
 */

/**
 * 
 * @param root TreeNode类 
 * @param o1 int整型 
 * @param o2 int整型 
 * @return int整型
 */
function lowestCommonAncestor( root ,  o1 ,  o2 ) {
    // write code here
    if(!root) return null;
    //如果p或q为根节点，则p或q为最近公共祖先
    if(root.val===o1||root.val===o2) return root.val;
    //在左子树寻找q和p的最近公共祖先
    let left=lowestCommonAncestor(root.left,o1,o2);
    //在右子树寻找q和p的最近公共祖先
    let right=lowestCommonAncestor(root.right,o1,o2);
    //如果p和q分属两侧，则根节点为最近公共祖先
    if(left!==null&&right!==null) return root.val;
    //如果左子树有值，则最近公共祖先在左子树，否则，在有子树
    return left!==null?left:right;
    
}

module.exports = {
    lowestCommonAncestor : lowestCommonAncestor
};

BM40 重建二叉树

在这里插入图片描述

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function reConstructBinaryTree(pre, vin)
{
    // write code here
    if(!pre.length||!vin.length){
        return null;
    }
    let root=new TreeNode(pre.shift());
    let index=vin.indexOf(root.val);
    
    root.left=reConstructBinaryTree(pre, vin.slice(0,index));
    root.right=reConstructBinaryTree(pre, vin.slice(index+1,vin.length));
    
    return root;
}
module.exports = {
    reConstructBinaryTree : reConstructBinaryTree
};

BM41 输出二叉树的右视图

在这里插入图片描述

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 * 求二叉树的右视图
 * @param xianxu int整型一维数组 先序遍历
 * @param zhongxu int整型一维数组 中序遍历
 * @return int整型一维数组
 */
function solve( xianxu ,  zhongxu ) {
    let level = 0; //表示树的深度
    let res = [];
    function rebuild(xianxu, zhongxu, level, res) {
        if(xianxu.length === 0) return null;
        const root = xianxu[0];
        const index = zhongxu.findIndex(node => node === root)
        //左子树的先序遍历结果
        const leftNodePreOrder = xianxu.slice(1, index + 1);
        //左子树的中序遍历结果
        const leftNodeInOrder = zhongxu.slice(0, index);
        //右子树的先序遍历结果
        const rightNodePreOrder = xianxu.slice(index + 1);
        //右子树的中序遍历结果
        const rightNodeInOrder = zhongxu.slice(index + 1);
        
        rebuild(leftNodePreOrder, leftNodeInOrder, level + 1, res);
        rebuild(rightNodePreOrder, rightNodeInOrder, level + 1, res);
        
        //记录下每一层的
        res[level] = root;
    }
    
    rebuild(xianxu, zhongxu, level, res);
    
    return res;
}
module.exports = {
    solve : solve
};
无响应乱码元素
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JS实现的二叉树算法完整实例
10-20
主要介绍了JS实现的二叉树算法,结合完整实例形式分析了基于JS定义、创建二叉树及常用的各种遍历、访问二叉树操作技巧,需要的朋友可以参考下
js关于二叉树的算法题大全
qq_41402809的博客
09-06 303
js关于二叉树的算法题大全 创建二叉搜索树 插入节点 中序遍历、后序遍历 DFS、BFS 最大值，最小值 寻找指定值 并返回路径 寻找二叉树是否有一条路径 其和为指定值 二叉树深度 之字形打印二叉树 层次打印二叉树 **树的节点的定义** class Node { constructor(key){ this.key = key; this.left = null; this.right = null }; } //////////////
javascript算法（二叉树算法）
___KAKU的博客
02-08 1363
前景：js多应用于前端页面的一些交互，但是现在也用js实现服务器上的开发，甚至强于java或者是c++,吸取了前面技术的优点。   另外，js现在也用于移动端的开发，并且能够很好的兼容IOS和Android两种系统，带来了很大的方便，性价比较高。一、那么为什么学习算法？   程序=算法+数据结构。好的算法 能够给用户带来一种良好的用户体验。提高产品的性能，带来更高的价值。二、排序二叉树算法的重要性...
二叉树_算法总结_JavaScript
sbc_sbc的博客
08-14 296
二叉树相关算法 二叉树的前中后序遍历： 前序遍历：根 左 右 中序遍历：左 根 右 后序遍历：左 右 根 递归写法（前序遍历）（空间复杂度与系统堆栈有关，系统栈需要记住每个节点的值，所以空间复杂度为O(n)。时间复杂度应该为O(n)）： var preorderTraversal = function(root) { var res = []; var preorderTraversalNode = (node)=>{ if(node == n...
js二叉树的基本算法操作
ab31ab的博客
06-10 870
二叉树 二叉树的基本实现，删除两个节点的地方还是不太熟，还要好好学习一下才行 数据结构里关于链和树这块，最开始看视频的时候最好跟着老师敲一次代码，对于不会举一反三的码畜来说会更好的知道对象的属性是个啥。我一度搞不定树的两条边怎么表示的，哈哈 1.封装二叉树 function BinarySearchTree() { function node(key) { ...
JavaScript数据结构和算法之二叉树详解
10-24
主要介绍了JavaScript数据结构和算法之二叉树详解,本文讲解了二叉树的概念、二叉树的特点、二叉树节点的定义、查找最大和最小值等内容,需要的朋友可以参考下
JavaScript数据结构之二叉树的删除算法示例
10-20
在JavaScript中，二叉树是一种重要的数据结构，用于组织和操作...对于想要深入学习JavaScript数据结构和算法的读者，可以查阅相关的技术资料，如《JavaScript数据结构与算法技巧总结》等专题，以进一步提升自己的技能。
JavaScript数据结构之二叉树的查找算法示例
10-20
主要介绍了JavaScript数据结构之二叉树的查找算法,结合具体实例形式分析了javascript针对二叉树节点最小值、最大值的相关查找操作实现技巧,需要的朋友可以参考下
JavaScript数据结构之二叉树的计数算法示例
10-20
主要介绍了JavaScript数据结构之二叉树的计数算法,结合具体实例形式分析了javascript二叉树记录更新次数的原理与操作技巧,需要的朋友可以参考下
JavaScript数据结构之二叉树的遍历算法示例
10-20
本篇文章将详细介绍二叉树的三种遍历方法：中序遍历、先序遍历和后序遍历，并通过具体的JavaScript代码示例来阐述这些算法。 1. **中序遍历（In-Order Traversal）**： 中序遍历通常按照“左-根-右”的顺序访问...
javaScript 二叉树 若干算法题分析（上
hl199626的博客
06-16 164
链、表、树、图……树在算法领域，可谓独霸一方，与之相关的问题千奇百怪。二叉树又是其中的典范，能延伸到 堆、AVL树、SB树、红黑树等等结构。 走进这个世界，慢慢了解，你会收获到很多。本文先来一些简单的算法题，带你了解二叉树。二叉树前序遍历（先序遍历） 给你二叉树的根节点 root ，返回它节点值的 前序 遍历。数据范围：二叉树的节点数量满足0≤ n ≤100 ，二叉树节点的值满足1≤ val ≤100 ，树的各节点的值各不相同思路： 根据递归的时机，可以很轻松知道 先序中序后序的切入点。 求二叉树的层序
javaScript 二叉树 若干算法题分析（下）
hl199626的博客
06-17 206
上文讲到二叉树的一些遍历和高度，今天讲讲二叉树的路径与价值问题。1、二叉树中和为某一值的路径给定一个二叉树root和一个值 sum ，判断是否有从根节点到叶子节点的节点值之和等于 sum 的路径。1.该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点2.叶子节点是指没有子节点的节点3.路径只能从父节点到子节点，不能从子节点到父节点4.总节点数目为n例如： 思路：必须从根节点到每个叶节点，和值进行比较，如果存在某个分支和值相等，保存到最终结果。 2、（较难）二叉树中最大路径和二叉树里面的路径
一种思路解决二叉树的普遍问题（JavaScript）面试必看
qq_39897978的博客
12-09 204
1、先序遍历 //二叉树遍历 //先序遍历 const preOrderTraversal = function(root){ let res = [] function traversal (root){ if(root!==null){ res.push(root.val) traversal(root.left) traversal(root.right) } } traversal(root) return res }
Javascript实现二叉树算法
任性的wo的博客
12-09 327
目录 二叉树算法原理及代码实现 二叉树定义 中序遍历 前序遍历 后序遍历 二叉树节点查找 二叉树叶子节点的删除原理及实现 二叉树算法原理及代码实现 二叉树定义 8：二叉树的根节点 4、7、13：二叉树的叶子节点 其他：中间节点 排序二叉树： 特点：节点的左子节点小于当前节点，节点的右子节点大于当前节点 代码实现： <!DOCTYPE html&gt...
html 二叉树模式,重建二叉树.html
weixin_36041939的博客
06-05 91
Documentfunction TreeNode(x) {this.val = x;this.left = null;this.right = null;}var pre = [1,2,4,7,3,5,6,8]var vin = [4,7,2,1,5,3,8,6]function reConstructBinaryTree(pre, vin) {// write code hereif(pre....
javascript数据结构及实现二叉树算法
韩潇的博客
09-08 2856
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
JS一些基础算法题解析
liu_pen的博客
05-13 349
本文列举了13个JS 一些基础算法题，翻转字符串、计算阶乘等。
js 前端算法------大厂面试笔试题(二叉树的深度优先遍历)
csdn_smartyang的博客
12-29 1124
今日分享的是二叉树的深度优先遍历 1.二叉树深度遍历通俗易懂的来讲就是优先往深处走，就是看有没子节点，从左到右比如从1 开始遍历，从左往右走，有没有子节点，有是2，就再看2遍历完了再看5以此类推 2.那么二叉树和栈的结合就是利用栈的后进先出的特点，从右往左把子节点放在栈中依次取出遍历 3.用js实现 //模拟一个二叉树 let tree={ value:1, childleft:{ value:2, childleft:{ value
前端常见算法面试题之 - 重建二叉树[JavaScript解法]
吴潇雄的博客
11-01 1636
前端常见算法面试题之 - 重建二叉树[JavaScript解法]题目描述实现思路代码实现 题目描述 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列[1,2,4,7,3,5,6,8]，和中序遍历序列[4,7,2,1,5,3,8,6]，则重建二叉树并返回 实现思路 根据前序遍历和中序遍历的定义，我们不难发先输入数据可...
写前端常见的面试算法题和案例
最新发布
05-25
前端面试中常见的算法题和案例有： ...10. 实现一个二叉树的遍历：用 JavaScript 实现一个二叉树的先序遍历、中序遍历、后序遍历。 以上是一些常见的前端面试算法题和案例，掌握它们可以帮助你更好地应对前端面试。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值