JS数据结构第六篇 --- 二叉树力扣练习题

递归+迭代两种实现方式：

/** 反转二叉树
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {TreeNode}
 * 第一种方式迭代
 * 执行用时 :72 ms, 在所有 JavaScript 提交中击败了87.29%的用户
 * 内存消耗 :33.8 M, 在所有 JavaScript 提交中击败了24.26%的用户
 */
var invertTree = function(root) {
    if (!root) return root;

    var arr = [root];

    while(arr.length){
        var current = arr.shift(); //取出节点，交换左右子节点
        var temp = current.right;
        current.right = current.left;
        current.left = temp;

        //将左右子节点push到数组中
        if (current.right) arr.push(current.right);
        if (current.left) arr.push(current.left);
    }
    return root;
};

/**
 * 第二种方式递归
 * @param root
 * @returns {*}
 * 执行用时 :64 ms, 在所有 JavaScript 提交中击败了98.02%的用户
 * 内存消耗 :33.6 MB, 在所有 JavaScript 提交中击败了53.85%的用户
 */
var invertTree2 = function(root) {
    if (!root) return root;

    var temp = invertTree(root.left);
    root.left = invertTree(root.right);
    root.right = temp;
    return root;
};

2、第144题：二叉树的前序遍历

初看这个题目描述，没怎么看懂，特别是控制台的输入输出

比如输入：[3, 9, 20, 15, 7, 88, 16, 2, 19, 13, 26, 11]

输出是：[3,9,15,2,19,7,13,26,20,88,11,16]

一时没弄明白，后面琢磨了一下，才发现力扣这里的输入是按照输入顺序来组成树的，而不是按输入的大小组成树。

即上面这个输入的数字列表，做成二叉树图为：

如果输入的数字列表中带有null, 则null所在的子树空不占位，

比如输入：[3, 9, null, 20, 15, 7, 88, 16, 2, 19, null, 13, 26, 11]

输出为：[3, 9, 20, 7, 19, 88, 13, 26, 15, 16, 11, 2]

输入数字的二叉树图为：

理解了力扣题目的输入输出逻辑，咱们再做题，二叉树的前序遍历递归+迭代方式code (先根节点，再左子节点，再右子节点)：

/**  前序遍历规则：先根节点，再左子节点，再右子节点
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/** 第一种方式：递归
 * @param {TreeNode} root
 * @return {number[]}
 执行用时 :72 ms, 在所有 JavaScript 提交中击败了86.38%的用户
 内存消耗 :33.8 MB, 在所有 JavaScript 提交中击败了17.62%的用户
 */
var preorderTraversal = function(root) {
    var arr = [];
    recusion(root, arr);
    return arr;

    function recusion(root){
        if (!root) return;
        //前序遍历，先根节点，再左节点，再右节点
        arr.push(root.val);
        recusion(root.left, arr);
        recusion(root.right, arr);
    }
};

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

/**
 * 第二种方式：迭代
 * 执行用时 :76 ms, 在所有 JavaScript 提交中击败70.96%的用户
 * 内存消耗 :33.6 MB, 在所有 JavaScript 提交中击败了60.62%的用户
 */
var preorderForeach = function(root) {
    var res = [];
    if (!root) return res;
    var arr = [root];
    while(arr.length){
        //借助于栈的特性：后进先出
        var current = arr.pop();
        res.push(current.val);

        //先将右节点压入栈底，因为右节点后取值
        if (current.right){
            arr.push(current.right);
        }
        //左节点先取值，压入栈顶
        if (current.left){
            arr.push(current.left);
        }
    }
    return res;
};

3、第94题：二叉树的中序遍历

二叉树中序遍历，先找到最左边的左子节点，从这里开始，然后左子节点，再根节点，再右子节点：

/** 中序遍历：从小到大，从做左边的左子节点，最后一个是右边的右子节点
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/** 中序遍历：按照从小到大排序，先找到最左边的子节点，也就是最小值，再依次往上走父节点，右节点
 * @param {TreeNode} root
 * @return {number[]}
 * 第一种方式：递归
 * 执行用时 :64 ms, 在所有 JavaScript 提交中击败了97.67%的用户
 * 内存消耗 :33.8 MB, 在所有 JavaScript 提交中击败20.52%的用户
 */
var inorderTraversal = function(root) {
    const res = [];
    if (!root) return res;
    recusion(root);
    return res;

    function recusion(root){
        if (!root) return;

        recusion(root.left);
        res.push(root.val);
        recusion(root.right);
    }
};

/**
 * 第二种方式：迭代
 * 执行用时 :68 ms, 在所有 JavaScript 提交中击败了94.67%的用户
 * 内存消耗 33.7 MB, 在所有 JavaScript 提交中击败了30.60%的用户
 */
var inorderTraversal2 = function(root) {
    const res = [];
    if (!root) return res;

    const arr = [];
    while (root || arr.length){
        while(root){
            arr.push(root);
            root = root.left;
        }
        root = arr.pop();  //最后一个左节点
        res.push(root.val);
        root = root.right;
    }
    return res;
};

4、第145题：二叉树的后序遍历

后序遍历的规则：先叶子节点，再根节点；即先左子节点，再右子节点，再根节点。

/** 后序遍历规则：先叶子节点，叶子节点先左后右，再根节点
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/** 后序遍历：先叶子节点，再左子树，再右子树
 * 第一种方式：递归
 * @param {TreeNode} root
 * @return {number[]}
 * 执行用时 :76 ms, 在所有 JavaScript 提交中击败了68.85%的用户
 * 内存消耗 :33.9 MB, 在所有 JavaScript 提交中击败了9.84%的用户
 */
var postorderTraversal = function(root) {
    var res = [];
    if (!root) return res;
    recusion(root);
    return res;

    function recusion(root){
        if (!root) return;

        recusion(root.left);
        recusion(root.right);
        res.push(root.val);
    }
};

/**
 * 第二种方式：迭代
 * @param root
 * @returns {Array}
 * 执行用时 :80 ms, 在所有 JavaScript 提交中击败了48.15%的用户
 * 内存消耗 :33.7 MB, 在所有 JavaScript 提交中击败25.41%的用户
 */
var postorderTraversal = function(root) {
    var res = [];
    if (!root) return res;

    var arr = [root];
    while (arr.length){
        var current = arr.pop();
        res.unshift(current.val);

        if (current.left){
            arr.push(current.left);
        }
        if (current.right){
            arr.push(current.right);
        }
    }
    return res;
};

5、第102题：二叉树的层级遍历

递归层级遍历和前序遍历差不多，迭代方式层级遍历有点绕

/** 层次遍历
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 * 给定二叉树: [3,9,20,null,null,15,7],
    3
  /  9  20
   /   15   7
 返回其层次遍历结果：
 [
 [3],
 [9,20],
 [15,7]
 ]

 */
/** 层次遍历，第一种方式：递归， 和前序遍历差不多
 * @param {TreeNode} root
 * @return {number[][]}
 * 执行用时 :84 ms, 在所有 JavaScript 提交中击败了55.19%的用户
 * 内存消耗 :34.6 M, 在所有 JavaScript 提交中击败了53.23%的用户
 */
var levelOrder = function(root) {
    var res = [];
    if (!root) return res;
    recusion(root, 0);
    return res;

    function recusion(root, level){

        if (!root) return;

        if (res[level]){
            res[level].push(root.val);
        }
        else{
            res[level] = [root.val];
        }

        if (root.left){
            recusion(root.left, level+1);
        }
        if (root.right){
            recusion(root.right, level+1);
        }
    }
};

/**
 * 第二种层序遍历：迭代
 * @param root
 * @returns {Array}
 * 执行用时 :80 ms, 在所有 JavaScript 提交中击败了73.64%的用户
 * 内存消耗 :34.8 MB, 在所有 JavaScript 提交中击败了28.36%的用户
 */
var levelOrder2 = function(root) {
    var res = [];
    if (!root) return res;

    var queue = [root];
    while(queue.length){

        //内循环把这一层级的所有节点都放入tempQueue队列中，每一个外循环则是每一层级重新开始
        var arr = [], tempQueue = [];
        while(queue.length){
            var current = queue.shift();
            arr.push(current.val);

            if (current.left){
                tempQueue.push(current.left);
            }
            if (current.right){
                tempQueue.push(current.right);
            }
            console.log("tempQueue.length: ", tempQueue.length, ", queue.length: ", queue.length);
            console.log("-----------")
        }
        res.push(arr);
        queue = tempQueue;

        console.log(JSON.stringify(res))
        console.log("***************************")
    }
    return res;
};

// function TreeNode(val){
//     this.val = val;
//     this.left = this.right = null;
// }
//
// var node = new TreeNode(23);
// node.left = new TreeNode(16);
// node.right = new TreeNode(45);
// node.left.left = new TreeNode(3);
// node.left.right = new TreeNode(22);
// node.right = new TreeNode(45);
// node.right.left = new TreeNode(37);
// node.right.right = new TreeNode(99);
// console.log(levelOrder2(node));

6、第104题：二叉树的最大深度

二叉树的最大深度和求二叉树的层级遍历差不多

/**  二叉树的最大深度
 * 给定一个二叉树，找出其最大深度。
 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
 说明: 叶子节点是指没有子节点的节点。
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 * 第一种方式：递归
 * 执行用时 :96 ms, 在所有 JavaScript 提交中击败了51.18%的用户
 * 内存消耗 :37.1 MB, 在所有 JavaScript 提交中击败了40.00%的用户
 */
var maxDepth = function(root) {
    if (!root) return 0;

    var maxLevel = 1;
    recusion(root, 1);
    return maxLevel;

    function recusion(root, level){

        if (level > maxLevel) {
            maxLevel = level;
        }

        if (root.left){
            recusion(root.left, level+1);
        }
        if (root.right){
            recusion(root.right, level+1);
        }
    }
};

/**
 * 第二种：迭代
 * @param root
 * @returns {number}
 执行用时 :88 ms, 在所有 JavaScript 提交中击败了81.91%的用户
 内存消耗 :36.8 MB, 在所有 JavaScript 提交中击败了93.61%的用户
 */
var maxDepth2 = function(root) {
    if (!root) return 0;

    var level = 0, queue = [root];
    while(queue.length){
        var tempQueue = [];
        //内循环，每次把整个层级节点遍历完， tempQueue存储每个层级的所有节点
        while(queue.length){
            var current = queue.shift();

            if (current.left){
                tempQueue.push(current.left);
            }
            if (current.right){
                tempQueue.push(current.right)
            }
        }
        level++;
        queue = tempQueue;
    }
    return level;
};

// function TreeNode(val){
//     this.val = val;
//     this.left = this.right = null;
// }
//
// var node = new TreeNode(3);
// node.left = new TreeNode(9);
// node.right = new TreeNode(20);
// node.right.left = new TreeNode(15);
// node.right.right = new TreeNode(7);
// console.log(maxDepth(node))

7、第662题：二叉树最大宽度

这个题和二叉树层级遍历/求最大深度类似，但比层级遍历要绕要麻烦点。

迭代方式：迭代遍历，用2个栈，一个用来存储每一层级的节点，另一个栈用来存储每个节点的编号。

对节点进行编号，规则：根节点编号从0开始，左子节点编号 = 父节点编号 * 2 + 1，右子节点编号 = 父节点编号 * 2 + 2；

递归方式：规则同迭代方式，也是对节点进行编号

如图：

/**
 * 给定一个二叉树，编写一个函数来获取这个树的最大宽度。树的宽度是所有层中的最大宽度。这个二叉树与满二叉树（full binary tree）结构相同，但一些节点为空。
 每一层的宽度被定义为两个端点（该层最左和最右的非空节点，两端点间的null节点也计入长度）之间的长度。

 示例 1:
 输入:
       1
    /      3     2
  / \      5   3     9
 输出: 4
 解释: 最大值出现在树的第 3 层，宽度为 4 (5,3,null,9)。

 示例 2:
 输入:
      1
     /
    3
  /  5   3
 输出: 2
 解释: 最大值出现在树的第 3 层，宽度为 2 (5,3)。

 示例 3:
 输入:
     1
    /    3   2
  /
 5
 输出: 2
 解释: 最大值出现在树的第 2 层，宽度为 2 (3,2)。

 示例 4:
 输入:
          1
        /        3   2
     /         5       9
   /           6           7
 输出: 8
 解释: 最大值出现在树的第 4 层，宽度为 8 (6,null,null,null,null,null,null,7)。

 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 * 第一种方式：递归
 * 执行用时 :84 ms, 在所有 JavaScript 提交中击败了100.00%的用户
 * 内存消耗 :36.7 MB, 在所有 JavaScript 提交中击败了37.50%的用户
 */
var widthOfBinaryTree = function(root) {

    if (!root) return 0;

    //queue存储节点，numArr存储节点对应的节点编号位置
    var queue = [root], numArr = [0], maxWidth = 1;

    while (queue.length) {
        //tempQueue存储每一层级所有的节点，tempNumArr存储对应节点的编号位置
        var tempQueue = [], tempNumArr = [];
        while (queue.length) {
            var node = queue.shift(), num = numArr.shift(); //取出栈底节点和编号

            if (node.left) {
                tempQueue.push(node.left);
                tempNumArr.push(num * 2 + 1);
            }
            if (node.right) {
                tempQueue.push(node.right);
                tempNumArr.push(num * 2 + 2);
            }
        }
        var tempWidth = 0;
        //计算tempNumArr中存储的这一层的宽度, 最后一位元素存储这一层级最大宽度的编号
        if (tempNumArr.length) {
            tempWidth = tempNumArr[tempNumArr.length - 1] - tempNumArr[0] + 1;
        }
        if (tempWidth > maxWidth) {
            maxWidth = tempWidth;  //更新最大宽度
        }

        //开始下一个层级的宽度计算
        queue = tempQueue;
        numArr = tempNumArr;
    }

    return maxWidth;
};

/**
 * 第二种递归方式：
 * @param root
 * @returns {number}
 * 执行用时 :84 ms, 在所有 JavaScript 提交中击败了100.00%的用户
 * 内存消耗 :36 MB, 在所有 JavaScript 提交中击败了75.00%的用户
 */
var widthOfBinaryTree2 = function(root) {

    if (!root) return 0;

    var res = [], maxWidth = 1;
    recusion(root, 0, 0);
    return maxWidth;

    function recusion(root, level, num){

        if (res[level]){
            res[level].push(num);
        }
        else{
            res[level] = [num];
        }

        //计算最大宽度
        var tempArr = res[level];
        var tempWidth = tempArr[tempArr.length - 1] - tempArr[0] + 1;
        if (tempWidth > maxWidth) {
            maxWidth = tempWidth;
        }

        if (root.left){
            recusion(root.left, level + 1, num * 2 + 1);
        }
        if (root.right){
            recusion(root.right, level + 1, num * 2 + 2);
        }
    }
};

// function TreeNode(val){
//     this.val = val;
//     this.left = this.right = null;
// }
//
// //[1,1,1,1,null,null,1,1,null,null,1]
// var root = new TreeNode(1);
// root.left = new TreeNode(1);
// root.right = new TreeNode(1);
// root.left.left = new TreeNode(1);
// root.left.right = new TreeNode(3);
// root.right.right = new TreeNode(9);
// console.log(widthOfBinaryTree(root));

原文地址：https://www.cnblogs.com/tandaxia/p/11481462.html

时间： 2024-10-09 11:01:41

JS数据结构第六篇 --- 二叉树力扣练习题的相关文章

6. 蛤蟆的数据结构进阶六之二叉树排序树

6. 蛤蟆的数据结构进阶六之二叉树排序树本篇名言:"有些人因为贪婪,想得更多的东西,却把现在所有的也失掉了. -- 伊索" 关于理论知识已经在上篇中进行描述,这篇我们主要来看下如何是实现二叉排序树. 欢迎转载,转载请标明出处: 1. 二叉排序树的定义二叉排序树(BinarySort Tree)又称二叉查找(搜索)树(Binary Search Tree).其定义为:二叉排序树或者是空树,或者是满足如下性质的二叉树: ①若它的左子树非空,则左子树上所有结点的值均小于根结点的值: ②

JS数据结构第三篇---双向链表和循环链表

一.双向链表在上文<JS数据结构第二篇---链表>中描述的是单向链表.单向链表是指每个节点都存有指向下一个节点的地址,双向链表则是在单向链表的基础上,给每个节点增加一个指向上一个节点的地址.然后头结点的上一个节点,和尾结点的下一个节点都指向null.同时LinkedList类中再增加一个last内部属性,一直指向链表中最后一个节点.结构模拟如图: 同样对外暴露的方法和单向链表一样,只是内部实现稍有变化双向链表完整设计代码: /** * 自定义双向链表:对外公开的方法有 * append(e

【算法练习题】力扣练习题——数组（2）：三数之和

原题说明: 给定一个包含 n 个整数的数组 nums,判断 nums 中是否存在三个元素 a,b,c ,使得 a + b + c = 0 ?找出所有满足条件且不重复的三元组. 注意:答案中不可以包含重复的三元组. 例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4], 满足要求的三元组集合为:[[-1, 0, 1],[-1, -1, 2]] 原题链接:https://leetcode-cn.com/problems/3sum 解法一:基于HashMap的暴力求解参考力扣题

(数据结构第六章)二叉树的顺序存储结构

二叉树的五条性质: 1.在二叉树的第i层上至多有2^(i-1)个节点(i>=1) 2.深度为k的二叉树至多有2^k-1个节点(k>=1) 3.对任何一个二叉树T,如果其终端节点数为n0,度为2的节点数为n2,则n0=n2+1. 证:总结点数n=n0+n1+n2 设分支总数B,n=B+1 B=n1+n2:两式加减即证出. 补充个定义:节点拥有的子树数称为节点的度. 树的度是树内各节点度的最大值. 4.具有n个节点的完全二叉树的深度为floor(log(2)n)+1 5.如果对一颗有n个节点的完全

JS原生第六篇（帅哥）

复习按钮不可用 disabled = "disabled" || true setTimeout 只执行一次 setInterval 执行很多次递归调用 : 函数自己调用自己函数递归调用不提倡用函数名而喜欢用的是 arguments.callee 返回的是正在执行的函数本身逻辑运算符与 && 或 || 非 ! ! > && > || 2&&a

数据结构第六篇——顺序存储结构与链式存储结构的特点

?注:未经博主同意,不得转载. 两者特点: 顺序表的特点是逻辑上相邻的数据元素,物理存储位置也相邻,并且,顺序表的存储空间需要预先分配. 它的优点: (1)方法简单,各种高级语言中都有数组,容易实现. (2)不用为表示节点间的逻辑关系而增加额外的存储开销. (3)顺序表具有按元素序号随机访问的特点. 缺点: (1)在顺序表中做插入.删除操作时,平均移动表中的一半元素,因此对n较大的顺序表效率低. (2)需要预先分配足够大的存储空间,估计过大,可能会导致顺序表后部大量闲置:预先分配过小,又会造成溢

【算法练习题】力扣练习题——数组（6）：在有序数组中查找元素存在的范围

原题说明:给定一个按照升序排列的整数数组 nums,和一个目标值 target.找出给定目标值在数组中的开始位置和结束位置. 你的算法时间复杂度必须是 O(log n) 级别. 如果数组中不存在目标值,返回 [-1, -1]. 原题链接:https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array 题目分析: 这道题目当然也是用二分查找来解题.经过上道题的教训,这次我详细考察了各个

【算法练习题】力扣练习题——数组（4）：下一个排列

原题说明:实现获取下一个排列的函数,算法需要将给定数字序列重新排列成字典序中下一个更大的排列. 如果不存在下一个更大的排列,则将数字重新排列成最小的排列(即升序排列). 必须原地修改,只允许使用额外常数空间. 以下是一些例子,输入位于左侧列,其相应输出位于右侧列.1,2,3 → 1,3,23,2,1 → 1,2,31,1,5 → 1,5,1 原题链接:https://leetcode-cn.com/problems/next-permutation 题意分析: 先给出几个实例 1)123 → 1

[力扣]144_二叉树的前序遍历

/* 给定一个二叉树,返回它的前序遍历. 示例: 输入: [1,null,2,3] 1 2 / 3 输出: [1,2,3] 进阶: 递归算法很简单,你可以通过迭代算法完成吗? 来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/binary-tree-preorder-traversal 著作权归领扣网络所有.商业转载请联系官方授权,非商业转载请注明出处. */ 方法一:常规递归方式,用C语言实现(根左右) 代码实现: /** * Note