TypeScript算法题实战——二叉搜索树篇_traverse 有序列表 二叉搜索树(3)

        return;
    traverse(root.left);
    traveseArr.push(root.val);
    traverse(root.right);
}

for(let i = 0; i < traveseArr.length; i++){
    countMap.set(traveseArr[i], (countMap.get(traveseArr[i]) || 0) + 1);
}
const countArr: number[][] = Array.from(countMap);
countArr.sort((a, b) => {
    return b[1] - a[1];
})
const resArr: number[] = [];
const maxCount: number = countArr[0][1];
for (let i of countArr) {
    if (i[1] === maxCount) resArr.push(i[0]);
}
return resArr;

};

在代码中使用到了， `const countArr: number[][] = Array.from(countMap);`，可以将countMap（类型为哈希Map）转换成二维数组，数组为一个n行2列数组，第一列为出现的数字，第二列为对应数字出现的次数，这样就可以很好进行操作并得到众数了。


## 三、求二叉搜索树的最近公共祖先


### 3.1、题目描述


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


力扣链接：https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree/  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/532b459c23a54ab4a018e596fedc24f0.png)


### 3.2、题解


首先我们做一题普通二叉树的**最近公共祖先**，可以用递归来做，最近公共祖先有一个特点就是：p和q来自于（1）左子树，（2）右子树，（3）根节点的三者其中之二。

function lowestCommonAncestor(root: TreeNode | null, p: TreeNode | null, q: TreeNode | null): TreeNode | null {
if(root == null)
return root;
if(root == p || root == q)
return root;
const left = lowestCommonAncestor(root.left, p, q);
const right = lowestCommonAncestor(root.right, p, q);
// 即第一次在该节点的左子树和右子树上分别找到了p 和 q
if(left !== null && right !== null) return root;
// 暂时只找到一个
if(left != null) return left;
if(right != null) return right;
// 一个都没找到
return null;
};

而 **求二叉搜索树的最近公共祖先** 需要在上一题的基础上，利用一下“**二叉搜索树是有序的**”这个特点，即从根开始找，如果根节点大于p也大于q，则往左子树找，如果根节点小于q也小于p，则往右子树找，如果不满足同时小于或者大于，那么他就是我们要的最近公共祖先。

function lowestCommonAncestor(root: TreeNode | null, p: TreeNode | null, q: TreeNode | null): TreeNode | null {
if(root.val > p.val && root.val > q.val){
return lowestCommonAncestor(root.left, p , q);
}
if(root.val < p.val && root.val <q.val){
return lowestCommonAncestor(root.right, p, q);
}
return root;
};

## 四、二叉搜索树中的插入操作


### 4.1、题目描述


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


注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果  
 力扣链接：https://leetcode.cn/problems/insert-into-a-binary-search-tree


### 4.2、题解


我们选择不改变树的结构，而是往空结点里面插值，这样做就简单很多，首先判断当前根节点为不为空，若为空则新建一个值为val的结点，返回，若不为空则判断其根节点的值是大于val还是小于val，使用递归的思想，根值大于val就去改左子树，根值小于val就去改右子树。

function insertIntoBST(root: TreeNode | null, val: number): TreeNode | null {
if(root == null){
let res: TreeNode = new TreeNode(val)
return res;
}

if(root.val > val)
    root.left = insertIntoBST(root.left, val);
else if(root.val < val)
    root.right =insertIntoBST(root.right, val);
return root;

};

## 五、删除二叉搜索树中的节点


### 5.1、题目描述


给定一个二叉搜索树的根节点 `root` 和一个值 `key`，删除二叉搜索树中的 `key` 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。


力扣链接：https://leetcode.cn/problems/delete-node-in-a-bst


### 5.2、题解


一般来说，删除节点可分为两个步骤：首先找到需要删除的节点；如果找到了，删除它。我们主要把算法分成三大块：删除节点的部分、寻找待删除节点的部分，递归返回的部分。


可以利用到二叉搜索树的特性寻找到待删除节点，然后删除节点的方法是把右子树的根节点提上来带他当前节点，然后右子树的最左子节点的左节点接当前左子树。

function deleteNode(root: TreeNode | null, key: number): TreeNode | null {
if (root === null) return null;
//删除节点
if(root.val === key){
if (root.left === null && root.right === null) return null;
else if (root.left === null) return root.right;
else if (root.right === null) return root.left;
// 把右子树的最左子节点续上
let curNode: TreeNode = root.right;
while (curNode.left !== null) {
curNode = curNode.left;
}
curNode.left = root.left;
return root.right;
}
//寻找节点
else if(root.val < key){
root.right = deleteNode(root.right, key);
}
else if(root.val > key){
root.left = deleteNode(root.left, key);
}
//返回
return root;
};

## 六、修剪二叉搜索树


### 6.1、题目描述


给定一个**二叉搜索树**，同时给定最小边界`L` 和最大边界 `R`。通过修剪二叉搜索树，使得所有节点的值在`[L, R]`中 `(R>=L)` 。你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。  
 题目链接：https://leetcode.cn/problems/trim-a-binary-search-tree/


### 6.2、题解


如果当前节点值小于low，则切除左子树以及根节点，如果当前节点值大于high，则切除右子树以及根节点，如果当前节点值在low和high的其中，那么就递归到左子树和右子树进行后续操作。

function trimBST(root: TreeNode | null, low: number, high: number): TreeNode | null {
if (root === null) return null;
if (root.val < low) {
return trimBST(root.right, low, high);
}
if (root.val > high) {
return trimBST(root.left, low, high);
}
root.left = trimBST(root.left, low, high);
root.right = trimBST(root.right, low, high);
return root;
};

## 七、将有序数组转换为二叉搜索树


### 7.1、题目描述


给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。


**高度平衡** **二叉树**是一棵满足「`每个节点的左右两个子树的高度差的绝对值不超过 1` 」的二叉树。


力扣链接：https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree


### 7.2、题解


使用二分法加递归的思想，首先要保证高度平衡，且在满足二叉搜索树的前提下，根节点需要选择为该有序数组的中间值，然后左子树即是该值左边的部分，右子树则是其右边的部分，递归继续即可：

function sortedArrayToBST(nums: number[]): TreeNode | null {
if(nums == null)
return null;
else
return recur(nums, 0, nums.length - 1);
function recur(nums:number[], left:number, right:number):TreeNode{
if(left === right){
let res:TreeNode = new TreeNode(nums[left]);
return res;
}
if(left > right)
return null;
let mid = Math.floor((right + left + 1) / 2);
let res:TreeNode = new TreeNode(nums[mid]);
res.left = recur(nums, left, mid - 1);
res.right = recur(nums, mid + 1 , right);
return res;
}
};

## 八、把二叉搜索树转换为累加树


### 8.1、题目描述


给出二叉 **搜索** 树的根节点，该树的节点值各不相同，请你将其转换为累加树`（Greater Sum Tree）`，使每个节点 **node** 的新值等于原树中大于或等于 **node.val** 的值之和。  


![img](https://img-blog.csdnimg.cn/img_convert/4af4e33bbdea9303a81f69cee46b93c9.png)
![img](https://img-blog.csdnimg.cn/img_convert/8fad84419c0f33baed3ced0216a48169.png)
![img](https://img-blog.csdnimg.cn/img_convert/ef2c662f704f6ce1bb98613171d76ec5.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**

24121693)]
[外链图片转存中...(img-brISO7OD-1714424121694)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**