leetcode面试题之二叉树

已于 2022-05-01 23:12:26 修改
阅读量893 收藏
点赞数
分类专栏： LeetCode 文章标签： leetcode javascript
于 2022-04-21 23:11:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/mys_mys/article/details/124334386
版权

文章目录

p101 对称二叉树

/**
 * 101. 对称二叉树
 * 给你一个二叉树的根节点 root ， 检查它是否轴对称。
 * https://leetcode-cn.com/problems/symmetric-tree/
 */
/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {boolean}
 * 递归
 */
var isSymmetric = function (root) {
    if (root === null) {
        return true;
    }
    return dfs(root.left, root.right);
};

function dfs(left, right) {
    if (left === null && right === null) {
        return true;
    }
    if (left === null || right === null) {
        return false;
    }
    //注意：此处需要用 !==
    if (left.val !== right.val) {
        return false;
    }
    return dfs(left.left, right.right) && dfs(left.right, right.left);
}


/**
 * @param {TreeNode} root
 * @return {boolean}
 * 队列
 */
var isSymmetric2 = function (root) {
    if (root === null) {
        return true;
    }
    let queue = [];
    queue.push(root);
    while (queue.length > 0) {
        let n = queue.length;
        for (let i = 0; i < n; i ++) {
            let node = queue.shift();
            if (node.left === null && node.right)
            if (node.left && node.right) {

            }
        }
    }
    return dfs(root.left, root.right);
};

p102 二叉树层次遍历

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[][]}
 */
var levelOrder = function (root) {
    let res = [], queue = [];
    queue.push(root);
    if (root === null) {
        return res;
    }

    //遍历队列，每次遍历都是一层，该层遍历完之后加入res
    while (queue.length !== 0) {
        var length = queue.length;
        //存放每一层的节点
        let level = [];
        for (let i = 0; i < length; i++) {
            //遍历当前节点，将val保存到level
            let node = queue.shift();
            level.push(node.val);
            //存放当前层下一层的节点
            node.left && queue.push(node.left);
            node.right && queue.push(node.right);
        }
        //当层遍历完成，结果放入数组
        res.push(level);
    }
    return res;
};

function TreeNode(val, left, right) {
    this.val = (val === undefined ? 0 : val)
    this.left = (left === undefined ? null : left)
    this.right = (right === undefined ? null : right)
}

p103 之字形层次遍历

设一个flag，偶数反转

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[][]}
 */
var zigzagLevelOrder = function(root) {
    let res = [], queue = [];
    queue.push(root);
    if (root === null) {
        return res;
    }

    let flag = 0;
    while (queue.length > 0) {
        let n = queue.length;
        let level = [];
        flag++;
        for (let i = 0; i < n; i++) {
            let node = queue.shift();
            level.push(node.val);

            node.left && queue.push(node.left);
            node.right && queue.push(node.right);
        }
        //flag记录遍历层次，偶数层level值反转
        if (flag % 2 === 0) {
            level.reverse();
        }
        res.push(level);
    }
    return res;
};

p104 二叉树的最大深度

/**
 * 104. 二叉树的最大深度
 * 给定一个二叉树，找出其最大深度。
 * 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
 * https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/
 */
/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var maxDepth = function(root) {
    let queue = [], count = 0;
    if (root === null) {
        return 0;
    }
    queue.push(root);
    while (queue.length > 0) {
        let n = queue.length;
        count ++;
        for (let i = 0; i < n; i ++) {
            let node = queue.shift();
            node.left && queue.push(node.left);
            node.right && queue.push(node.right);
        }
    }
    return count;
};

p105 从前序与中序遍历构造二叉树

在这里插入图片描述

/**
 * 105. 从前序与中序遍历序列构造二叉树
 * 给定两个整数数组preorder 和 inorder，其中preorder 是二叉树的先序遍历，
 * inorder是同一棵树的中序遍历，请构造二叉树并返回其根节点
 * https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
 */
/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {number[]} preorder
 * @param {number[]} inorder
 * @return {TreeNode}
 */
var buildTree = function(preorder, inorder) {
    //pos:用于将树的中序遍历 位置与值 相映射，即哈希表，查找为O(1)
    let pos = {}
    for (let i = 0; i < inorder.length; i ++) {
        pos[inorder[i]] = i
    }
    return build(0, preorder.length - 1, 0, inorder.length - 1)

    // pl pr:前序的左右端点位置 il ir:中序的左右端点位置
    function build(pl, pr, il, ir) {
        //初始条件判断
        if (pl > pr) {
            return null
        }
        //以前序的最左端点为根节点,建立树
        let root = new TreeNode(preorder[pl])
        // k:根节点的位置
        let k = pos[root.val]
        //建立左子树(画图求端点表达式)
        root.left = build(pl + 1, pl + k - il, il, k - 1)
        //建立右子树
        root.right = build(pl + k - il + 1, pr, k + 1, ir)
        return root;
    }
};

树的哈希表映射：

let pos = {}
    for (let i = 0; i < inorder.length; i ++) {
        pos[inorder[i]] = i
    }

p108 将有序数组转换为二叉搜索树

/**
 * 题目描述：
 * 108. 将有序数组转换为二叉搜索树
 * 给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。
 * 高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。
 * https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/
 */

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {number[]} nums
 * @return {TreeNode}
 */
var sortedArrayToBST = function (nums) {
    return build(0, nums.length - 1)

    function build(l, r) {
        //初始条件判断
        if (l > r) {
            return null
        }
        //以中间节点为根节点，建立二叉搜索树
        let mid = l + r >> 1
        let root = new TreeNode(nums[mid])
        //建立左子树
        root.left = build(l, mid - 1)
        //建立右子树
        root.right = build(mid + 1, r)
        return root
    }
};

p116 填充每个节点的下一个右侧节点指针

/**
 * 题目描述：
 * 116. 填充每个节点的下一个右侧节点指针
 * 给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
 * struct Node {
 *   int val;
 *   Node *left;
 *   Node *right;
 *   Node *next;
 * }
 * 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
 * 初始状态下，所有next 指针都被设置为 NULL。
 * https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node/
 */

/**
 * // Definition for a Node.
 * function Node(val, left, right, next) {
 *    this.val = val === undefined ? null : val;
 *    this.left = left === undefined ? null : left;
 *    this.right = right === undefined ? null : right;
 *    this.next = next === undefined ? null : next;
 * };
 */

/**
 * @param {Node} root
 * @return {Node}
 * 思路：
 * 层次遍历，queue，每层将节点串联起来
 */
var connect = function(root) {
    let queue = []
    queue.push(root)
    if (root === null) {
        return root
    }
    while (queue.length > 0) {
        let n = queue.length
        //每层遍历时将该层的节点串联起来
        let node = queue[0]
        for (let i = 1; i < n; i ++) {
            node.next = queue[i]
            node = queue[i]
        }
        //遍历该层，将该层的左右节点放入queue
        for (let i = 0; i < n; i ++) {
            node = queue.shift()
            node.left && queue.push(node.left)
            node.right && queue.push(node.right)
        }
    }
    return root
};

p572 另一棵树的子树

/**
 * 572. 另一棵树的子树
 * 给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。
 * 二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。
 * https://leetcode-cn.com/problems/subtree-of-another-tree/
 */
/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} s
 * @param {TreeNode} t
 * @return {boolean}
 * 思路：树哈希
 * 如果两棵树形态相同，哈希值相同；形态不同，哈希值大概率不同
 * (树哈希和字符串哈希一般不考虑冲突，因为冲突的概率非常小)
 */
var isSubtree = function(s, t) {
    //P Q:取一个较大的质数 MOD:用于取模，保证范围
    let P = 131, Q = 159, MOD = 1e4 + 7
    //S T:s t的哈希值(均设置为正数)，子树t初始化为-1
    let S, T = -1
    //res:返回结果，默认false
    let res = false
    //求子树t的哈希值
    T = dfs(t)
    //如果t的哈希值和s的哈希值相同，说明t是s的子树
    if (T === dfs(s)) {
        res = true
    }
    return res

    //求以root为根节点的树的哈希值
    function dfs(root) {
        //如果根节点为空，随便返回一个不为0的值
        if (root === null) {
            return 12345
        }
        //求左子树、右子树的哈希值
        let left = dfs(root.left), right = dfs(root.right)
        //x:root根节点的哈希值
        let x = (root.val % MOD + MOD) % MOD
        //如果s的左右子树中如果有与t子树相同哈希值的，返回true
        if (left === T || right === T) {
            res = true
        }
        //返回：以root为根节点的树的哈希值
        return (x + left * P % MOD + right * Q) % MOD
    }
};

剑指offer

o33 二叉搜索树的后序遍历序列

/**
 * 剑指 Offer 33. 二叉搜索树的后序遍历序列
 * 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true，否则返回 false。假设输入的数组的任意两个数字都互不相同。
 * https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-hou-xu-bian-li-xu-lie-lcof/
 */
/**
 * @param {number[]} postorder
 * @return {boolean}
 */
var verifyPostorder = function(postorder) {
  let seq = postorder
  return dfs(0, seq.length - 1)

  // l r当前序列的左右边界
  function dfs(l, r) {
    if (l >= r) return true
    let root = seq[r] // 根节点
    // 遍历找右子树的第一个节点
    let k = l
    while (k < r && seq[k] < root) k ++ // 此时k为右子树第一个节点
    // 遍历右子树
    for (let i = k; i < r; i ++) {
      // 如果右子树节点 < 根节点，返回false
      if (seq[i] < root) return false
    }
    // 继续递归左子树，右子树
    return dfs(l, k - 1) && dfs(k, r - 1)
  }
};

let num = [7, 4, 6, 5]
console.log(verifyPostorder(num))

o34 二叉树中和为某一值的路径

/**
 * 剑指 Offer 34. 二叉树中和为某一值的路径
 * 给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
 * https://leetcode-cn.com/problems/er-cha-shu-zhong-he-wei-mou-yi-zhi-de-lu-jing-lcof/
 */
/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} target
 * @return {number[][]}
 */
var pathSum = function(root, target) {
  let res = [], path = []
  dfs(root, target)
  return res

  function dfs(root, sum) {
    // 如果当前节点为空，则不是叶子结点
    if (! root) return
    path.push(root.val)
    sum -= root.val // 当sum减到0时，则为所求路径

    // 如果当前节点是叶子结点，同时sum=0，该路径加入到res中
    // 注意此处要用：path.slice()，以创建一个新数组的方式加入，否则结果是[[]]
    if (!root.left && !root.right && !sum) res.push(path.slice())
    // 递归遍历左右子树
    dfs(root.left, sum)
    dfs(root.right, sum)
    // 当前路径遍历完成后，恢复现场
    path.pop()
  }
};

o36 二叉搜索树与双向链表

/**
 * 剑指 Offer 36. 二叉搜索树与双向链表
 * 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。
 */
/**
 * // Definition for a Node.
 * function Node(val,left,right) {
 *    this.val = val;
 *    this.left = left;
 *    this.right = right;
 * };
 */
/**
 * @param {Node} root
 * @return {Node}
 * 思路：中序遍历
 */
var treeToDoublyList = function(root) {
  let pre, head
  if (!root) return null
  dfs(root)

  // 遍历完成之后，此时pre指向的是尾结点
  // 循环双链表，首尾相连
  head.left = pre
  pre.right = head

  return head

  // 二叉搜索树，中序遍历是有序的
  function dfs(cur) {
    // 当前节点为空，返回
    if (!cur) return

    // 左子树
    dfs(cur.left)

    // 处理当前节点 pre:cur的左侧节点
    if(pre != null) pre.right = cur;
    else head = cur;
    cur.left = pre;
    pre = cur // pre后移

    // 右子树
    dfs(cur.right)
  }
};
LeetCode 面试经典 150 题回顾
张彦峰的博客
11-19 6万+
最经典 150 题，掌握面试所有知识点 面试经典 150 题 : 题目分析、解题思路、复杂度分析、代码展示
leetcode系列-二叉树
dafeng_xiaobai的博客
06-01 290
二叉树的理论基础 关于二叉树，你该了解这些！：二叉树的种类、存储方式、遍历方式、定义方式 public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode() {} TreeNode(int val) { this.val = val; } TreeNode(int val, TreeNode left, TreeNode right) {
Leetcode刷题总结——二叉树
weixin_47883447的博客
04-06 565
二叉树节点的定义： 1、二叉树的遍历 前序遍历（中左右）、中序遍历（左中右）、后序遍历（左右中） 递归三要素： 1）确定递归函数的参数和返回值：确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。 2）确定终止条件：写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。 3）.
二叉树leetcode
weixin_39915444的博客
11-17 375
144. 二叉树的前序遍历 class Solution(object): def preorderTraversal(self, root): """ :type root: TreeNode :rtype: List[int] """ if not root: return [] stack = [root] res = [] while s
二叉树（leetcode)
我的博客
01-13 598
预备知识： 二叉树 深度优先遍历 void dfs(TreeNode *root, vector&lt;vector&lt;int&gt;&gt;&amp; result, int &amp;path_sum, vector&lt;int&gt; &amp;path, int sum){ if(!root){ return; } //此时访问，前序 ...
LeetCode —— 二叉树
Archer__13的博客
12-29 542
LeetCode —— 二叉树
leetcode二叉树
qq_43283527的博客
04-08 616
树的属性： 层次结构 一个节点的所有子节点独立于另一个节点的子节点。 二叉树：如果树中的每个节点最多有两个子节点，我们说该树是一个二叉树。 1.列表表示的树 在列表树的列表中，将根节点的值存储为列表的第一个元素；第二个元素：一个表示左子树的列表；第三个元素：表示右子树的另一个列表。 2.节点表示 用left 和right 的属性表示其他实例的引用。 3 . 树的遍历 前序：首先访问根节点，然...
2024Java面试题之leetcode第637题二叉树的层平均值.zip
最新发布
07-26
2024java面试题 2024Java面试题之leetcode第637题二叉树的层平均值
解密Python+LeetCode面试题：二叉树最小深度求解
资源摘要信息:"本资源是一份针对编程面试题的Python解题代码，特别针对LeetCode平台上第111题——二叉树的最小深度问题的解答。在深入解析题目要求的基础上，提供了详细的Python代码实现，旨在帮助求职者在技术面试...
掌握leetcode面试题：二叉树视觉化处理技巧
在这个特定的leetcode卡标题中，列出了与二叉树相关的多个面试题目，这些问题不仅考察编程者对数据结构的理解和处理能力，同时还能测试他们的问题解决技巧。以下是对这些知识点的详细说明。 **检查所有叶子是否在...
python-leetcode面试题解之第101题对称二叉树-题解.zip
04-29
本压缩包文件“python-leetcode面试题解之第101题对称二叉树-题解.zip”专注于解决LeetCode上的第101题——对称二叉树。这道题目在Python编程语言下的解决方案是核心内容，对于准备Python相关职位面试的求职者来说...
Leetcode -二叉树
yuetan的博客
09-18 989
Leetcode
【LeetCode】-二叉树
银尘博客
03-15 7890
文章目录前言一、二叉树的层序遍历 前言 初识LeetCode与算法，将在此系列文章里面，记录自己的算法学习经历，前期主要是监督自己学习打卡，后期我会将自己对知识的理解，慢慢补充到文章当中，希望大家能在阅读我的文章中，有所收获。该系列文章的刷题顺序以代码随想录为线索。 一、二叉树的层序遍历 题目： 给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。 示例 1： 输入：root = [3,9,20,null,null,15,7] 输出：[[3],[9,20],[1
剑指 Offer 32 - I. 从上到下打印二叉树
Amberfd的博客
03-02 151
解法一 层次遍历 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { public: vector<int> lev.
leetcode——二叉树问题汇总
Michael_Jay的博客
03-12 1250
本章汇总了二叉树相关题目
leetcode刷穿二叉树（一）
e935052319的博客
05-25 247
带你刷穿leetcode二叉树系列（一），附优质题解+代码，每天五道题，简单到困难，小白到高手。 遇到树的问题再也不难受～
leetcode二叉树整理
weixin_41169280的博客
03-12 156
** 617题：合并二叉树 ** 使用递归解题，前序遍历，注意写清楚函数！！！
Leetcode041--两种方式构建二叉树
蜕变的快乐
03-11 564
通过两种方式来构建我们的二叉树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值