# 代码随想录算法训练营第二十三天| 530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先

36 篇文章 0 订阅

## 530.二叉搜索树的最小绝对差

### 解题过程

#### 看到题目的第一想法

二叉树转换成数组是一个有序数组，那么将其转换为数组之后，从数组中找最小差值就很方便，甚至都省去了绝对值的步骤。

/**
* 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 getMinimumDifference = function(root) {
let ansArr = [];
const small = function(node){
if(node == null)return;
small(node.left);
ansArr.push(node.val);
small(node.right);
}
small(root);
let smallNum = Infinity;
for(let i = 0;i<ansArr.length-1;i++){
if((ansArr[i+1]-ansArr[i])<smallNum){
smallNum = ansArr[i+1]-ansArr[i];
}
}
return smallNum;
};

#### 看完代码随想录之后的想法

var getMinimumDifference = function (root) {
let arr = [];
const buildArr = (root) => {
if (root) {
buildArr(root.left);
arr.push(root.val);
buildArr(root.right);
}
}
buildArr(root);
let diff = arr[arr.length - 1];
for (let i = 1; i < arr.length; ++i) {
if (diff > arr[i] - arr[i - 1])
diff = arr[i] - arr[i - 1];
}
return diff;
};

## 501.二叉搜索树中的众数

### 解题过程

#### 看到题目的第一想法

/**
* 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 findMode = function (root) {
let nodeArr = [];
const makeArr = function (node) {
if (node == null) return;
makeArr(node.left);
nodeArr.push(node.val);
makeArr(node.right);
}
makeArr(root);
if (nodeArr.length == 1) return nodeArr;
let ans = [];
for(let i =1;i<nodeArr.length;i++){
if(nodeArr[i]==nodeArr[i-1]){
if(ans.length == 0)ans.push(nodeArr[i]);
else if(ans.length!=0&&ans[ans.length-1]==nodeArr[i]){
ans.push(nodeArr[i]);
}
}
}
return ans;
};

#### 看完代码随想录之后的想法

/**
* 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 findMode = function(root) {
// 不使用额外空间，使用中序遍历,设置出现最大次数初始值为1
let count = 0,maxCount = 1;
let pre = root,res = [];
// 1.确定递归函数及函数参数
const travelTree = function(cur) {
// 2. 确定递归终止条件
if(cur === null) {
return ;
}
travelTree(cur.left);
// 3. 单层递归逻辑
if(pre.val === cur.val) {
count++;
}else {
count = 1;
}
pre = cur;
if(count === maxCount) {
res.push(cur.val);
}
if(count > maxCount) {
res = [];
maxCount = count;
res.push(cur.val);
}
travelTree(cur.right);
}
travelTree(root);
return res;
};

### 总结

/**
* 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 findMode = function(root) {
// 使用递归中序遍历
let map = new Map();
// 1. 确定递归函数以及函数参数
const traverTree = function(root) {
// 2. 确定递归终止条件
if(root === null) {
return ;
}
traverTree(root.left);
// 3. 单层递归逻辑
map.set(root.val,map.has(root.val)?map.get(root.val)+1:1);
traverTree(root.right);
}
traverTree(root);
//上面把数据都存储到map
//下面开始寻找map里面的
// 定义一个最大出现次数的初始值为root.val的出现次数
let maxCount = map.get(root.val);
// 定义一个存放结果的数组res
let res = [];
for(let [key,value] of map) {
// 如果当前值等于最大出现次数就直接在res增加该值
if(value === maxCount) {
res.push(key);
}
// 如果value的值大于原本的maxCount就清空res的所有值，因为找到了更大的
if(value>maxCount) {
res = [];
maxCount = value;
res.push(key);
}
}
return res;
};

## 236. 二叉树的最近公共祖先

### 解题过程

#### 看到题目的第一想法

1. 此节点等于要找的某个节点，且此节点有某个子节点含有另一个要找的子节点：输出赋值；
2. 此节点等于要找的某个节点，且此节点没有某个子节点含有另一个要找的子节点：return true；
3. 此节点不等于要找的某个节点，且此节点两个子节点都含有另一个要找的子节点：输出赋值；
4. 此节点不等于要找的某个节点，return 左右子节点是否有要找的值的或；

/**
* Definition for a binary tree node.
* function TreeNode(val) {
*     this.val = val;
*     this.left = this.right = null;
* }
*/
/**
* @param {TreeNode} root
* @param {TreeNode} p
* @param {TreeNode} q
* @return {TreeNode}
*/
var lowestCommonAncestor = function(root, p, q) {
let ans = null;
const nearest = function(node){
if(node == null)return false;
let leftBo = nearest(node.left);
let rightBo =nearest(node.right);
if(node== p||node== q){
if(leftBo||rightBo){//如果当前节点等于某个值且子节点中含有另一个值
ans = node;
}else{//如果当前节点等于某个值且子节点中不含有另一个值
return true;
}
}else{//当前节点不等于某个值
if(leftBo&&rightBo){
ans = node;
}else{
return leftBo||rightBo;
}
}
}
nearest(root);
return ans;
};

#### 看完代码随想录之后的想法

/**
* Definition for a binary tree node.
* function TreeNode(val) {
*     this.val = val;
*     this.left = this.right = null;
* }
*/
/**
* @param {TreeNode} root
* @param {TreeNode} p
* @param {TreeNode} q
* @return {TreeNode}
*/
var lowestCommonAncestor = function(root, p, q) {
// 使用递归的方法
// 需要从下到上，所以使用后序遍历
// 1. 确定递归的函数
const travelTree = function(root,p,q) {
// 2. 确定递归终止条件
if(root === null || root === p || root === q) {
return root;
}
// 3. 确定递归单层逻辑
let left = travelTree(root.left,p,q);
let right = travelTree(root.right,p,q);
if(left !== null && right !== null) {
return root;
}
if(left === null) {
return right;
}
return left;
}
return  travelTree(root,p,q);
};

### 总结

这种需要一层一层向上传递的，直接无脑后序。

• 23
点赞
• 6
收藏
觉得还不错? 一键收藏
• 1
评论

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