文章目录
二叉搜索树
二叉搜索树,左子结点小于根结点小于右子节点。
递归怎么写?
1.总结规律,你知道你是在写一个递归方法,那么就得定义出这个递归方法是干什么的。
2.调用自己
3.跳出条件,跳出时的判断条件是什么以及当前条件下该返回什么。
需要注意的是,如果你的跳出条件有问题的话,递归很容易产生stackoverflow。
669. 修剪二叉搜索树
给定一个二叉搜索树,同时给定最小边界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
//BST 二叉查找树,根节点大于左结点,小于右结点
//对树进行遍历,去分析哪些值需要被剪掉,哪些被保留
class Solution {
public TreeNode trimBST(TreeNode root, int L, int R) {
if (root == null) return root;
if (root.val > R) return trimBST(root.left, L, R); //比R大,向左修减
if (root.val < L) return trimBST(root.right, L, R);//向右修剪
//两边修剪,存在在【R,L】区间范围内
root.left = trimBST(root.left, L, R);
root.right = trimBST(root.right, L, R);
return root;
}
}
230. 二叉搜索树
给定一个二叉搜索树,编写一个函数 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
二叉搜索树的中序就是一个从小到大排序的序列,因此这道题可以通过中序遍历来做。
//第k个最小的元素
//中序遍历 利用二叉搜索树的性质排列
//从小到大排列
class Solution {
public int kthSmallest(TreeNode root, int k) {
Stack<TreeNode> stack = new Stack<>();
while(true){
while(root != null){
stack.push(root);
root = root.left;
}
root = stack.pop();
if(--k == 0) return root.val;
root = root.right;
}
}
}
538. 把二叉搜索树转换成累加树
给定一个二叉搜索树(Binary Search Tree),把它转换成为累加树(Greater Tree),使得每个节点的值是原来的节点值加上所有大于它的节点值之和。
输入: 二叉搜索树:
5
/ \
2 13
输出: 转换为累加树:
18
/ \
20 13
//此题是将大于自身结点的值都累计相加
//相当于遍历整棵树,先遍历右-中-左
//变形的中序遍历
class Solution {
//定义一个变量来记录走过的结点的和
public int sum = 0;
public TreeNode convertBST(TreeNode root) {
traver(root);
return root;
}
//定义一个函数
private void traver(TreeNode node){
if(node == null) return;
traver(node.right);
sum += node.val;//将走过的结点累计相加
node.val = sum;
traver(node.left);
}
}
公共祖先
235. 二叉搜索树的公共祖先
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为:“对于有根树 T 的两个结点 p、q,最近公共祖先表示为一个结点 x,满足 x 是 p、q 的祖先且 x 的深度尽可能大(一个节点也可以是它自己的祖先)。”
例如,给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]
//因为该树为二叉搜索树,只要p和q在同一颗子树上就一直沿着这颗子树往下走
//(这意味着p和q都同时大于或者小于当前指向的根结点)。
class Solution {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
//找合适的位置,把它放进去
TreeNode pointer = root;
while(pointer != null){
if(pointer.val > p.val && pointer.val > q.val){
pointer = pointer.left;
}else if(pointer.val < p.val && pointer.val < q.val){
pointer = pointer.right;
}else{
return pointer;
}
}
return pointer;
}
}
236. 二叉树的最近公共祖先
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为:“对于有根树 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。因为根据定义最近公共祖先节点可以为节点本身。
class Solution {
//功能:给定p和q,如果p和q存在,就返回最近的公共结点,
//如果只有一个存在,那就返回那一个,如果都不存在,就返回空
public TreeNode lowestCommonAncestor(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);
if(left == null) return right;//都在右边
if(right == null) return left;//都在左边
if(left != null && right != null) return root;//分散在两边
return null;
}
}
转换成二叉搜索树
108. 将有序数组转换成二叉搜索树
将一个按照升序排列的有序数组,转换为一棵高度平衡二叉搜索树。
本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
给定有序数组: [-10,-3,0,5,9],
一个可能的答案是:[0,-3,9,-10,null,5],它可以表示下面这个高度平衡二叉搜索树:
0
/ \
-3 9
/ /
-10 5
//以中间结点为根节点,递归构建左右子数;
class Solution {
public TreeNode sortedArrayToBST(int[] nums) {
return BST(nums, 0 ,nums.length-1);
}
public TreeNode BST(int[] nums, int l, int r){
if(l > r) return null;
int mid = (l+r)/2;
TreeNode root = new TreeNode(nums[mid]);
//向左递归
root.left = BST(nums, l , mid-1);
//向右递归
root.right = BST(nums, mid+1 ,r);
return root;
}
}
109. 将有序链表转换成二叉搜索树
给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树。
本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
示例:
给定的有序链表: [-10, -3, 0, 5, 9],
一个可能的答案是:[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树:
0
/ \
-3 9
/ /
-10 5
109题和108题不同的是,108题是将一个有序数组转换成二叉搜索,109题是将有序链表转换成二叉搜索树,有序数组的中间值很好找,而链表的中间值则需要通过快慢指针来找到
class Solution {
public TreeNode sortedListToBST(ListNode head) {
if(head == null) return null;
return buildBST(head, null);
}
public TreeNode buildBST(ListNode head, ListNode tail){
if(head == null || head == tail) return null;
ListNode fast = head;
ListNode slow = head;
//注意这里是tail
while(fast != tail && fast.next != tail){
fast = fast.next.next;
slow = slow.next;
}
TreeNode root = new TreeNode(slow.val);
root.left = buildBST(head, slow);
root.right = buildBST(slow.next, tail);
return root;
}
}
653. 两数之和 IV – 输入BST
给定一个二叉搜索树和一个目标结果,如果 BST 中存在两个元素且它们的和等于给定的目标结果,则返回 true。
案例 1:
输入:
5
/ \
3 6
/ \ \
2 4 7
Target = 9
输出: True
案例 2:
输入:
5
/ \
3 6
/ \ \
2 4 7
Target = 28
输出: False
class Solution {
public boolean findTarget(TreeNode root, int k) {
List<Integer> list = new ArrayList<>();
inOrder(root, list);
int i = 0;
int j = list.size()-1;
while(i<j){
int sum = list.get(i) + list.get(j);
if(sum == k) return true;
else if(sum < k) i++;
else j--;
}
return false;
}
public void inOrder(TreeNode root, List<Integer> list){
if(root == null) return;
inOrder(root.left, list);
list.add(root.val);
inOrder(root.right, list);
}
}
530. 二叉搜索树的绝对最小值之差
给定一个所有节点为非负值的二叉搜索树,求树中任意两节点的差的绝对值的最小值
输入:
1
\
3
/
2
输出:
1
解释:
最小绝对差为1,其中 2 和 1 的差的绝对值为 1(或者 2 和 3)。
class Solution {
public int getMinimumDifference(TreeNode root) {
List<Integer> list = new ArrayList<>();
inOrder(root, list);
int minDiff = Integer.MAX_VALUE;
//使其最小值无穷大,然后用其它值去更新最小值
//排好序的二叉搜索树,差最小的两个点必然相邻;
for(int i = 1; i < list.size(); i++){
minDiff = Math.min(minDiff, list.get(i) - list.get(i-1));
}
return minDiff;
}
public void inOrder(TreeNode node, List<Integer> list){
if(node == null) return;
inOrder(node.left, list);
list.add(node.val);
inOrder(node.right, list);
}
}