LeetCode刷题记-二叉树-二叉搜索树
700. 二叉搜索树中的搜索
题目：
给定二叉搜索树（BST）的根节点 root 和一个整数值 val。
你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。写题历程：
这道题只要抓住二叉搜索树的特性就很好做了，左边比根节点值小，右边比根节点值大，剩下的搜索，只是一些判断，然后递归搜索就行了
解法：
class Solution {
public TreeNode searchBST(TreeNode root, int val) {
if(root == null) return null;
if(root.val == val) return root;
if(root.val > val) {
return searchBST(root.left,val);
}
if(root.val < val) {
return searchBST(root.right,val);
}
return null;
}
}98. 验证二叉搜索树
题目：
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。
有效 二叉搜索树定义如下：
节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。写题历程：
一开始掉坑里了，只比较了左节点和右节点与当前节点的情况，但是!
二叉搜索树不是只对左右节点做要求呀，而是左右子树，是子树
或许左右节点确实满足条件了，但是左右节点的子节点呢，怕是不一定吧
在我意识到这个之后(其实是看题解才发现我掉坑了)，思考怎么整...
我们可以用一个变量去记录当前节点值，采用中序遍历的方式，先递归左子树，若当前节点值大于左结点值，记录当前节点值，再去递归右子树，最后左右子树相与返回
解法：
class Solution {
Long maxVal = -2147483649L;
public boolean isValidBST(TreeNode root) {
if(root == null) return true;
boolean leftTree = isValidBST(root.left);
if(!leftTree) return false;
if(root.val <= maxVal) return false;
maxVal = Long.valueOf(root.val);
boolean rightTree = isValidBST(root.right);
return leftTree && rightTree;
}
}530. 二叉搜索树的最小绝对差
题目：
给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。
差值是一个正数，其数值等于两值之差的绝对值。写题历程：
利用二叉搜索树的特性，根据中序遍历，使之有序，再来查找最小绝对差值
如何找最小绝对差值？第一，用一个变量记录答案，第二，用一个变量记录当前节点的上一节点的值，这样我们就可以计算差值，将差值更新到答案上，直至找到最小
解法:
class Solution {
Integer res = Integer.MAX_VALUE;
Integer pre = null; //记录前一个节点的值
public int getMinimumDifference(TreeNode root) {
if(root == null) return 0;
int left = getMinimumDifference(root.left);
if(pre != null) {
res = Math.min(res,root.val - pre);
}
pre = root.val;
int right = getMinimumDifference(root.right);
return res;
}
}501. 二叉搜索树中的众数
题目：
给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。
如果树中有不止一个众数，可以按 任意顺序 返回。
假定 BST 满足如下定义：
1. 结点左子树中所含节点的值 小于等于 当前节点的值
2. 结点右子树中所含节点的值 大于等于 当前节点的值
3. 左子树和右子树都是二叉搜索树写题历程：
二叉搜索树的重要性质：中序遍历后是一个非递减序列
因此问题简化成，在一个有序非递减数组中找出现频率最高的数
但是写的过程中，代码还是差点意思，考虑的情况不周
不仅要比较当前节点与上一个节点的值，还需要找到最高频率
通过多重判断，最后将集合转换成数组。思路上确实不难，但实现起来步骤还是有些许繁琐的
解法：
class Solution {
List list = new ArrayList<>();
Integer pre = null; //记录上一个节点的值
int maxFrequency = 0; //最大频率
int frequency = 0; //当前节点的出现频率
public int[] findMode(TreeNode root) {
searchMode(root);
return list.stream().mapToInt(Integer::intValue).toArray();
}
public void searchMode(TreeNode node) {
if(node == null) return;
searchMode(node.left);
if(pre != null && pre == node.val) frequency ++;
else frequency = 1; //如果不相同，频率只能为1，因为只出现一次
if(frequency > maxFrequency) {
maxFrequency = frequency; //更新最大频率
list.clear(); //加入集合的元素应该移除，因为有频率更高的数了
list.add(node.val);
} else if(frequency == maxFrequency) {
list.add(node.val);
}
pre = node.val;
searchMode(node.right);
}
} 235. 二叉搜索树的最近公共祖先
题目：
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]写题历程：
利用好搜索树的性质，左边小，右边大
那就可以比较根节点与左右子树节点的大小关系
均大于，递归左边；均小于，递归右边
在之间，则返回
解法：
class Solution {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
//经过中序遍历可以将二叉搜索树变成一个有序数组，找两个节点的最近公共祖先
//相当于在数组中[p,q]可以找到该最近公共祖先
//如何在数组中准确找到？如何排除其他元素？
if(root == null) return 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;
}
}701. 二叉搜索树中的插入操作
题目：
给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。
注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。写题历程：
有一说一，这题我思路来的挺快的，只是对于回溯的领悟还有点差距，回溯条件想错了
看了点提示后，再自己人工debug了下，弄清楚了
这种带有性质的树其实反而不用那么担心，正是因为特殊，而恰好能利用它的性质去解决
例如本题插入节点，我们只需判断下当前节点的值与要插入的值的大小关系，当前节点值大，则插到左边，反之右边，然后递归，遇到空就回溯，然后直接插入就行了
解法:
class Solution {
public TreeNode insertIntoBST(TreeNode root, int val) {
return traversal(root,val);
}
public TreeNode traversal(TreeNode root, int val) {
if(root == null) return new TreeNode(val); //如果是空树，直接用插入的节点创建一棵树
if(root.val > val) {
TreeNode left = traversal(root.left,val);
root.left = left; //回溯
}
if(root.val < val) {
TreeNode right = traversal(root.right,val);
root.right = right; //回溯
}
return root;
}
}450. 删除二叉搜索树中的节点
题目：
给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。
一般来说，删除节点可分为两个步骤：
首先找到需要删除的节点；
如果找到了，删除它。写题历程：
我本以为这题和在二叉搜索树中插入节点的思路差不多，没想到它需要考虑的情况这么多
首先最主要的是，删除节点会修改二叉搜索树的结构，即你删除完节点后，还需要调整为一颗二叉搜索树
分五种情况：
未找到目标节点，即根节点为空
找到目标节点
目标节点是叶子节点
目标节点的左子树为空，右子树不为空
目标节点的左子树不为空，右子树为空
目标节点的左右子树均不为空
具体理一下 目标节点的左右子树均不为空 的思路：
当目标节点的左右子树均不为空，且需要删除目标节点，首先目标节点的父节点必定要连接目标节点的子节点
其次，连接完毕后，还得保证这棵树仍然是一棵二叉搜索树
我们可以把目标节点的左右子树进行合并，再调整结构，最后与目标节点的父节点进行连接
具体实现：（将左子树合并到右子树）
利用一个临时节点指向目标节点的右子节点
遍历这棵子树找到此树的最左叶子节点
最左叶子节点去连接目标节点的左子树，即完成合并
最后一步，将目标节点删除，即目标节点的右节点成为新的根节点
当然，将右子树合并到左子树也是ok的，把里面左右修改下就行，答案不唯一
解法：
class Solution {
public TreeNode deleteNode(TreeNode root, int key) {
if(root == null) return root; //第一种情况
if(root.val == key) { //找到目标
if(root.left == null) return root.right; //这两行包含了二三四的情况
else if(root.right == null) return root.left;
else { //第五种情况
TreeNode cur = root.right;
while(cur.left != null) {
cur = cur.left;
}
cur.left = root.left;
root = root.right;
return root;
}
}
if(root.val > key) root.left = deleteNode(root.left,key);
if(root.val < key) root.right = deleteNode(root.right,key);
return root;
}
}669. 修剪二叉搜索树
题目：
给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。 可以证明，存在 唯一的答案 。
所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。写题历程：
我试着用删除节点的思路来解这题，其实还是可行的，就是遍历的顺序发生了变化，若用上题的思路，则需要后序遍历
其实先序遍历也可以搞定，反而会简单，只需要判断到当前节点的值不在范围内，再根据二叉搜索树的性质，左子树小，右子树大，即可以剪掉其某一边的子树，去递归另一边
解法：
/**
先序
**/
class Solution {
public TreeNode trimBST(TreeNode root, int low, int high) {
if(root == null) return root;
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;
}
}
/**
后序
**/
class Solution {
public TreeNode trimBST(TreeNode root, int low, int high) {
if(root == null) return root;
root.left = trimBST(root.left,low,high);
root.right = trimBST(root.right,low,high);
//不满足条件
if(root.val < low || root.val > high) {
if(root.left == null) return root.right;
else if(root.right == null) return root.left;
}
return root;
}
}108. 将有序数组转换为二叉搜索树
题目：
给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。
高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。写题历程：
前面反复提过，二叉搜索树的一个重要性质：中序遍历将变成一个非递减序列
而这一题不就恰好反过来而已吗
我们可以根据上述性质知道，数组中间的元素就是头节点，然后以此分割，左边的在左子树，右边的在右子树，递归一下即可
还有注意分割的时候，要遵循 循环不变量原则
解法：
class Solution {
public TreeNode sortedArrayToBST(int[] nums) {
return traversal(nums,0,nums.length);
}
public TreeNode traversal(int[] nums, int start,int end) {
if(start == end) return null;
int index = start + end >> 1;
TreeNode root = new TreeNode(nums[index]);
if(root == null) return root;
//左闭右开
root.left = traversal(nums,start,index);
root.right = traversal(nums,index + 1, end);
return root;
}
}538. 把二叉搜索树转换为累加树
题目：
给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。
提醒一下，二叉搜索树满足下列约束条件：
节点的左子树仅包含键 小于 节点键的节点。
节点的右子树仅包含键 大于 节点键的节点。
左右子树也必须是二叉搜索树。写题历程：
一开始没看懂题，小小地绕了一下，不过可以看出它有点像是反过来的二叉搜索树（个人的理解），即根节点的右边小，左边大
照着这个思路，再根据二叉搜索树的重要性质，可以知道它的中序遍历也是反的，也就是右中左，再就是累加树。至此，题目算是理清了
我们从从右到左递归遍历再累加，最后返回根节点，就可以搞定这题了
具体看代码...
解法：
class Solution {
Integer sum = 0; //累加器
public TreeNode convertBST(TreeNode root) {
convert(root);
return root;
}
public void convert(TreeNode root) {
if(root == null) return ;
convert(root.right); //右
//中
sum += root.val; //每多遍历一个节点，则多累加一个节点的值
root.val = sum; //将当前节点的值更新为累加值
convert(root.left); //左
}
}