每日算法&面试题，大厂特训二十八天——第二十一天（树）

导读

肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！
适合面试和比赛的算法目录：传送门

特别介绍

📣小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶

📣python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章，可以让你快乐学python练手项目专栏

📣另外想学JavaWeb进厂的同学可以看看这个专栏：传送们

📣这是个冲刺大厂面试专栏还有算法比赛练习我们一起加油 上岸之路

算法特训二十八天

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

输入：root = [4,2,7,1,3], val = 2
输出：[2,1,3]

输入：root = [4,2,7,1,3], val = 5
输出：[]

思路：二叉搜索树满足如下性质：

左子树所有节点的元素值均小于根的元素值； 右子树所有节点的元素值均大于根的元素值。

初始部分：
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        if (root == null) {
            return null;
        }
        if (val == root.val) {
            return root;
        }
        return searchBST(val < root.val ? root.left : root.right, val);
    }
}

给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据
保证 ，新值和原始二叉搜索树中的任意节点值都不同。

注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。

输入：root = [4,2,7,1,3], val = 5
输出：[4,2,7,1,3,5]
解释：另一个满足题目要求可以通过的树是：

输入：root = [40,20,60,10,30,50,70], val = 25
输出：[40,20,60,10,30,50,70,null,null,25]

示例 3：

输入：root = [4,2,7,1,3,null,null,null,null,null,null], val = 5
输出：[4,2,7,1,3,5]

思路：首先回顾二叉搜索树的性质：对于任意节点 \textit{root}root 而言，左子树（如果存在）上所有节点的值均小于 \textit{root.val}root.val，右子树（如果存在）上所有节点的值均大于 \textit{root.val}root.val，且它们都是二叉搜索树。

因此，当将 \textit{val}val 插入到以 \textit{root}root 为根的子树上时，根据
\textit{val}val 与 \textit{root.val}root.val 的大小关系，就可以确定要将
\textit{val}val 插入到哪个子树中。

如果该子树不为空，则问题转化成了将 \textit{val}val 插入到对应子树上。 否则，在此处新建一个以
\textit{val}val 为值的节点，并链接到其父节点 \textit{root}root 上。

初始部分：
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

解题部分：
class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        if (root == null) {
            return new TreeNode(val);
        }
        TreeNode pos = root;
        while (pos != null) {
            if (val < pos.val) {
                if (pos.left == null) {
                    pos.left = new TreeNode(val);
                    break;
                } else {
                    pos = pos.left;
                }
            } else {
                if (pos.right == null) {
                    pos.right = new TreeNode(val);
                    break;
                } else {
                    pos = pos.right;
                }
            }
        }
        return root;
    }
}

面试题

一个对象的两个方法加 synchronized，一个线程进去 sleep，另一个线程
可以进入到另一个方法吗？
不能

什么是可重入锁（ReentrantLock）？

举例来说明锁的可重入性
public class UnReentrant{
Lock lock = new Lock();
public void outer(){
lock.lock();
inner();
lock.unlock();
}
public void inner(){
lock.lock();
//do something
lock.unlock();
}
}
outer 中调用了 inner，outer 先锁住了 lock，这样 inner 就不能再获取 lock。其实调用
outer 的线程已经获取了 lock 锁，但是不能在 inner 中重复利用已经获取的锁资源，这种
锁即称之为不可重入可重入就意味着：线程可以进入任何一个它已经拥有的锁所同步着的代码
块。
synchronized、ReentrantLock 都是可重入的锁，可重入锁相对来说简化了并发编程的开发

点击直接资料领取

这里有python，Java学习资料还有有有趣好玩的编程项目，更有难寻的各种资源。反正看看也不亏。