给定一个二叉搜索树,同时给定最小边界L 和最大边界 R。通过修剪二叉搜索树,使得所有节点的值在[L, R]中 (R>=L) 。你可能需要改变树的根节点,所以结果应当返回修剪好的二叉搜索树的新的根节点。
示例 1:
输入:
1
/ \
0 2
L = 1
R = 2
输出:
1
\
2
示例 2:
输入:
3
/ \
0 4
\
2
/
1
L = 1
R = 3
输出:
3
/
2
/
1
public TreeNode trimBST(TreeNode root, int L, int R) {
if(root==null)return null;
if(root.val>R) return trimBST(root.left,L,R);
if(root.val<L)return trimBST(root.right,L,R);
root.left=trimBST(root.left,L,R);
root.right=trimBST(root.right,L,R);
return root;
}
给定一个二叉搜索树,编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。
说明:
你可以假设 k 总是有效的,1 ≤ k ≤ 二叉搜索树元素个数。
示例 1:
输入: root = [3,1,4,null,2], k = 1
3
/ \
1 4
\
2
输出: 1
示例 2:
输入: root = [5,3,6,2,4,null,null,1], k = 3
5
/ \
3 6
/ \
2 4
/
1
输出: 3
private int cnt=0;
private int val;
public int kthSmallest(TreeNode root, int k) {
inorder(root,k);
return val;
}
private void inorder(TreeNode root,int k){
if(root==null)return ;
inorder(root.left,k);
cnt++;
if(cnt==k){
val=root.val;
return;
}
inorder(root.right,k);
}
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为:“对于有根树 T 的两个结点 p、q,最近公共祖先表示为一个结点 x,满足 x 是 p、q 的祖先且 x 的深度尽可能大(一个节点也可以是它自己的祖先)。”
例如,给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]
示例 1:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6
解释: 节点 2 和节点 8 的最近公共祖先是 6。
示例 2:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。
说明:
所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉搜索树中。
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
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;
}
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为:“对于有根树 T 的两个结点 p、q,最近公共祖先表示为一个结点 x,满足 x 是 p、q 的祖先且 x 的深度尽可能大(一个节点也可以是它自己的祖先)。”
例如,给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]
示例 1:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出: 3
解释: 节点 5 和节点 1 的最近公共祖先是节点 3。
示例 2:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出: 5
解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。
说明:
所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉树中。
注意:是二叉树
public TreeNode lowestCommonAncestor2(TreeNode root, TreeNode p, TreeNode q) {
if(root==null||root==p||root==q)return root;
TreeNode left=lowestCommonAncestor(root.left,p,q);
TreeNode right=lowestCommonAncestor(root.right,p,q);
return left==null?right:right==null?left:root;
}
将一个按照升序排列的有序数组,转换为一棵高度平衡二叉搜索树。
本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
示例:
给定有序数组: [-10,-3,0,5,9],
一个可能的答案是:[0,-3,9,-10,null,5],它可以表示下面这个高度平衡二叉搜索树:
0
/ \
-3 9
/ /
-10 5
public TreeNode sortedArrayToBST(int[] nums) {
return toBST(nums,0,nums.length-1);
}
private TreeNode toBST(int[] nums,int sIdx,int eIdx){
if(sIdx>eIdx)return null;
int mIdx=(sIdx+eIdx)/2;
TreeNode root=new TreeNode(nums[mIdx]);
root.left=toBST(nums,sIdx,mIdx-1);
root.right=toBST(nums,mIdx+1,eIdx);
return root;
}
给定一个二叉搜索树和一个目标结果,如果 BST 中存在两个元素且它们的和等于给定的目标结果,则返回 true。
案例 1:
输入:
5
/ \
3 6
/ \ \
2 4 7
Target = 9
输出: True
案例 2:
输入:
5
/ \
3 6
/ \ \
2 4 7
Target = 28
输出: False
public boolean findTarget(TreeNode root, int k) {
List<Integer> nums=new ArrayList<>();
inorder1(root,nums);
int i=0,j=nums.size()-1;
while(i<j){
int sum=nums.get(i)+nums.get(j);
if(sum==k)return true;
if(sum<k)i++;
else j--;
}
return false;
}
private void inorder1(TreeNode root,List<Integer> nums){
if(root==null)return;
inorder1(root.left,nums);
nums.add(root.val);
inorder1(root.right,nums);
}
给定一个所有节点为非负值的二叉搜索树,求树中任意两节点的差的绝对值的最小值。
示例 :
输入:
1
\
3
/
2
输出:
1
解释:
最小绝对差为1,其中 2 和 1 的差的绝对值为 1(或者 2 和 3)。
注意: 树中至少有2个节点。
private void inorder1(TreeNode root,List<Integer> nums){
if(root==null)return;
inorder1(root.left,nums);
nums.add(root.val);
inorder1(root.right,nums);
}
public int getMinimumDifference(TreeNode root) {
List<Integer> res=new ArrayList<>();
inorder1(root,res);
int ans=Math.abs(res.get(0)-res.get(1));
System.out.println(ans);
int j=1;
while(j+1<res.size()){
ans=Math.min(Math.abs(res.get(j+1)-res.get(j)),ans);
j++;
}
return ans;
}